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

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

    //
    // node_info.cc
    //
    // This plugin prints out type and connected plug information for
    // the selected dependency nodes.
    //

    #include <maya/MIOStream.h>
    #include <maya/MFnPlugin.h>
    #include <maya/MString.h>
    #include <maya/MStringResource.h>
    #include <maya/MStringResourceId.h>
    #include <maya/MArgList.h>

    #include <maya/MPxCommand.h>
    #include <maya/MSyntax.h>
    #include <maya/MArgDatabase.h>

    #include <maya/MGlobal.h>
    #include <maya/MDagPath.h>
    #include <maya/MItSelectionList.h>
    #include <maya/MSelectionList.h>

    #include <maya/MFnDependencyNode.h>
    #include <maya/MPlugArray.h>
    #include <maya/MPlug.h>

    #define kQuietFlag      "-q"
    #define kQuietFlagLong  "-quiet"

    // String resource constants and registration

    #define rPluginId  "nodeInfoCmd"
    #define rConnFound MStringResourceId(rPluginId, "rConnFound", \
                                        "Number of connections found: ^1s")
    #define rPlugInfo  MStringResourceId(rPluginId, "rPlugInfo", \
                                        "  Plug Info: ")
    #define rPlugDestOf MStringResourceId(rPluginId, "rPlugDestOf",\
                                        "    This plug is a dest of: ")

    static MStatus registerMStringResources(void)
    {
        MStringResource::registerString(rConnFound);
        MStringResource::registerString(rPlugInfo);
        MStringResource::registerString(rPlugDestOf);
        return MS::kSuccess;
    }

    //
    // Command class declaration
    //
    class nodeInfo : public MPxCommand
    {
    public:
                        nodeInfo();
        virtual         ~nodeInfo();

        MStatus         doIt( const MArgList& args );

        static MSyntax  newSyntax();
        static void*    creator();

    private:
        void            printType( const MObject& node, const MString& prefix );
        MStatus         parseArgs( const MArgList& args );
        bool            quiet;
    };

    //
    // Command class implementation
    //

    nodeInfo::nodeInfo()
        : quiet (false)
    {}

    nodeInfo::~nodeInfo() {}

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

    MSyntax nodeInfo::newSyntax()
    {
         MSyntax syntax;
         syntax.addFlag(kQuietFlag, kQuietFlagLong);
         return syntax;
    }

    MStatus nodeInfo::parseArgs( const MArgList& args )
    {
        MStatus         stat;
        MArgDatabase    argData(syntax(), args);

        if (argData.isFlagSet(kQuietFlag))
            quiet = true;

        return stat;
    }

    MStatus nodeInfo::doIt( const MArgList& args )
    //
    // Description
    //     This method performs the action of the command.
    //
    //     This method iterates over all selected items and
    //     prints out connected plug and dependency node type
    //     information.
    //
    {
        MStatus stat;           // Status code
        MObject dependNode;     // Selected dependency node

        stat = parseArgs ( args );
        if ( !stat )
            return stat;

        // Create a selection list iterator
        //
        MSelectionList slist;
        MGlobal::getActiveSelectionList( slist );
        MItSelectionList iter( slist, MFn::kInvalid,&stat );

        // Iterate over all selected dependency nodes
        //
        for ( ; !iter.isDone(); iter.next() )
        {
            // Get the selected dependency node
            //
            stat = iter.getDependNode( dependNode );
            if ( !stat ) {
                stat.perror("getDependNode");
                continue;
            }

            // Create a function set for the dependency node
            //
            MFnDependencyNode fnDependNode( dependNode );

            // Check the type of the dependency node
            //
            MString nodeName = fnDependNode.name();
            nodeName += ": ";
            printType( dependNode, nodeName );

            // Get all connected plugs to this node
            //
            MPlugArray connectedPlugs;
            stat = fnDependNode.getConnections( connectedPlugs );

            int numberOfPlugs = connectedPlugs.length();
            if ( !quiet )
            {
                MString msgFmt = MStringResource::getString(rConnFound, stat);
                MString msg;
                MString arg;
                arg.set(numberOfPlugs);
                msg.format(msgFmt, arg);
                cerr << msg << endl;
            }

            // Print out the dependency node name and attributes
            // for each plug
            //
            MString pInfoMsg = MStringResource::getString(rPlugInfo, stat);
            for ( int i=0; i<numberOfPlugs; i++ )
            {
                MPlug plug = connectedPlugs[i];
                MString pinfo = plug.info();
                if ( !quiet )
                {
                    cerr << pInfoMsg << pinfo << endl;
                }

                // Now get the plugs that this plug is the
                // destination of and print the node type.
                //
                MPlugArray array;
                plug.connectedTo( array, true, false );

                MString dInfoMsg = MStringResource::getString(rPlugDestOf, stat);
                for ( unsigned int j=0; j<array.length(); j++ )
                {
                    MObject mnode = array[j].node();
                    printType( mnode, dInfoMsg );
                }
            }
        }
        return MS::kSuccess;
    }

    void nodeInfo::printType( const MObject& node, const MString& prefix )
    //
    // Description
    //     This method prints the type of the given node.
    //     prefix is a string that gets printed before the type name.
    //
    {
        if ( !quiet)
            cerr << prefix << node.apiTypeStr() << endl;

    }

    //
    // The following routines are used to register/unregister
    // the command we are creating within Maya
    //
    MStatus initializePlugin( MObject obj )
    {
        MStatus   status;
        MFnPlugin plugin( obj, PLUGIN_COMPANY, "3.0", "Any");

        status = plugin.registerUIStrings(registerMStringResources, "nodeInfoCmdInitStrings");
        if (!status) {
            status.perror("registerUIStrings");
            return status;
        }
        status = plugin.registerCommand( "nodeInfo",
                                          nodeInfo::creator,
                                          nodeInfo::newSyntax);
        if (!status) {
            status.perror("registerCommand");
            return status;
        }

        return status;
    }

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

        status = plugin.deregisterCommand( "nodeInfo" );
        if (!status) {
            status.perror("deregisterCommand");
            return status;
        }

        return status;
    }