//-
// ==========================================================================
// 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;												
}