nodeCreatedCBCmd.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.
// ==========================================================================
//+

// MEL Command: nodeCreatedCB
//
// Description:
//              A simple plugin to register a mel proc to be called whenever a node is 
//              created. Registered Mel procedures should be declared to take a single
//              string argument (the name of the added node).
//
//              Warning: mel procedures registered with this method will be called 
//                               whenever a node is added to the DG. This may cause problems
//                               in certain cases. For example: each time a reference is 
//                               reloaded, each of its nodes is re-added to the DG.
//
// Flags:
//              -register/-r string: registers a mel callback. There is no limit
//                                                       to the number of callbacks that can be registered.
//
//              -unregister/-u string: unregister the specified callback.
//
//              -filter/-f string: by default all registered callbacks will be called
//                                                 whenever any node is created. Using the filter flag
//                                                 you can indicate that callbacks should only be
//                                                 called when certain node types are created.
//                                                 To determine the type of a particular node see the
//                                                 'objectType' and 'nodeType' commands.
//
//                                                 Note: only one filter can be in affect at a time,
//                                                 and it will be applied to all registered callbacks.
//
//              -fullDagPath/-fdp: if this flag is specified when registering a 
//                                                 callback, any dag node names passed into the mel
//                                                 procedure will include the full dag path.
//
// Note:
//              The -register, -unregister, and -filter flags are mutually exclusive, 
//              only one should be used per command invocation.
//
// Important:
//              Do not delete the node in your callback.
//
// Example Usage:
//
// // Appends the suffix '_ply' to all created mesh nodes
// //
// global proc myCB( string $node )
// {
//              print("calling polyCB " + $node + "\n");
//              string $type = `objectType $node`;
//              if ( $type == "mesh" ) {
//                      rename $node ($node+"_ply");
//              }       
// }
//
// nodeCreatedCB -register "myCB";
//
#include <nodeCreatedCBCmd.h>
#include <maya/MFnPlugin.h>
#include <maya/MObject.h>
#include <maya/MFnDependencyNode.h>
#include <maya/MFnDagNode.h>
#include <maya/MDGMessage.h>
#include <maya/MArgDatabase.h>
#include <maya/MSyntax.h>
#include <maya/MGlobal.h>

#define kRegisterFlagLong               "-register"
#define kRegisterFlag                   "-r"
#define kUnregisterFlagLong             "-unregister"
#define kUnregisterFlag                 "-u"
#define kFilterFlagLong                 "-filter"
#define kFilterFlag                             "-f"
#define kFullDagPathFlagLong    "-fullDagPath"
#define kFullDagPathFlag                "-fdp"


// The id of the API callback. The API callback must be removed when this
// plug-in is unloaded.
//
MCallbackId             nodeCreatedCB::sId;
// The array of all registered Mel procedures.
//
MStringArray    nodeCreatedCB::sMelProcs;
// Flags to indicate whether or not a mel procedure should be passed the
// short or long names of dag nodes.
//
MIntArray               nodeCreatedCB::sFullDagPath;


MStatus nodeCreatedCB::doIt( const MArgList& args )
//
//      Description:
//              implements the MEL nodeCreatedCB command.
//
{
        MStatus stat = MS::kSuccess;

        MArgDatabase argData( syntax(), args );

        // Parse command flags.
        //
        if ( argData.isFlagSet( kRegisterFlag ) ) {
                // Register a new procedure.
                //
                MString proc;
                argData.getFlagArgument( kRegisterFlag, 0, proc );
                stat = registerMelProc( proc, argData.isFlagSet( kFullDagPathFlag ) );
        } else if ( argData.isFlagSet( kUnregisterFlag ) ) {
                // Unregister a procedure.
                //
                MString proc;
                argData.getFlagArgument( kUnregisterFlag, 0, proc );
                stat = unregisterMelProc( proc );
        } else if ( argData.isFlagSet( kFilterFlag ) ) {
                // Change the filter being applied.
                //
                MString filter;
                argData.getFlagArgument( kFilterFlag, 0, filter );
                stat = changeFilter( filter );
        }
        
        if ( stat.error() ) {
                MGlobal::displayError( stat.errorString() );
        }

        return stat;
}

MStatus nodeCreatedCB::registerMelProc( MString melProc, bool fullDagPath )
//
// Register a Mel procedure to be called whenever a node is added.
//
{
        MStatus stat = MS::kSuccess;
        if ( melProc.length() == 0 ) {
                // Basic error checking. An empty string is not a valid mel procedure
                // name
                //
                stat = MS::kFailure;
                stat.perror("invalid mel callback: " + melProc);
                return stat;
        }
        nodeCreatedCB::sMelProcs.append( melProc );
        nodeCreatedCB::sFullDagPath.append( fullDagPath );
        return stat;
}

MStatus nodeCreatedCB::unregisterMelProc( MString melProc )
//
// Unregister a Mel procedure.
//
{
        MStatus stat = MS::kFailure;
        int numProcs = nodeCreatedCB::sMelProcs.length();
        for ( int i = 0; i < numProcs; i++ ) {
                // Search the array of registered callbacks for melProc and
                // remove it. If melProc exists more than once, only one instance
                // of it will be removed.
                //
                if ( nodeCreatedCB::sMelProcs[i] == melProc ) {
                        nodeCreatedCB::sMelProcs.remove(i);
                        nodeCreatedCB::sFullDagPath.remove(i);
                        stat = MS::kSuccess;
                        break;
                }
        }

        if ( !stat ) {
                // Report an error if melProc was not found.
                //
                stat.perror(melProc + " is not a registered callback.");
        }

        return stat;
}

MStatus nodeCreatedCB::changeFilter( MString filter )
//
// Change the node type filter.
//
{
        MStatus stat = MS::kSuccess;
        // We don't want to add sCallbackFunc more than once as that will cause
        // all registered Mel procs to be called multiple times. So we first
        // remove, then re-add the callback.
        //
        MDGMessage::removeCallback( nodeCreatedCB::sId );
        nodeCreatedCB::sId = MDGMessage::addNodeAddedCallback( nodeCreatedCB::sCallbackFunc, filter );
        return stat;
}

void nodeCreatedCB::sCallbackFunc( MObject& node, void* clientData )
//
// The API callback called whenever a node is added. This function handles
// calling all registered MEL callbacks and passing them the appropriate
// node name argument.
//
{
        int numProcs = nodeCreatedCB::sMelProcs.length();
        for ( int i = 0; i < numProcs; i++ ) {
                MString melCmd = nodeCreatedCB::sMelProcs[i];
                MString nodeName;
                if ( nodeCreatedCB::sFullDagPath[i] && 
                         node.hasFn( MFn::kDagNode ) ) {
                        MFnDagNode dagObj( node );
                        nodeName = dagObj.fullPathName();
                } else {
                        MFnDependencyNode dn( node );
                        nodeName = dn.name();
                }
                melCmd += " \"" + nodeName + "\"";
                MGlobal::executeCommand( melCmd );
        }
}

MSyntax nodeCreatedCB::newSyntax()
//
// Create the syntax object for the nodeCreateCB command.
//
{
        MSyntax syntax;

        syntax.addFlag( kRegisterFlag, kRegisterFlagLong, MSyntax::kString );
        syntax.addFlag( kUnregisterFlag, kUnregisterFlagLong, MSyntax::kString );
        syntax.addFlag( kFilterFlag, kFilterFlagLong, MSyntax::kString );
        syntax.addFlag( kFullDagPathFlag, kFullDagPathFlagLong );

        return syntax;
}
                                                                                                                
void* nodeCreatedCB::creator()                                                                          
{                                                                                                                               
        return new nodeCreatedCB;                                                                               
}
                                                                                                                        
MStatus initializePlugin( MObject obj )                                         
{                                                                                                                               
        MFnPlugin       plugin( obj, PLUGIN_COMPANY, "6.0" );                           
        MStatus         stat;                                                                                   
        stat = plugin.registerCommand( "nodeCreatedCB",                                 
                                        nodeCreatedCB::creator,
                                                                        nodeCreatedCB::newSyntax );         
        if ( !stat )                                                                                            
                stat.perror("registerCommand"); 
        
        // add the API callback.
        //
        nodeCreatedCB::sId = MDGMessage::addNodeAddedCallback( nodeCreatedCB::sCallbackFunc );

        return stat;                                                                                            
}                                                                                                                               
MStatus uninitializePlugin( MObject obj )                                               
{                                                                                                                               
        MFnPlugin       plugin( obj );                                                                  
        MStatus         stat;                                                                                   
        stat = plugin.deregisterCommand( "nodeCreatedCB" );                             
        if ( !stat )                                                                                            
                stat.perror("deregisterCommand");                                               

        // Remove the API callback, necessary to prevent crashes.
        //
        MDGMessage::removeCallback( nodeCreatedCB::sId );

        nodeCreatedCB::sMelProcs.clear();
        nodeCreatedCB::sFullDagPath.clear();
        
        return stat;                                                                                            
}