animFileUtils.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: animFileUtils.cc
//
//  Description:
//      Utility classes to read and write .anim files.
//

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

#include <maya/MIOStream.h>
#include <maya/MFStream.h>

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

#include <maya/MGlobal.h>
#include <maya/MString.h>

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

#if defined (OSMac_)
using namespace std;
#endif
//-------------------------------------------------------------------------
//  Class animUnitNames
//-------------------------------------------------------------------------

//  String names for units.
//
const char *kMmString =         "mm";
const char *kCmString =         "cm";
const char *kMString =          "m";
const char *kKmString =         "km";
const char *kInString =         "in";
const char *kFtString =         "ft";
const char *kYdString =         "yd";
const char *kMiString =         "mi";

const char *kMmLString =        "millimeter";
const char *kCmLString =        "centimeter";
const char *kMLString =         "meter";
const char *kKmLString =        "kilometer";
const char *kInLString =        "inch";
const char *kFtLString =        "foot";
const char *kYdLString =        "yard";
const char *kMiLString =        "mile";

const char *kRadString =        "rad";
const char *kDegString =        "deg";
const char *kMinString =        "min";
const char *kSecString =        "sec";

const char *kRadLString =       "radian";
const char *kDegLString =       "degree";
const char *kMinLString =       "minute";
const char *kSecLString =       "second";

const char *kHourTString =      "hour";
const char *kMinTString =       "min";
const char *kSecTString =       "sec";
const char *kMillisecTString =  "millisec";

const char *kGameTString =      "game";
const char *kFileTString =      "film";
const char *kPalTString =       "pal";
const char *kNtscTString =      "ntsc";
const char *kShowTString =      "show";
const char *kPalFTString =      "palf";
const char *kNtscFTString =     "ntscf";

const char *kUnitlessString = "unitless";
const char *kUnknownTimeString =    "Unknown Time Unit";
const char *kUnknownAngularString = "Unknown Angular Unit";
const char *kUnknownLinearString =  "Unknown Linear Unit";

animUnitNames::animUnitNames()
//
//  Description:
//      Class constructor.
//
{
}

animUnitNames::~animUnitNames()
//
//  Description:
//      Class destructor.
//
{
}

/* static */
void animUnitNames::setToLongName(const MAngle::Unit& unit, MString& name)
//
//  Description:
//      Sets the string with the long text name of the angle unit.
//
{
    switch(unit) {
        case MAngle::kDegrees:
            name.set(kDegLString);
            break;
        case MAngle::kRadians:
            name.set(kRadLString);
            break;
        case MAngle::kAngMinutes:
            name.set(kMinLString);
            break;
        case MAngle::kAngSeconds:
            name.set(kSecLString);
            break;
        default:
            name.set(kUnknownAngularString);
            break;
    }
}

/* static */
void animUnitNames::setToShortName(const MAngle::Unit& unit, MString& name)
//
//  Description:
//      Sets the string with the short text name of the angle unit.
//
{
    switch(unit) {
        case MAngle::kDegrees:
            name.set(kDegString);
            break;
        case MAngle::kRadians:
            name.set(kRadString);
            break;
        case MAngle::kAngMinutes:
            name.set(kMinString);
            break;
        case MAngle::kAngSeconds:
            name.set(kSecString);
            break;
        default:
            name.set(kUnknownAngularString);
            break;
    }
}

/* static */
void animUnitNames::setToLongName(const MDistance::Unit& unit, MString& name)
//
//  Description:
//      Sets the string with the long text name of the distance unit.
//
{
    switch(unit) {
        case MDistance::kInches:
            name.set(kInLString);
            break;
        case MDistance::kFeet:
            name.set(kFtLString);
            break;
        case MDistance::kYards:
            name.set(kYdLString);
            break;
        case MDistance::kMiles:
            name.set(kMiLString);
            break;
        case MDistance::kMillimeters:
            name.set(kMmLString);
            break;
        case MDistance::kCentimeters:
            name.set(kCmLString);
            break;
        case MDistance::kKilometers:
            name.set(kKmLString);
            break;
        case MDistance::kMeters:
            name.set(kMLString);
            break;
        default:
            name.set(kUnknownLinearString);
            break;
    }
}

/* static */
void animUnitNames::setToShortName(const MDistance::Unit& unit, MString& name)
//
//  Description:
//      Sets the string with the short text name of the distance unit.
//
{
    switch(unit) {
        case MDistance::kInches:
            name.set(kInString);
            break;
        case MDistance::kFeet:
            name.set(kFtString);
            break;
        case MDistance::kYards:
            name.set(kYdString);
            break;
        case MDistance::kMiles:
            name.set(kMiString);
            break;
        case MDistance::kMillimeters:
            name.set(kMmString);
            break;
        case MDistance::kCentimeters:
            name.set(kCmString);
            break;
        case MDistance::kKilometers:
            name.set(kKmString);
            break;
        case MDistance::kMeters:
            name.set(kMString);
            break;
        default:
            name.set(kUnknownLinearString);
            break;
    }
}

/* static */
void animUnitNames::setToLongName(const MTime::Unit &unit, MString &name)
//
//  Description:
//      Sets the string with the long text name of the time unit.
//
{
    switch(unit) {
        case MTime::kHours:
            name.set(kHourTString);
            break;
        case MTime::kMinutes:
            name.set(kMinTString);
            break;
        case MTime::kSeconds:
            name.set(kSecTString);
            break;
        case MTime::kMilliseconds:
            name.set(kMillisecTString);
            break;
        case MTime::kGames:
            name.set(kGameTString);
            break;
        case MTime::kFilm:
            name.set(kFileTString);
            break;
        case MTime::kPALFrame:
            name.set(kPalTString);
            break;
        case MTime::kNTSCFrame:
            name.set(kNtscTString);
            break;
        case MTime::kShowScan:
            name.set(kShowTString);
            break;
        case MTime::kPALField:
            name.set(kPalFTString);
            break;
        case MTime::kNTSCField:
            name.set(kNtscFTString);
            break;
        default:
            name.set(kUnknownTimeString);
            break;
    }
}

/* static */
void animUnitNames::setToShortName(const MTime::Unit &unit, MString &name)
//
//  Description:
//      Sets the string with the short text name of the time unit.
//
{
    setToLongName(unit, name);
}

/* static */
bool animUnitNames::setFromName(const MString &str, MAngle::Unit &unit)
//
//  Description:
//      The angle unit is set based on the passed string. If the string
//      is not recognized, the angle unit is set to MAngle::kInvalid.
//
{
    bool state = true;

    const char *name = str.asChar();

    if ((strcmp(name, kDegString) == 0) || 
        (strcmp(name, kDegLString) == 0)) {
        unit = MAngle::kDegrees;
    } else if ( (strcmp(name, kRadString) == 0) ||
                (strcmp(name, kRadLString) == 0)) {
        unit = MAngle::kRadians;
    } else if ( (strcmp(name, kMinString) == 0) ||
                (strcmp(name, kMinLString) == 0)) {
        unit = MAngle::kAngMinutes;
    } else if ( (strcmp(name, kSecString) == 0) ||
                (strcmp(name, kSecLString) == 0)) {
        unit = MAngle::kAngSeconds;
    } else {
        //  This is not a recognized angular unit.
        //
        unit = MAngle::kInvalid;
        MStatus stat;
        MString msg; 
        // Use format to place variable string into message
        MString msgFmt = MStringResource::getString(kInvalidAngleUnits, stat);
        msg.format(msgFmt, str);
        MGlobal::displayError(msg);
        state = false;
    }

    return state;
}

/* static */
bool animUnitNames::setFromName(const MString &str, MDistance::Unit &unit)
//
//  Description:
//      The distance unit is set based on the passed string. If the string
//      is not recognized, the distance unit is set to MDistance::kInvalid.
//
{
    bool state = true;

    const char *name = str.asChar();

    if ((strcmp(name, kInString) == 0) ||
        (strcmp(name, kInLString) == 0)) {
        unit = MDistance::kInches;
    } else if ( (strcmp(name, kFtString) == 0) ||
                (strcmp(name, kFtLString) == 0)) {
        unit = MDistance::kFeet;
    } else if ( (strcmp(name, kYdString) == 0) ||
                (strcmp(name, kYdLString) == 0)) {
        unit = MDistance::kYards;
    } else if ( (strcmp(name, kMiString) == 0) ||
                (strcmp(name, kMiLString) == 0)) {
        unit = MDistance::kMiles;
    } else if ( (strcmp(name, kMmString) == 0) ||
                (strcmp(name, kMmLString) == 0)) {
        unit = MDistance::kMillimeters;
    } else if ( (strcmp(name, kCmString) == 0) ||
                (strcmp(name, kCmLString) == 0)) {
        unit = MDistance::kCentimeters;
    } else if ( (strcmp(name, kKmString) == 0) ||
                (strcmp(name, kKmLString) == 0)) {
        unit = MDistance::kKilometers;
    } else if ( (strcmp(name, kMString) == 0) ||
                (strcmp(name, kMLString) == 0)) {
        unit = MDistance::kMeters;
    } else {
        //  This is not a recognized distance unit.
        //
        state = false;
        MStatus stat;
        MString msg; 
        // Use format to place variable string into message
        MString msgFmt = MStringResource::getString(kInvalidLinearUnits, stat);
        msg.format(msgFmt, str);
        MGlobal::displayError(msg);
        unit = MDistance::kInvalid;
    }

    return state;
}

/* static */
bool animUnitNames::setFromName(const MString &str, MTime::Unit &unit)
//
//  Description:
//      The time unit is set based on the passed string. If the string
//      is not recognized, the time unit is set to MTime::kInvalid.
//
{
    bool state = true;
    const char *name = str.asChar();

    if (strcmp(name, kHourTString) == 0) {
        unit = MTime::kHours;
    } else if (strcmp(name, kMinTString) == 0) {
        unit = MTime::kMinutes;
    } else if (strcmp(name, kSecTString) == 0) {
        unit = MTime::kSeconds;
    } else if (strcmp(name, kMillisecTString) == 0) {
        unit = MTime::kMilliseconds;
    } else if (strcmp(name, kGameTString) == 0) {
        unit = MTime::kGames;
    } else if (strcmp(name, kFileTString) == 0) {
        unit = MTime::kFilm;
    } else if (strcmp(name, kPalTString) == 0) {
        unit = MTime::kPALFrame;
    } else if (strcmp(name, kNtscTString) == 0) {
        unit = MTime::kNTSCFrame;
    } else if (strcmp(name, kShowTString) == 0) {
        unit = MTime::kShowScan;
    } else if (strcmp(name, kPalFTString) == 0) {
        unit = MTime::kPALField;
    } else if (strcmp(name, kNtscFTString) == 0) {
        unit = MTime::kNTSCField;
    } else {
        //  This is not a recognized time unit.
        //
        unit = MTime::kInvalid;
        MStatus stat;
        MString msg; 
        // Use format to place variable string into message
        MString msgFmt = MStringResource::getString(kInvalidTimeUnits, stat);
        msg.format(msgFmt, str);
        MGlobal::displayError(msg);
        state = false;
    }

    return state;
}

//-------------------------------------------------------------------------
//  Class animBase
//-------------------------------------------------------------------------

// Tangent type words
//
const char *kWordTangentGlobal = "global";
const char *kWordTangentFixed = "fixed";
const char *kWordTangentLinear = "linear";
const char *kWordTangentFlat = "flat";
const char *kWordTangentSmooth = "spline";
const char *kWordTangentStep = "step";
const char *kWordTangentSlow = "slow";
const char *kWordTangentFast = "fast";
const char *kWordTangentClamped = "clamped";
const char *kWordTangentPlateau = "plateau";
const char *kWordTangentStepNext = "stepnext";
const char *kWordTangentAuto = "auto";

// Infinity type words
//
const char *kWordConstant = "constant";
const char *kWordLinear = "linear";
const char *kWordCycle = "cycle";
const char *kWordCycleRelative = "cycleRelative";
const char *kWordOscillate = "oscillate";

//  Param Curve types
//
const char *kWordTypeUnknown = "unknown";
const char *kWordTypeLinear = "linear";
const char *kWordTypeAngular = "angular";
const char *kWordTypeTime = "time";
const char *kWordTypeUnitless = "unitless";

//  Keywords
//
const char *kAnim = "anim";
const char *kAnimData = "animData";
const char *kMovData = "movData";
const char *kMayaVersion = "mayaVersion";
const char *kAnimVersion = "animVersion";

const char *kTimeUnit = "timeUnit";
const char *kLinearUnit = "linearUnit";
const char *kAngularUnit = "angularUnit";
const char *kStartTime = "startTime";
const char *kEndTime = "endTime";
const char *kStartUnitless = "startUnitless";
const char *kEndUnitless = "endUnitless";

// animVersions:
//
const char *kAnimVersionString = "1.1";
// const double kVersion1 = 1.0;                        // initial release
const double kVersionNonWeightedAndBreakdowns = 1.1;    // added support for non-weighted curves and breakdowns

const char *kTwoSpace = "  ";

//  animData keywords
//
const char *kInputString = "input";
const char *kOutputString = "output";
const char *kWeightedString = "weighted";
const char *kPreInfinityString = "preInfinity";
const char *kPostInfinityString = "postInfinity";
const char *kInputUnitString = "inputUnit";
const char *kOutputUnitString = "outputUnit";
const char *kTanAngleUnitString = "tangentAngleUnit";
const char *kKeysString = "keys";

//  special characters
//
const char kSemiColonChar   = ';';
const char kSpaceChar       = ' ';
const char kTabChar         = '\t';
const char kHashChar        = '#';
const char kNewLineChar     = '\n';
const char kSlashChar       = '/';
const char kBraceLeftChar   = '{';
const char kBraceRightChar  = '}';
const char kDoubleQuoteChar = '"';

animBase::animBase ()
//
//  Description:
//      The constructor.
//
{
    resetUnits();
}
    
animBase::~animBase()
//
//  Description:
//      The destructor.
//
{
}

void animBase::resetUnits()
//
//  Description:
//      Reset the units used by this class to the ui units.
//
{
    timeUnit = MTime::uiUnit();
    linearUnit = MDistance::uiUnit();
    angularUnit = MAngle::uiUnit();
}

const char *
animBase::tangentTypeAsWord(MFnAnimCurve::TangentType type)
//
//  Description:
//      Returns a string with a test based desription of the passed
//      MFnAnimCurve::TangentType. 
//
{
    switch (type) {
        case MFnAnimCurve::kTangentGlobal:
            return (kWordTangentGlobal);
        case MFnAnimCurve::kTangentFixed:
            return (kWordTangentFixed);
        case MFnAnimCurve::kTangentLinear:
            return (kWordTangentLinear);
        case MFnAnimCurve::kTangentFlat:
            return (kWordTangentFlat);
        case MFnAnimCurve::kTangentSmooth:
            return (kWordTangentSmooth);
        case MFnAnimCurve::kTangentStep:
            return (kWordTangentStep);
        case MFnAnimCurve::kTangentStepNext:
            return (kWordTangentStepNext);
        case MFnAnimCurve::kTangentSlow:
            return (kWordTangentSlow);
        case MFnAnimCurve::kTangentFast:
            return (kWordTangentFast);
        case MFnAnimCurve::kTangentClamped:
            return (kWordTangentClamped);
        case MFnAnimCurve::kTangentPlateau:
            return (kWordTangentPlateau);
        case MFnAnimCurve::kTangentAuto:
            return (kWordTangentAuto);
        default:
            break;
    }
    return (kWordTangentGlobal);
}

MFnAnimCurve::TangentType
animBase::wordAsTangentType (char *type)
//
//  Description:
//      Returns a MFnAnimCurve::TangentType based on the passed string.
//      If the string is not a recognized tangent type, tnen
//      MFnAnimCurve::kTangentGlobal is returned.
//
{
    if (strcmp(type, kWordTangentGlobal) == 0) {
        return (MFnAnimCurve::kTangentGlobal);
    }
    if (strcmp(type, kWordTangentFixed) == 0) {
        return (MFnAnimCurve::kTangentFixed);
    }
    if (strcmp(type, kWordTangentLinear) == 0) {
        return (MFnAnimCurve::kTangentLinear);
    }
    if (strcmp(type, kWordTangentFlat) == 0) {
        return (MFnAnimCurve::kTangentFlat);
    }
    if (strcmp(type, kWordTangentSmooth) == 0) {
        return (MFnAnimCurve::kTangentSmooth);
    }
    if (strcmp(type, kWordTangentStep) == 0) {
        return (MFnAnimCurve::kTangentStep);
    }
    if (strcmp(type, kWordTangentStepNext) == 0) {
        return (MFnAnimCurve::kTangentStepNext);
    }
    if (strcmp(type, kWordTangentSlow) == 0) {
        return (MFnAnimCurve::kTangentSlow);
    }
    if (strcmp(type, kWordTangentFast) == 0) {
        return (MFnAnimCurve::kTangentFast);
    }
    if (strcmp(type, kWordTangentClamped) == 0) {
        return (MFnAnimCurve::kTangentClamped);
    }
    if (strcmp(type, kWordTangentPlateau) == 0) {
        return (MFnAnimCurve::kTangentPlateau);
    }
    if (strcmp(type, kWordTangentAuto) == 0) {
        return (MFnAnimCurve::kTangentAuto);
    }
    return (MFnAnimCurve::kTangentGlobal);
}

const char *
animBase::infinityTypeAsWord(MFnAnimCurve::InfinityType type)
//  
//  Description:
//      Returns a string containing the name of the passed 
//      MFnAnimCurve::InfinityType type.
//
{
    switch (type) {
        case MFnAnimCurve::kConstant:
            return (kWordConstant);
        case MFnAnimCurve::kLinear:
            return (kWordLinear);
        case MFnAnimCurve::kCycle:
            return (kWordCycle);
        case MFnAnimCurve::kCycleRelative:
            return (kWordCycleRelative);
        case MFnAnimCurve::kOscillate:
            return (kWordOscillate);
        default:
            break;
    }
    return (kWordConstant);
}

MFnAnimCurve::InfinityType
animBase::wordAsInfinityType(const char *type)
//
//  Description:
//      Returns a MFnAnimCurve::InfinityType from the passed string.
//      If the string does not match a recognized infinity type,
//      MFnAnimCurve::kConstant is returned.
//
{
    if (strcmp(type, kWordConstant) == 0) {
        return(MFnAnimCurve::kConstant);
    } else if (strcmp(type, kWordLinear) == 0) {
        return (MFnAnimCurve::kLinear);
    } else if (strcmp(type, kWordCycle) == 0) {
        return (MFnAnimCurve::kCycle);
    } else if (strcmp(type, kWordCycleRelative) == 0) {
        return (MFnAnimCurve::kCycleRelative);
    } else if (strcmp(type, kWordOscillate) == 0) {
        return (MFnAnimCurve::kOscillate);
    }

    return (MFnAnimCurve::kConstant);
}

const char *
animBase::outputTypeAsWord (MFnAnimCurve::AnimCurveType type)
//
//  Description:
//      Returns a string identifying the output type of the
//      passed MFnAnimCurve::AnimCurveType.
//
{
    switch (type) {
        case MFnAnimCurve::kAnimCurveTL:
        case MFnAnimCurve::kAnimCurveUL:
            return (kWordTypeLinear);
        case MFnAnimCurve::kAnimCurveTA:
        case MFnAnimCurve::kAnimCurveUA:
            return (kWordTypeAngular);
        case MFnAnimCurve::kAnimCurveTT:
        case MFnAnimCurve::kAnimCurveUT:
            return (kWordTypeTime);
        case MFnAnimCurve::kAnimCurveTU:
        case MFnAnimCurve::kAnimCurveUU:
            return (kWordTypeUnitless);
        case MFnAnimCurve::kAnimCurveUnknown:
            return (kWordTypeUnitless);
    }
    return (kWordTypeUnknown);
}

animBase::AnimBaseType
animBase::wordAsInputType(const char *input)
//
//  Description:
//      Returns an input type based on the passed string.
//
{
    if (strcmp(input, kWordTypeTime) == 0) {
        return animBase::kAnimBaseTime;
    } else {
        return animBase::kAnimBaseUnitless;
    }
}

animBase::AnimBaseType
animBase::wordAsOutputType(const char *output) 
//
//  Description:
//      Returns a output type based on the passed string.
//
{
    if (strcmp(output, kWordTypeLinear) == 0) {
        return animBase::kAnimBaseLinear;
    } else if (strcmp(output, kWordTypeAngular) == 0) {
        return animBase::kAnimBaseAngular;
    } else if (strcmp(output, kWordTypeTime) == 0) {
        return animBase::kAnimBaseTime;
    } else {
        return animBase::kAnimBaseUnitless;
    }
}

const char *
animBase::boolInputTypeAsWord(bool isUnitless) 
//
//  Description:
//      Returns a string based on a bool. 
//
{
    if (isUnitless) {
        return (kWordTypeUnitless);
    } else {
        return (kWordTypeTime);
    }
}


MFnAnimCurve::AnimCurveType
animBase::typeAsAnimCurveType(  animBase::AnimBaseType input, 
                                animBase::AnimBaseType output)
//
//  Description:
//      Returns a MFnAnimCurve::AnimCurveType based on the passed
//      input and output types. If the input and output types do
//      not create a valid MFnAnimCurve::AnimCurveType, then a
//      MFnAnimCurve::kAnimCurveUnknown is returned.
//
{
    MFnAnimCurve::AnimCurveType type = MFnAnimCurve::kAnimCurveUnknown;

    switch (output) {
        case kAnimBaseLinear:
            if (kAnimBaseUnitless == input) {
                type = MFnAnimCurve::kAnimCurveUL;
            } else {
                type = MFnAnimCurve::kAnimCurveTL;
            }
            break;
        case kAnimBaseAngular:
            if (kAnimBaseUnitless == input) {
                type = MFnAnimCurve::kAnimCurveUA;
            } else {
                type = MFnAnimCurve::kAnimCurveTA;
            }
            break;
        case kAnimBaseTime:
            if (kAnimBaseUnitless == input) {
                type = MFnAnimCurve::kAnimCurveUT;
            } else {
                type = MFnAnimCurve::kAnimCurveTT;
            }
            break;
        case kAnimBaseUnitless:
            if (kAnimBaseUnitless == input) {
                type = MFnAnimCurve::kAnimCurveUU;
            } else {
                type = MFnAnimCurve::kAnimCurveTU;
            }
            break;
        default:
            //  An unknown anim curve type.
            //
            break;
    }

    return type;
}

double animBase::asDouble (ifstream &clipFile)
//
//  Description:
//      Reads the next bit of valid data as a double.
//
{
    advance(clipFile);

    double value;
    clipFile >> value;

    return (value);
}

bool animBase::isNextNumeric(ifstream &clipFile)
//
//  Description:
//      The method skips past whitespace and comments and checks if
//      the next character is numeric.
//      
//      true is returned if the character is numeric.
//
{
    bool numeric = false;
    advance(clipFile);

    char next = clipFile.peek();
    if (next >= '0' && next <= '9') {
        numeric = true;
}

    return numeric;
}

void animBase::advance (ifstream &clipFile) 
//
//  Description:
//      The method skips past all of the whitespace and commented lines
//      in the ifstream. It will also ignore semi-colons.
//
{
    while (clipFile) {
        clipFile >> ws;

        char next = clipFile.peek();

        if (next == kSemiColonChar) {
            clipFile.ignore(1, kSemiColonChar);
            continue;
        }

        if (next == kSlashChar || next == kHashChar) {
            clipFile.ignore(INT_MAX, kNewLineChar);
            continue;
        }

        break;
    }
}

char* animBase::asWord (ifstream &clipFile, bool includeWS /* false */)
//
//  Description:
//      Returns the next string of characters in an ifstream. The string
//      ends when whitespace or a semi-colon is encountered. If the 
//      includeWS argument is true, the string will not end if a white
//      space character is encountered.
//
//      If a double quote is detected '"', then verything up to the next 
//      double quote will be returned.
//
//      This method returns a pointer to a static variable, so its contents
//      should be used immediately.
//      
    {
    static const int kBufLength = 1024;
    static char string[kBufLength];

    advance(clipFile);

    char *c = string;
    clipFile.read (c, 1);

    if (*c == kDoubleQuoteChar) {
        clipFile.read(c, 1);
        while(!clipFile.eof() && (*c != kDoubleQuoteChar)) {
            c++;
            if (c-string >= kBufLength) {
                break;
            }
            clipFile.read(c, 1);
        }
    } else {
        
        //  Get the case of the '{' or '}' character
        //
        if (*c == kBraceLeftChar || *c == kBraceRightChar) {
            c++;
        } else {
            while(!clipFile.eof() && (*c != kSemiColonChar)) {
                if (!includeWS && ((*c == kSpaceChar) || (*c == kTabChar))) {
                    break;
                }
                c++;
                if (c-string >= kBufLength) {
                    break;
                }
                clipFile.read(c, 1);
            }
    }
    }
    *c = 0x00;

    return (string);
    }

char animBase::asChar (ifstream &clipFile)
//
//  Description:
//      Returns the next character of interest in the ifstream. All 
//      whitespace and commented lines are ignored.
//
    {
    advance(clipFile);
    return clipFile.get();
    }

bool animBase::isEquivalent(double a, double b)
//
//  Description:
//      Returns true if the doubles are within the tolerance.
//
    {
    const double tolerance = 1.0e-10;
    return ((a > b) ? (a - b <= tolerance) : (b - a <= tolerance));
}

//-----------------------------------------------------------------------------
//  Class animReader
//-----------------------------------------------------------------------------

animReader::animReader ()
//
//  Description:
//      Class constructor.
//
:   animVersion (1.0)
,   convertAnglesFromV2To3(false)
,   convertAnglesFromV3To2(false)
{
}
    
animReader::~animReader()
//
//  Description:
//      Class destructor.
//
{
}

MStatus 
animReader::readClipboard(ifstream &readAnim, MAnimCurveClipboard& cb)
//
//  Description:
//      Given a clipboard and an ifstream, read the ifstream and add
//      all of the anim curves described in ther stream into the 
//      API clipboard.
//
{
    //  Set the default values for the start and end of the clipboard.
    //  The MAnimCurveClipboard::set() method will examine all of the
    //  anim curves are determine the proper start and end values, if the
    //  start time is greater than the end value.
    //
    //  By default, the start values are greater than the end values to 
    //  ensure correct behavior if the file does not specify the start and
    //  end values.
    //
    //
    double startTime = 1.0;
    double endTime = 0.0;
    double startUnitless = 1.0;
    double endUnitless = 0.0;

    resetUnits();
    convertAnglesFromV2To3 = false;
    convertAnglesFromV3To2 = false;

    //  Read the header. The header officially ends when the first non-header
    //  keyword is found. The header contains clipboard specific information
    //  where the body is anim curve specific.
    //
    char *dataType = NULL;
    bool hasVersionString = false;
    while (!readAnim.eof()) {
        advance(readAnim);
        dataType = asWord(readAnim);

        if (strcmp(dataType, kAnimVersion) == 0) {
            MString version(asWord(readAnim));
            animVersion = version.asDouble();
            MString thisVersion(kAnimVersionString);

            hasVersionString = true;

            //  Add versioning control here.
            //
            if (version != thisVersion) {
                MStatus stat;
                MString msg; 
                // Use format to place variable string into message
                MString msgFmt = MStringResource::getString(kInvalidVersion,
                                                            stat);
                msg.format(msgFmt, version, thisVersion);
                MGlobal::displayWarning(msg);
            }
        } else if (strcmp(dataType, kMayaVersion) == 0) {
            MString version(asWord(readAnim, true));

            MString currentVersion = MGlobal::mayaVersion();
            if (currentVersion.substring(0,1) == "2.") {
                MString vCheck = version.substring(0, 1);
                if (vCheck != "2.") {
                    convertAnglesFromV3To2 = true;
                }
            } else {
                //  If this is a pre-Maya 3.0 file, then the tangent angles 
                //  will need to be converted to work in Maya 3.0+
                //
                MString vCheck = version.substring(0, 1);
                if (vCheck == "2.") {
                    convertAnglesFromV2To3 = true;
                }
            }
        } else if (strcmp(dataType, kTimeUnit) == 0) {
            MString timeUnitString(asWord(readAnim));
            if (!animUnitNames::setFromName(timeUnitString, timeUnit)) {
                MString unitName;
                timeUnit = MTime::uiUnit();
                animUnitNames::setToShortName(timeUnit, unitName);
                MStatus stat;
                MString msg; 
                // Use format to place variable string into message
                MString msgFmt = MStringResource::getString(kSettingToUnit,
                                                            stat);
                msg.format(msgFmt, kTimeUnit, unitName);
                MGlobal::displayWarning(msg);
            }
        } else if (strcmp(dataType, kLinearUnit) == 0) {
            MString linearUnitString(asWord(readAnim));
            if (!animUnitNames::setFromName(linearUnitString, linearUnit)) {
                MString unitName;
                linearUnit = MDistance::uiUnit();
                animUnitNames::setToShortName(linearUnit, unitName);
                MStatus stat;
                MString msg; 
                // Use format to place variable string into message
                MString msgFmt = MStringResource::getString(kSettingToUnit,
                                                            stat);
                msg.format(msgFmt, kLinearUnit, unitName);
                MGlobal::displayWarning(msg);
            }
        } else if (strcmp(dataType, kAngularUnit) == 0) {
            MString angularUnitString(asWord(readAnim));
            if (!animUnitNames::setFromName(angularUnitString, angularUnit)) {
                MString unitName;
                angularUnit = MAngle::uiUnit();
                animUnitNames::setToShortName(angularUnit, unitName);
                MStatus stat;
                MString msg; 
                // Use format to place variable string into message
                MString msgFmt = MStringResource::getString(kSettingToUnit,
                                                            stat);
                msg.format(msgFmt, kAngularUnit, unitName);
                MGlobal::displayWarning(msg);
            }
        } else if (strcmp(dataType, kStartTime) == 0) {
            startTime = asDouble(readAnim);
        } else if (strcmp(dataType, kEndTime) == 0) {
            endTime = asDouble(readAnim);
        } else if (strcmp(dataType, kStartUnitless) == 0) {
            startUnitless = asDouble(readAnim);
        } else if (strcmp(dataType, kEndUnitless) == 0) {
            endUnitless = asDouble(readAnim);
        } else {    
            //  The header should be finished. Begin to parse the body.
            //
            break;
        }
    }

    //  The animVersion string is required.
    //
    if (!hasVersionString) {
        MStatus stat;
        MString msg; 
        // Use format to place variable string into message
        MString msgFmt = MStringResource::getString(kMissingKeyword, stat);
        msg.format(msgFmt, kAnimVersion);
        MGlobal::displayError(msg);
        return (MS::kFailure);
    }

    //  Set the linear and angular units to be the same as the file
    //  being read. This will allow fixed tangent data to be read
    //  in properly if the scene has different units than the .anim file.
    //
    MDistance::Unit oldDistanceUnit = MDistance::uiUnit();
    MTime::Unit oldTimeUnit = MTime::uiUnit();

    MDistance::setUIUnit(linearUnit);
    MTime::setUIUnit(timeUnit);

    MAnimCurveClipboardItemArray clipboardArray;
    while (!readAnim.eof()) {

        if (NULL == dataType) {
            dataType = asWord(readAnim);
        }

        if (strcmp(dataType, kAnim) == 0) {
            MString fullAttributeName, leafAttributeName, nodeName;

            //  If this is from an unconnected anim curve, then there
            //  will not be an attribute name.
            //
            if (!isNextNumeric(readAnim)) {
                fullAttributeName.set(asWord(readAnim));

                //  If the node names were specified, then the next two
                //  words should be the leaf attribute and the node name.
                //
                if (!isNextNumeric(readAnim)) {
                    leafAttributeName.set(asWord(readAnim));
                    nodeName.set(asWord(readAnim));
                }
            }

            unsigned rowCount, childCount, attrCount;
            rowCount = (unsigned)asDouble(readAnim);
            childCount = (unsigned)asDouble(readAnim);
            attrCount = (unsigned)asDouble(readAnim);

            //  If the next keyword is not an animData, then this is 
            //  a place holder for the API clipboard.
            //
            dataType = asWord(readAnim);
            if (strcmp(dataType, kAnimData) == 0) {
                MAnimCurveClipboardItem clipboardItem;
                if (readAnimCurve(readAnim, clipboardItem)) {
                    clipboardItem.setAddressingInfo(rowCount, 
                                                    childCount, attrCount);
                    clipboardItem.setNameInfo(  nodeName, 
                                                fullAttributeName, 
                                                leafAttributeName);
                    clipboardArray.append(clipboardItem);
                } else {
                    //  Could not read the anim curve.
                    //
                    MStatus stringStat;
                    MString msg = MStringResource::getString(kCouldNotReadAnim,
                                                             stringStat);
                    MGlobal::displayError(msg);
                }
            } else {
                //  This must be a place holder object for the clipboard.
                //
                MAnimCurveClipboardItem clipboardItem;
                clipboardItem.setAddressingInfo(rowCount, 
                                                childCount, attrCount);

                //  Since there is no anim curve specified, what is 
                //  in the fullAttributeName string is really the node 
                //  name.
                //
                clipboardItem.setNameInfo(  fullAttributeName, 
                                            nodeName, 
                                            leafAttributeName);
                clipboardArray.append(clipboardItem);

                //  dataType already contains the next keyword. 
                //  
                continue;
            }
        } else {
            if (!readAnim.eof()) {
                MString warnStr(dataType);
                MStatus stat;
                MString msg; 
                // Use format to place variable string into message
                MString msgFmt = MStringResource::getString(kUnknownKeyword,
                                                            stat);
                msg.format(msgFmt, warnStr);
                MGlobal::displayError(msg);

                //  Skip to the next line, this one is invalid.
                //
                readAnim.ignore(INT_MAX, kNewLineChar);
            } else {
                //  The end of the file was reached. 
                //
                break;
            }
        }

        //  Skip any whitespace.
        //
        dataType = NULL;
    }

    if (MS::kSuccess != cb.set( clipboardArray, 
                        MTime(startTime, timeUnit), MTime(endTime, timeUnit), 
                        (float) startUnitless, (float) endUnitless)) {

        MStatus stringStat;
        MString msg = MStringResource::getString(kClipboardFailure,
                                                 stringStat);
        MGlobal::displayError(msg);
    }

    //  Restore the old units.
    //
    MDistance::setUIUnit(oldDistanceUnit);
    MTime::setUIUnit(oldTimeUnit);

    return (MS::kSuccess);
}

void animReader::convertAnglesAndWeights3To2(MFnAnimCurve::AnimCurveType type, 
                                bool isWeighted, MAngle &angle, double &weight)
//
//  Description:
//      Converts the tangent angles from Maya 3.0 to Maya2.* formats.
//
{
    double oldAngle = angle.as(MAngle::kRadians);
    double newAngle = oldAngle;

    //  Calculate the scale values for the conversion.
    //
    double xScale = 1.0;
    double yScale = 1.0;

    MTime tOne(1.0, MTime::kSeconds);
    if (type == MFnAnimCurve::kAnimCurveTT ||
        type == MFnAnimCurve::kAnimCurveTL ||
        type == MFnAnimCurve::kAnimCurveTA ||
        type == MFnAnimCurve::kAnimCurveTU) {

        xScale = tOne.as(MTime::uiUnit());
    }

    switch (type) {
        case MFnAnimCurve::kAnimCurveTT:
        case MFnAnimCurve::kAnimCurveUT:
            yScale = tOne.as(MTime::uiUnit());
            break;
        case MFnAnimCurve::kAnimCurveTL:
        case MFnAnimCurve::kAnimCurveUL:
            {
                MDistance dOne(1.0, MDistance::internalUnit());
                yScale = dOne.as(linearUnit);
            }
            break;
        case MFnAnimCurve::kAnimCurveTA:
        case MFnAnimCurve::kAnimCurveUA:
            {
                MAngle aOne(1.0, MAngle::internalUnit());
                yScale = aOne.as(angularUnit);
            }
            break;
        case MFnAnimCurve::kAnimCurveTU:
        case MFnAnimCurve::kAnimCurveUU:
        default:
            break;
    }

    double tanAngle = tan(oldAngle);
    newAngle = atan((xScale*tanAngle)/yScale);

    if (isWeighted) {
        double sinAngle = sin(oldAngle);
        double cosAngle = cos(oldAngle);

        double denominator = (yScale*yScale*sinAngle*sinAngle) +
                                (xScale*xScale*cosAngle*cosAngle);
        weight = sqrtl(weight/denominator);
    }

    MAngle finalAngle(newAngle, MAngle::kRadians);
    angle = finalAngle;
}

void animReader::convertAnglesAndWeights2To3(MFnAnimCurve::AnimCurveType type, 
                                bool isWeighted, MAngle &angle, double &weight)
//
//  Description:
//      Converts the tangent angles from Maya 2.* to Maya3.0+ formats.
//
{
    double oldAngle = angle.as(MAngle::kRadians);

    double newAngle = oldAngle;
    double newWeight = weight;

    //  Calculate the scale values for the conversion.
    //
    double xScale = 1.0;
    double yScale = 1.0;

    MTime tOne(1.0, MTime::kSeconds);
    if (type == MFnAnimCurve::kAnimCurveTT ||
        type == MFnAnimCurve::kAnimCurveTL ||
        type == MFnAnimCurve::kAnimCurveTA ||
        type == MFnAnimCurve::kAnimCurveTU) {

        xScale = tOne.as(MTime::uiUnit());
    }

    switch (type) {
        case MFnAnimCurve::kAnimCurveTT:
        case MFnAnimCurve::kAnimCurveUT:
            yScale = tOne.as(MTime::uiUnit());
            break;
        case MFnAnimCurve::kAnimCurveTL:
        case MFnAnimCurve::kAnimCurveUL:
            {
                MDistance dOne(1.0, MDistance::internalUnit());
                yScale = dOne.as(linearUnit);
            }
            break;
        case MFnAnimCurve::kAnimCurveTA:
        case MFnAnimCurve::kAnimCurveUA:
            {
                MAngle aOne(1.0, MAngle::internalUnit());
                yScale = aOne.as(angularUnit);
            }
            break;
        case MFnAnimCurve::kAnimCurveTU:
        case MFnAnimCurve::kAnimCurveUU:
        default:
            break;
    }

    const double quarter = M_PI/2;
    if (isEquivalent(oldAngle, 0.0) ||
        isEquivalent(oldAngle, quarter) ||
        isEquivalent(oldAngle, -quarter)) {
        
        newAngle = oldAngle;

        if (isWeighted) {
            newWeight = yScale*oldAngle;
        }
    } else {
        double tanAngle = tan(oldAngle);
        newAngle = atan((yScale*tanAngle)/xScale);
            
        if (isWeighted) {
            double cosAngle = cos(oldAngle);
            double cosSq = cosAngle*cosAngle;

            double wSq = (weight*weight) * 
                    (((xScale*xScale - yScale*yScale)*cosSq) + (yScale*yScale));

            newWeight = sqrtl(wSq);
        }
    }

    weight = newWeight;

    MAngle finalAngle(newAngle, MAngle::kRadians);
    angle = finalAngle;
}

bool animReader::readAnimCurve(
ifstream &clipFile, MAnimCurveClipboardItem &item)
//
//  Description:
//      Read a block of the ifstream that should contain anim curve
//      data in the format determined by the animData keyword.
//
{
    MFnAnimCurve animCurve;
    MObject animCurveObj; 

    //  Anim curve defaults.
    //
    animBase::AnimBaseType input = wordAsInputType(kWordTypeTime);
    animBase::AnimBaseType output = wordAsOutputType(kWordTypeLinear);
    MFnAnimCurve::InfinityType preInf = wordAsInfinityType(kWordConstant);
    MFnAnimCurve::InfinityType postInf = wordAsInfinityType(kWordConstant);

    MString inputUnitName;
    animUnitNames::setToShortName(timeUnit, inputUnitName);
    MString outputUnitName;
    MAngle::Unit tanAngleUnit = angularUnit;
    bool isWeighted (false);

    char *dataType;
    while (!clipFile.eof()) {
        advance(clipFile);

        dataType = asWord(clipFile);

        if (strcmp(dataType, kInputString) == 0) {
            input = wordAsInputType(asWord(clipFile));
        } else if (strcmp(dataType, kOutputString) == 0) {
            output = wordAsOutputType(asWord(clipFile));
        } else if (strcmp(dataType, kWeightedString) == 0) {
            isWeighted = (asDouble(clipFile) == 1.0);
        } else if (strcmp(dataType, kPreInfinityString) == 0) {
            preInf = wordAsInfinityType(asWord(clipFile));
        } else if (strcmp(dataType, kPostInfinityString) == 0) {
            postInf = wordAsInfinityType(asWord(clipFile));
        } else if (strcmp(dataType, kInputUnitString) == 0) {
            inputUnitName.set(asWord(clipFile));
        } else if (strcmp(dataType, kOutputUnitString) == 0) {
            outputUnitName.set(asWord(clipFile));
        } else if (strcmp(dataType, kTanAngleUnitString) == 0) {
            MString tUnit(asWord(clipFile));
            if (!animUnitNames::setFromName(tUnit, tanAngleUnit)) {
                MString unitName;
                tanAngleUnit = angularUnit;
                animUnitNames::setToShortName(tanAngleUnit, unitName);

                MStatus stat;
                MString msg; 
                // Use format to place variable string into message
                MString msgFmt = MStringResource::getString(kSettingTanAngleUnit, stat);
                msg.format(msgFmt, unitName);
                MGlobal::displayError(msg);
            }
        } else if (strcmp(dataType, kKeysString) == 0) {
            //  Ignore the rest of this line.
            //
            clipFile.ignore(INT_MAX, kNewLineChar);
            break;
        } else if (strcmp(dataType, "{") == 0) {
            //  Skippping the '{' character. Just ignore it.
            //
            continue;
        } else {
            //  An unrecogized keyword was found.
            //
            MString warnStr(dataType);
            MStatus stat;
            MString msg; 
            // Use format to place variable string into message
            MString msgFmt = MStringResource::getString(kUnknownKeyword,
                                                        stat);
            msg.format(msgFmt, warnStr);
            MGlobal::displayError(msg);
            continue;
        }
    }

    // Read the animCurve
    //
    MStatus status;
    MFnAnimCurve::AnimCurveType type = typeAsAnimCurveType(input, output);
    animCurveObj = animCurve.create(type, NULL, &status);

    if (status != MS::kSuccess) {
        MString msg = MStringResource::getString(kCouldNotCreateAnim, status);
        MGlobal::displayError(msg);
        return false;
    }

    animCurve.setIsWeighted(isWeighted);
    animCurve.setPreInfinityType(preInf);
    animCurve.setPostInfinityType(postInf);

    //  Set the appropriate units.
    //
    MTime::Unit inputTimeUnit;
    if (input == kAnimBaseTime) {
        if (!animUnitNames::setFromName(inputUnitName, inputTimeUnit)) {
            MString unitName;
            inputTimeUnit = timeUnit;
            animUnitNames::setToShortName(inputTimeUnit, unitName);
            MStatus stat;
            MString msg; 
            // Use format to place variable string into message
            MString msgFmt = MStringResource::getString(kSettingToUnit,
                                                        stat);
            msg.format(msgFmt, kInputUnitString, unitName);
            MGlobal::displayWarning(msg);
        }
    }

    MTime::Unit outputTimeUnit;
    if (output == kAnimBaseTime) {
        if (!animUnitNames::setFromName(outputUnitName, outputTimeUnit)) {
            MString unitName;
            outputTimeUnit = timeUnit;
            animUnitNames::setToShortName(outputTimeUnit, unitName);
            MStatus stat;
            MString msg; 
            // Use format to place variable string into message
            MString msgFmt = MStringResource::getString(kSettingToUnit,
                                                        stat);
            msg.format(msgFmt, kOutputUnitString, unitName);
            MGlobal::displayWarning(msg);
        }
    }

    int index = 0;
    double conversion = 1.0;
    if (output == kAnimBaseLinear) {
        MDistance::Unit unit;
        if (outputUnitName.length() != 0) {
            if (!animUnitNames::setFromName(outputUnitName, unit)) {
                MString unitName;
                unit = linearUnit;
                animUnitNames::setToShortName(unit, unitName);
                MStatus stat;
                MString msg; 
                // Use format to place variable string into message
                MString msgFmt = MStringResource::getString(kSettingToUnit,
                                                            stat);
                msg.format(msgFmt, kOutputUnitString, unitName);
                MGlobal::displayWarning(msg);
            }
        } else {
            unit = linearUnit;
        }
        if (unit != MDistance::kCentimeters) {
            MDistance one(1.0, unit);
            conversion = one.as(MDistance::kCentimeters);
        }
    } else if (output == kAnimBaseAngular) {
        MAngle::Unit unit;
        if (outputUnitName.length() != 0) {
            if (!animUnitNames::setFromName(outputUnitName, unit)) {
                MString unitName;
                unit = angularUnit;
                animUnitNames::setToShortName(unit, unitName);
                MStatus stat;
                MString msg; 
                // Use format to place variable string into message
                MString msgFmt = MStringResource::getString(kSettingToUnit,
                                                            stat);
                msg.format(msgFmt, kOutputUnitString, unitName);
                MGlobal::displayWarning(msg);
            }
        } else {
            unit = angularUnit;
        }
        if (unit != MAngle::kRadians) {
            MAngle one(1.0, unit);
            conversion = one.as(MAngle::kRadians);
        }
    }

    // Now read each keyframe
    //
    advance(clipFile);
    char c = clipFile.peek();
    while (clipFile && c != kBraceRightChar) {
        double t = asDouble (clipFile);
        double val = asDouble (clipFile);

        MFnAnimCurve::TangentType tanIn = wordAsTangentType(asWord(clipFile));
        MFnAnimCurve::TangentType tanOut = wordAsTangentType(asWord(clipFile));

        switch (type) {
            case MFnAnimCurve::kAnimCurveTT:
                index = animCurve.addKey(   MTime(val, inputTimeUnit),
                                            MTime(val, outputTimeUnit),
                                            tanIn, tanOut, NULL, &status);
                break;
            case MFnAnimCurve::kAnimCurveTL:
            case MFnAnimCurve::kAnimCurveTA:
            case MFnAnimCurve::kAnimCurveTU:
                index = animCurve.addKey(   MTime(t, inputTimeUnit),
                                            val*conversion, tanIn, tanOut,
                                            NULL, &status);
                break;
            case MFnAnimCurve::kAnimCurveUL:
            case MFnAnimCurve::kAnimCurveUA:
            case MFnAnimCurve::kAnimCurveUU:
                index = animCurve.addKey(   t, val*conversion, 
                                            tanIn, tanOut,
                                            NULL, &status);
                break;
            case MFnAnimCurve::kAnimCurveUT:
                index = animCurve.addKey(   t, MTime(val, outputTimeUnit),
                                            tanIn, tanOut,
                                            NULL, &status);
                break;
            default:
                MString msg = MStringResource::getString(kUnknownNode, status);
                MGlobal::displayError(msg);
                return false;
        }

        if (status != MS::kSuccess) {
            MStatus stringStat;
            MString msg = MStringResource::getString(kCouldNotKey, stringStat);
            MGlobal::displayError(msg);
        }

        //  Tangent locking needs to be called after the weights and 
        //  angles are set for the fixed tangents.
        //
        bool tLocked = bool(asDouble(clipFile) == 1.0);
        bool swLocked = bool(asDouble(clipFile) == 1.0);
        bool isBreakdown (false);
        if (animVersion >= kVersionNonWeightedAndBreakdowns) {
            isBreakdown = (asDouble(clipFile) == 1.0);
        }

        //  Only fixed tangents need additional information.
        //
        if (tanIn == MFnAnimCurve::kTangentFixed) {
            MAngle inAngle(asDouble(clipFile), tanAngleUnit);
            double inWeight = asDouble(clipFile);

            //  If this is from a pre-Maya3.0 file, the tangent angles will 
            //  need to be converted.
            //
            if (convertAnglesFromV2To3) {
                convertAnglesAndWeights2To3(type,isWeighted,inAngle,inWeight);
            } else if (convertAnglesFromV3To2) {
                convertAnglesAndWeights3To2(type,isWeighted,inAngle,inWeight);
            }

            //  By default, the tangents are locked. When the tangents
            //  are locked, setting the angle and weight of a fixed in
            //  tangent may change the tangent type of the out tangent.
            //
            animCurve.setTangentsLocked(index, false);
            animCurve.setTangent(index, inAngle, inWeight, true);
        }

        //  Only fixed tangents need additional information.
        //
        if (tanOut == MFnAnimCurve::kTangentFixed) {
            MAngle outAngle(asDouble(clipFile), tanAngleUnit);
            double outWeight = asDouble(clipFile);

            //  If this is from a pre-Maya3.0 file, the tangent angles will 
            //  need to be converted.
            //
            if (convertAnglesFromV2To3) {
                convertAnglesAndWeights2To3(type,isWeighted,outAngle,outWeight);
            } else if (convertAnglesFromV3To2) {
                convertAnglesAndWeights3To2(type,isWeighted,outAngle,outWeight);
            }
            
            //  By default, the tangents are locked. When the tangents
            //  are locked, setting the angle and weight of a fixed out 
            //  tangent may change the tangent type of the in tangent.
            //
            animCurve.setTangentsLocked(index, false);
            animCurve.setTangent(index, outAngle, outWeight, false);
        }

        //  To prevent tangent types from unexpectedly changing, tangent 
        //  locking should be the last operation. See the above comments
        //  about fixed tangent types for more information.
        //
        animCurve.setWeightsLocked(index, swLocked);
        animCurve.setTangentsLocked(index, tLocked);
        animCurve.setIsBreakdown (index, isBreakdown);

        //  There should be no additional data on this line. Go to the
        //  next line of data.
        //
        clipFile.ignore(INT_MAX, kNewLineChar);

        //  Skip any comments.
        //
        advance(clipFile);
        c = clipFile.peek();
    }

    //  Ignore the brace that marks the end of the keys block.
    //
    if (c == kBraceRightChar) {
        clipFile.ignore(INT_MAX, kNewLineChar);
    }

    //  Ignore the brace that marks the end of the animData block.
    //
    advance(clipFile);
    if (clipFile.peek() == kBraceRightChar) {
        clipFile.ignore(INT_MAX, kNewLineChar);
    } else {
        //  Something is wrong.
        //
        MStatus stringStat;
        MString msg = MStringResource::getString(kMissingBrace, stringStat);
        MGlobal::displayError(msg);
    }

    //  Do not set the clipboard with an empty clipboard item.
    //
    if (!animCurveObj.isNull()) {
        item.setAnimCurve(animCurveObj);
    }

    //  Delete the copy of the anim curve.
    //
    MGlobal::deleteNode(animCurveObj);

    return true;
}

//-------------------------------------------------------------------------
//  Class animWriter
//-------------------------------------------------------------------------

animWriter::animWriter()
//
//  Description:
//      Class constructor.
//
{
}

animWriter::~animWriter()
//
//  Description:
//      Class destructor.
//
{
}

MStatus 
animWriter::writeClipboard( ofstream& animFile, 
                            const MAnimCurveClipboard &cb, 
                            bool nodeNames /* false */,
                            bool verboseUnits /* false */)
//
//  Description:
//      Write the contents of the clipboard to the ofstream.
//
{
    MStatus status = MS::kFailure;

    // Check to see if there is anything on the clipboard at all
    //
    if (cb.isEmpty()) {
        return status;
    }
    
    resetUnits();

    // Write out the clipboard information
    //
    if (!writeHeader(animFile)) {
        return (MS::kFailure);
    }

    // Now write out each animCurve
    //
        const MAnimCurveClipboardItemArray  &clipboardArray = 
                                            cb.clipboardItems(&status);
        if (MS::kSuccess != status) {
            return status;
        }

        for (unsigned int i = 0; i < clipboardArray.length(); i++) {
            const MAnimCurveClipboardItem &clipboardItem = clipboardArray[i];

            MStatus statusInLoop = MS::kSuccess;
            const MObject animCurveObj = clipboardItem.animCurve(&statusInLoop);

            //  The clipboard may contain Null anim curves. If a Null anim 
            //  curve is returned, it is safe to ignore the error message
            //  and continue to the next anim curve in the list.
            //
            bool placeHolder = false;
            if (MS::kSuccess != statusInLoop || animCurveObj.isNull()) {
                placeHolder = true;
            }

            // Write out animCurve information
            //
            if (!writeAnim(animFile, clipboardItem, placeHolder, nodeNames)) {
                return (MS::kFailure);
            }

            if (placeHolder) {
                continue;
            }

            //  Write out each curve in its specified format.
            //  For now, only the anim curve format.
            //
            if (!writeAnimCurve(animFile, &animCurveObj, 
                                clipboardItem.animCurveType(),
                                verboseUnits)) {
                return (MS::kFailure);
            }
        }

    return (MS::kSuccess);
}

bool animWriter::writeHeader(ofstream& clip)
//
//  Description:
//      Writes the header for the file. The header contains the clipboard
//      specific data. 
//
{
    if (!clip) {
        return false;
    }

    clip << kAnimVersion << kSpaceChar << kAnimVersionString << kSemiColonChar << endl;
    clip << kMayaVersion << kSpaceChar << MGlobal::mayaVersion() << kSemiColonChar << endl;

    static MAnimCurveClipboard &clipboard = 
        MAnimCurveClipboard::theAPIClipboard();

    double startTime = clipboard.startTime().as(timeUnit);
    double endTime = clipboard.endTime().as(timeUnit);

    if (startTime != endTime) {
    MString unit;
    animUnitNames::setToShortName(timeUnit, unit);
    clip << kTimeUnit << kSpaceChar << unit << kSemiColonChar << endl;
    animUnitNames::setToShortName(linearUnit, unit);
    clip << kLinearUnit << kSpaceChar << unit << kSemiColonChar << endl;
    animUnitNames::setToShortName(angularUnit, unit);
    clip << kAngularUnit << kSpaceChar << unit << kSemiColonChar << endl;
            clip << kStartTime << kSpaceChar << startTime << kSemiColonChar << endl;
            clip << kEndTime << kSpaceChar << endTime << kSemiColonChar << endl;
        }

        float startUnitless = clipboard.startUnitlessInput();
        float endUnitless = clipboard.endUnitlessInput();

        if (startUnitless != endUnitless) {
            clip << kStartUnitless << kSpaceChar << startUnitless << 
                    kSemiColonChar << endl;
            clip << kEndUnitless << kSpaceChar << endUnitless << 
                    kSemiColonChar << endl;
        }

    return true;
}

bool animWriter::writeAnim( ofstream &clip, 
                            const MAnimCurveClipboardItem &clipboardItem,
                            bool placeHolder /* false */,
                            bool nodeNames /* false */)
//  
//  Description:
//      Write out the anim curve from the clipboard item into the 
//      ofstream. The position of the anim curve in the clipboard
//      and the attribute to which it is attached is written out in this
//      method.
//
//      This method returns true if the write was successful.
//
{
    if (!clip) {
        return false;
    }

    clip << kAnim;

    //  If this is a clipboard place holder then there will be no full
    //  or leaf attribute names.
    //
    if (placeHolder) {
        clip << kSpaceChar << clipboardItem.nodeName().asChar();
    } else {
        clip << kSpaceChar << clipboardItem.fullAttributeName().asChar();

        if (nodeNames) {
            clip << kSpaceChar << clipboardItem.leafAttributeName().asChar();
            clip << kSpaceChar << clipboardItem.nodeName().asChar();
        }
    }

    unsigned int rowCount, childCount, attrCount;
    clipboardItem.getAddressingInfo(rowCount, childCount, attrCount);

    clip << kSpaceChar << rowCount;
    clip << kSpaceChar << childCount;
    clip << kSpaceChar << attrCount;
    clip << kSemiColonChar << endl;

    return true;
}

bool animWriter::writeAnimCurve(ofstream &clip, 
                                const MObject *animCurveObj,
                                MFnAnimCurve::AnimCurveType type,
                                bool verboseUnits /* false */)
//
//  Description:
//      Write out the anim curve from the clipboard item into the
//      ofstream. The actual anim curve data is written out.
//
//      This method returns true if the write was successful.
//
{
    if (NULL == animCurveObj || animCurveObj->isNull() || !clip) {
        return true;
    }

    MStatus status = MS::kSuccess;
    MFnAnimCurve animCurve(*animCurveObj, &status);
    if (MS::kSuccess != status) {
        MString msg = MStringResource::getString(kCouldNotExport, status);
        MGlobal::displayError(msg);
        return false;
    }

    clip << kAnimData << kSpaceChar << kBraceLeftChar << endl;

    clip << kTwoSpace << kInputString << kSpaceChar <<
            boolInputTypeAsWord(animCurve.isUnitlessInput()) << 
            kSemiColonChar << endl;

    clip << kTwoSpace << kOutputString << kSpaceChar <<
            outputTypeAsWord(type) << kSemiColonChar << endl;

    clip << kTwoSpace << kWeightedString << kSpaceChar <<
            (animCurve.isWeighted() ? 1 : 0) << kSemiColonChar << endl;

    //  These units default to the units in the header of the file.
    //  
    if (verboseUnits) {
        clip << kTwoSpace << kInputUnitString << kSpaceChar;
        if (animCurve.isTimeInput()) {
            MString unitName;
            animUnitNames::setToShortName(timeUnit, unitName);
            clip << unitName;
        } else {
            //  The anim curve has unitless input.
            //
            clip << kUnitlessString;
        }
        clip << kSemiColonChar << endl;

        clip << kTwoSpace << kOutputUnitString << kSpaceChar;
    }

    double conversion = 1.0;
    MString unitName;
    switch (type) {
        case MFnAnimCurve::kAnimCurveTA:
        case MFnAnimCurve::kAnimCurveUA:
            animUnitNames::setToShortName(angularUnit, unitName);
            if (verboseUnits) clip << unitName;
            {
                MAngle angle(1.0);
                conversion = angle.as(angularUnit);
            }
            break;
        case MFnAnimCurve::kAnimCurveTL:
        case MFnAnimCurve::kAnimCurveUL:
            animUnitNames::setToShortName(linearUnit, unitName);
            if (verboseUnits) clip << unitName;
            {
                MDistance distance(1.0);
                conversion = distance.as(linearUnit);
            }
            break;
        case MFnAnimCurve::kAnimCurveTT:
        case MFnAnimCurve::kAnimCurveUT:
            animUnitNames::setToShortName(timeUnit, unitName);
            if (verboseUnits) clip << unitName;
            break;
        default:
            if (verboseUnits) clip << kUnitlessString;
            break;
    }
    if (verboseUnits) clip << kSemiColonChar << endl;

    if (verboseUnits) {
        MString angleUnitName;
        animUnitNames::setToShortName(angularUnit, angleUnitName);
        clip << kTwoSpace << kTanAngleUnitString << 
                kSpaceChar << angleUnitName << kSemiColonChar << endl;
    }

    clip << kTwoSpace << kPreInfinityString << kSpaceChar <<
            infinityTypeAsWord(animCurve.preInfinityType()) << 
            kSemiColonChar << endl;

    clip << kTwoSpace << kPostInfinityString << kSpaceChar <<
            infinityTypeAsWord(animCurve.postInfinityType()) << 
            kSemiColonChar << endl;

    clip << kTwoSpace << kKeysString << kSpaceChar << kBraceLeftChar << endl;

    // And then write out each keyframe
    //
    unsigned numKeys = animCurve.numKeyframes();
    for (unsigned i = 0; i < numKeys; i++) {
        clip << kTwoSpace << kTwoSpace;
        if (animCurve.isUnitlessInput()) {
            clip << animCurve.unitlessInput(i);
        }
        else {
            clip << animCurve.time(i).value();
        }

        // clamp tiny values so that it isn't so small it can't be read in
        //
        double animValue = (conversion*animCurve.value(i));
        if (animBase::isEquivalent(animValue,0.0)) animValue = 0.0;
        clip << kSpaceChar << animValue;

        clip << kSpaceChar << tangentTypeAsWord(animCurve.inTangentType(i));
        clip << kSpaceChar << tangentTypeAsWord(animCurve.outTangentType(i));

        clip << kSpaceChar << (animCurve.tangentsLocked(i) ? 1 : 0);
        clip << kSpaceChar << (animCurve.weightsLocked(i) ? 1 : 0);
        clip << kSpaceChar << (animCurve.isBreakdown(i) ? 1 : 0);

        if (animCurve.inTangentType(i) == MFnAnimCurve::kTangentFixed) {
            MAngle angle;
            double weight;
            animCurve.getTangent(i, angle, weight, true);

            clip << kSpaceChar << angle.as(angularUnit);
            clip << kSpaceChar << weight;
        }
        if (animCurve.outTangentType(i) == MFnAnimCurve::kTangentFixed) {
            MAngle angle;
            double weight;
            animCurve.getTangent(i, angle, weight, false);

            clip << kSpaceChar << angle.as(angularUnit);
            clip << kSpaceChar << weight;
        }

        clip << kSemiColonChar << endl;
    }
    clip << kTwoSpace << kBraceRightChar << endl;

    clip << kBraceRightChar << endl;

    return true;
}