- Main Page
- Related Pages
- Modules
- Classes
- Examples

# animImportExport.cpp

    //-
    // ==========================================================================
    // Copyright (C) 1995 - 2006 Autodesk, Inc. and/or its licensors.  All
    // rights reserved.
    //
    // The coded instructions, statements, computer programs, and/or related
    // material (collectively the "Data") in these files contain unpublished
    // information proprietary to Autodesk, Inc. ("Autodesk") and/or its
    // licensors, which is protected by U.S. and Canadian federal copyright
    // law and by international treaties.
    //
    // The Data is provided for use exclusively by You. You have the right
    // to use, modify, and incorporate this Data into other products for
    // purposes authorized by the Autodesk software license agreement,
    // without fee.
    //
    // The copyright notices in the Software and this entire statement,
    // including the above license grant, this restriction and the
    // following disclaimer, must be included in all copies of the
    // Software, in whole or in part, and all derivative works of
    // the Software, unless such copies or derivative works are solely
    // in the form of machine-executable object code generated by a
    // source language processor.
    //
    // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND.
    // AUTODESK DOES NOT MAKE AND HEREBY DISCLAIMS ANY EXPRESS OR IMPLIED
    // WARRANTIES INCLUDING, BUT NOT LIMITED TO, THE WARRANTIES OF
    // NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
    // PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE, OR
    // TRADE PRACTICE. IN NO EVENT WILL AUTODESK AND/OR ITS LICENSORS
    // BE LIABLE FOR ANY LOST REVENUES, DATA, OR PROFITS, OR SPECIAL,
    // DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES, EVEN IF AUTODESK
    // AND/OR ITS LICENSORS HAS BEEN ADVISED OF THE POSSIBILITY
    // OR PROBABILITY OF SUCH DAMAGES.
    //
    // ==========================================================================
    //+

    //
    //  File Name:  animImport.cc
    //
    //  Description:
    //      Imports a .anim file into anim curves attached to the selected
    //      Maya objects.
    //

    #include <stdlib.h>
    #include <string.h>

    #include <maya/MFStream.h>
    #include <maya/MGlobal.h>
    #include <maya/MString.h>
    #include <maya/MFnPlugin.h>
    #include <maya/MPxFileTranslator.h>

    #include <maya/MSelectionList.h>

    #include <maya/MFnAnimCurve.h>
    #include <maya/MAnimCurveClipboard.h>
    #include <maya/MAnimCurveClipboardItem.h>
    #include <maya/MAnimCurveClipboardItemArray.h>

    #include "animImportExport.h"
    #include "animFileUtils.h"
    #include "animImportExportStrings.h"

    #if defined (OSMac_)
    #   include <sys/param.h>
    extern "C" int strcasecmp (const char *, const char *);
    #endif
    //-----------------------------------------------------------------------------
    //  anim Importer
    //-----------------------------------------------------------------------------

    const char *const animImportOptionScript = "animImportOptions";
    const char *const animImportDefaultOptions =
        "targetTime=4;copies=1;option=replace;pictures=0;connect=0;";

    // Register all strings used by the plugin C++ code
    static MStatus registerMStringResources(void)
    {
        MStringResource::registerString(kNothingSelected);
        MStringResource::registerString(kPasteFailed);
        MStringResource::registerString(kAnimCurveNotFound);
        MStringResource::registerString(kInvalidAngleUnits);
        MStringResource::registerString(kInvalidLinearUnits);
        MStringResource::registerString(kInvalidTimeUnits);
        MStringResource::registerString(kInvalidVersion);
        MStringResource::registerString(kSettingToUnit);
        MStringResource::registerString(kMissingKeyword);
        MStringResource::registerString(kCouldNotReadAnim);
        MStringResource::registerString(kCouldNotCreateAnim);
        MStringResource::registerString(kUnknownKeyword);
        MStringResource::registerString(kClipboardFailure);
        MStringResource::registerString(kSettingTanAngleUnit);
        MStringResource::registerString(kUnknownNode);
        MStringResource::registerString(kCouldNotKey);
        MStringResource::registerString(kMissingBrace);
        MStringResource::registerString(kCouldNotExport);
        return MS::kSuccess;
    }

    animImport::animImport()
    : MPxFileTranslator()
    {
    }

    animImport::~animImport()
    {
    }

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

    MStatus animImport::reader( const MFileObject& file,
                                    const MString& options,
                                    FileAccessMode mode)
    {
        MStatus status = MS::kFailure;

        MString fileName = file.fullName();
    #if defined (OSMac_)
        char fname[MAXPATHLEN];
        strcpy (fname, fileName.asChar());
        ifstream animFile(fname);
    #else
        ifstream animFile(fileName.asChar());
    #endif
        //  Parse the options. The options syntax is in the form of
        //  "flag=val;flag1=val;flag2=val"
        //
        MString pasteFlags;
        if (options.length() > 0) {
            //  Set up the flags for the paste command.
            //
            const MString flagTargetTime("targetTime");
            const MString flagTime("time");
            const MString flagCopies("copies");
            const MString flagOption("option");
            const MString flagConnect("connect");

            MString copyValue;
            MString flagValue;
            MString connectValue;
            MString timeValue;

            //  Start parsing.
            //
            MStringArray optionList;
            MStringArray theOption;
            options.split(';', optionList);

            unsigned nOptions = optionList.length();
            for (unsigned i = 0; i < nOptions; i++) {

                theOption.clear();
                optionList[i].split('=', theOption);
                if (theOption.length() < 1) {
                    continue;
                }

                if (theOption[0] == flagCopies && theOption.length() > 1) {
                    copyValue = theOption[1];;
                } else if (theOption[0] == flagOption && theOption.length() > 1) {
                    flagValue = theOption[1];
                } else if (theOption[0] == flagConnect && theOption.length() > 1) {
                    if (theOption[1].asInt() != 0) {
                        connectValue += theOption[1];
                    }
                } else if (theOption[0] == flagTime && theOption.length() > 1) {
                    timeValue += theOption[1];
                }
            }

            if (copyValue.length() > 0) {
                pasteFlags += " -copies ";
                pasteFlags += copyValue;
                pasteFlags += " ";
            }
            if (flagValue.length() > 0) {
                pasteFlags += " -option \"";
                pasteFlags += flagValue;
                pasteFlags += "\" ";
            }
            if (connectValue.length() > 0) {
                pasteFlags += " -connect ";
                pasteFlags += connectValue;
                pasteFlags += " ";
            }
            if (timeValue.length() > 0) {
                bool useQuotes = !timeValue.isDouble();
                pasteFlags += " -time ";
                if (useQuotes) pasteFlags += "\"";
                pasteFlags += timeValue;
                if (useQuotes) pasteFlags += "\"";
                pasteFlags += " ";
            }
        }

        if (mode == kImportAccessMode) {
            status = importAnim(animFile, pasteFlags);
        }

        animFile.close();
        return status;
    }

    bool animImport::haveReadMethod() const
    {
        return true;
    }

    bool animImport::haveWriteMethod() const
    {
        return false;
    }

    bool animImport::canBeOpened() const
    {
        return false;
    }

    MString animImport::defaultExtension() const
    {
        return MString("anim");
    }

    MPxFileTranslator::MFileKind animImport::identifyFile(
                                    const MFileObject& fileName,
                                    const char* buffer,
                                    short size) const
    {
        const char *name = fileName.name().asChar();
        int   nameLength = (int)strlen(name);

        if ((nameLength > 5) && !strcasecmp(name+nameLength-5, ".anim")) {
            return kIsMyFileType;
        }

        //  Check the buffer to see if this contains the correct keywords
        //  to be a anim file.
        //
        if (strncmp(buffer, "animVersion", 11) == 0) {
            return kIsMyFileType;
        }

        return  kNotMyFileType;
    }

    MStatus
    animImport::importAnim(ifstream &animFile, const MString &pasteFlags)
    {
        MStatus status = MS::kFailure;
        MAnimCurveClipboard::theAPIClipboard().clear();

        //  If the selection list is empty, there is nothing to import.
        //
        MSelectionList sList;
        MGlobal::getActiveSelectionList(sList);
        if (sList.isEmpty()) {
            MString msg = MStringResource::getString(kNothingSelected, status);
            MGlobal::displayError(msg);
            return (MS::kFailure);
        }

        if (MS::kSuccess !=
                (status = fReader.readClipboard(animFile,
                MAnimCurveClipboard::theAPIClipboard()))) {

            return status;
        }

        if (MAnimCurveClipboard::theAPIClipboard().isEmpty()) {
            return (MS::kFailure);
        }

        MString command("pasteKey -cb api ");
        command += pasteFlags;

        int result;
        if (MS::kSuccess != (status =
            MGlobal::executeCommand(command, result, false, true))) {
            MString msg = MStringResource::getString(kPasteFailed, status);
            MGlobal::displayError(msg);
            return status;
        }

        return status;
    }

    //-----------------------------------------------------------------------------
    //  anim Exporter
    //-----------------------------------------------------------------------------

    const char *const animExportOptionScript = "animExportOptions";
    const char *const animExportDefaultOptions = "precision=8;nodeNames=1;verboseUnits=0;whichRange=1;range=0:10;options=keys;hierarchy=none;controlPoints=0;shapes=1;helpPictures=0;useChannelBox=0;copyKeyCmd=";

    const int kDefaultPrecision = 8;    //  float precision.

    animExport::animExport()
    : MPxFileTranslator()
    {
    }

    animExport::~animExport()
    {
    }

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

    MStatus animExport::writer( const MFileObject& file,
                                    const MString& options,
                                    FileAccessMode mode)
    {
        MStatus status = MS::kFailure;

    #ifdef MAYA_EVAL_VERSION
        status = MS::kFailure;
        return status;
    #endif

        MString fileName = file.fullName();
    #if defined (OSMac_)
        char fname[MAXPATHLEN];
        strcpy (fname, fileName.asChar());
        ofstream animFile(fname);
    #else
        ofstream animFile(fileName.asChar());
    #endif
        //  Defaults.
        //
        MString copyFlags("copyKey -cb api -fea 1 ");
        int precision = kDefaultPrecision;
        bool nodeNames = true;
        bool verboseUnits = false;

        //  Parse the options. The options syntax is in the form of
        //  "flag=val;flag1=val;flag2=val"
        //
        MString exportFlags;
        if (options.length() > 0) {
            const MString flagPrecision("precision");
            const MString flagNodeNames("nodeNames");
            const MString flagVerboseUnits("verboseUnits");
            const MString flagCopyKeyCmd("copyKeyCmd");

            //  Start parsing.
            //
            MStringArray optionList;
            MStringArray theOption;
            options.split(';', optionList);

            unsigned nOptions = optionList.length();
            for (unsigned i = 0; i < nOptions; i++) {
                theOption.clear();
                optionList[i].split('=', theOption);
                if (theOption.length() < 1) {
                    continue;
                }

                if (theOption[0] == flagPrecision && theOption.length() > 1) {
                    if (theOption[1].isInt()) {
                        precision = theOption[1].asInt();
                    }
                } else if ( theOption[0] ==
                            flagNodeNames && theOption.length() > 1) {
                    if (theOption[1].isInt()) {
                        nodeNames = (theOption[1].asInt()) ? true : false;
                    }
                }
                else if (theOption[0] ==
                        flagVerboseUnits && theOption.length() > 1) {
                    if (theOption[1].isInt()) {
                        verboseUnits = (theOption[1].asInt()) ? true : false;
                    }
                } else if ( theOption[0] ==
                            flagCopyKeyCmd && theOption.length() > 1) {

                    //  Replace any '>' characters with '"'. This is needed
                    //  since the file translator option boxes do not handle
                    //  escaped quotation marks.
                    //
                    const char *optStr = theOption[1].asChar();
                    size_t nChars = strlen(optStr);
                    char *copyStr = new char[nChars+1];

                    copyStr = strcpy(copyStr, optStr);
                    for (size_t j = 0; j < nChars; j++) {
                        if (copyStr[j] == '>') {
                            copyStr[j] = '"';
                        }
                    }

                    copyFlags += copyStr;
                    delete [] copyStr;
                }
            }
        }

        //  Set the precision of the ofstream.
        //
        animFile.precision(precision);

        status = exportSelected(animFile, copyFlags, nodeNames, verboseUnits);

        animFile.flush();
        animFile.close();

        return status;
    }

    bool animExport::haveReadMethod() const
    {
        return false;
    }

    bool animExport::haveWriteMethod() const
    {
    #ifdef MAYA_EVAL_VERSION
        return false;
    #else
        return true;
    #endif
    }

    MString animExport::defaultExtension() const
    {
        return MString("anim");
    }

    MPxFileTranslator::MFileKind animExport::identifyFile(
                                    const MFileObject& fileName,
                                    const char* buffer,
                                    short size) const
    {
        const char *name = fileName.name().asChar();
        int   nameLength = (int)strlen(name);

        if ((nameLength > 5) && !strcasecmp(name+nameLength-5, ".anim")) {
            return kIsMyFileType;
        }

        return  kNotMyFileType;
    }

    MStatus animExport::exportSelected( ofstream &animFile,
                                        MString &copyFlags,
                                        bool nodeNames /* false */,
                                        bool verboseUnits /* false */)
    {
        MStatus status = MS::kFailure;

        //  If the selection list is empty, then there are no anim curves
        //  to export.
        //
        MSelectionList sList;
        MGlobal::getActiveSelectionList(sList);
        if (sList.isEmpty()) {
            MString msg = MStringResource::getString(kNothingSelected, status);
            MGlobal::displayError(msg);
            return (MS::kFailure);
        }

        //  Copy any anim curves to the API clipboard.
        //
        int result = 0;
        MString command(copyFlags);

        if (MS::kSuccess != (status =
            MGlobal::executeCommand(command, result, false, true))) {
            MStatus stringStat;
            MString msg = MStringResource::getString(kAnimCurveNotFound, stringStat);
            MGlobal::displayError(msg);
            return status;
        }

        if (result == 0 || MAnimCurveClipboard::theAPIClipboard().isEmpty()) {
            MString msg = MStringResource::getString(kAnimCurveNotFound, status);
            MGlobal::displayError(msg);
            return (MS::kFailure);
        }

        if (MS::kSuccess != (   status =
                                fWriter.writeClipboard(animFile,
                                MAnimCurveClipboard::theAPIClipboard(),
                                nodeNames, verboseUnits))) {
            return (MS::kFailure);
        }

        return status;
    }

    MStatus initializePlugin(MObject obj)
    {
        MStatus stat = MS::kFailure;
        MFnPlugin impPlugIn(obj, PLUGIN_COMPANY, "3.0", "Any");

        // This is done first, so the strings are available.
        stat = impPlugIn.registerUIStrings(registerMStringResources, "animImportExportInitStrings");
        if (stat != MS::kSuccess)
        {
            stat.perror("registerUIStrings");
            return stat;
        }

        stat = impPlugIn.registerFileTranslator("animImport", "none",
                                                animImport::creator,
                                                (char *)animImportOptionScript,
                                                (char *)animImportDefaultOptions,
                                                true);

        if (stat != MS::kSuccess) {
            return stat;
        }

        MFnPlugin expPlugIn(obj, PLUGIN_COMPANY, "3.0", "Any");
        stat = expPlugIn.registerFileTranslator("animExport", "",
                                            animExport::creator,
                                            (char *)animExportOptionScript,
                                            (char *)animExportDefaultOptions,
                                            true);

        return stat;
    }

    MStatus uninitializePlugin(MObject obj)
    {
        MStatus stat = MS::kFailure;

        MFnPlugin impPlugIn(obj);
        stat = impPlugIn.deregisterFileTranslator("animImport");

        if (stat != MS::kSuccess) {
            return stat;
        }

        MFnPlugin expPlugIn(obj);
        stat = expPlugIn.deregisterFileTranslator("animExport");

        return stat;
    }