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

/* 

    file : userMsgCmd.cpp
    class: userMessage
    ----------------------
    This is an example to demonstrate the usages of the MUserEventMessage class.
    It allows the user to create, destroy, and post to user-defined events
    identified by strings.

    The command "userMessage" supports the following options:

        -r/-register string : Register a new event type with the given name.
            Registration also attaches two callback functions to the event,
            userCallback1 and userCallback2.

        -d/-deregister string : Deregister an existing event with the given name

        -p/-post string : Post the event.  In this case, it simply notifies
            userCallback1 and userCallback2, which print info messages.

        -t/-test : Run a basic set of tests that demonstrate how the user event
            types can be used.  See userMessage::runTests()

    Only one option should be specified per invokation.
    
*/

#include <maya/MFnPlugin.h>
#include <maya/MStatus.h>
#include <maya/MPxCommand.h>
#include <maya/MMessage.h>
#include <maya/MUserEventMessage.h>
#include <maya/MGlobal.h>
#include <maya/MArgList.h>
#include <maya/MArgDatabase.h>
#include <maya/MSyntax.h>

// Syntax string definitions
static const char *postFlag = "-p";
static const char *postLongFlag = "-post";
static const char *registerFlag = "-r";
static const char *registerLongFlag = "-register";
static const char *deregisterFlag = "-d";
static const char *deregisterLongFlag = "-deregister";
static const char *testFlag = "-t";
static const char *testLongFlag = "-test";

class userMessage : public MPxCommand
{
    public:
        virtual MStatus doIt( const MArgList& );
        void runTests();

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

        // callback functions.
        static void userCallback1(void* clientData);
        static void userCallback2(void* clientData);

    private:
        static MString stringClientData;
};

// Define a string that will be passed to the callback functions
MString userMessage::stringClientData = "Sample Client Data (an MString object)";

MStatus userMessage::doIt( const MArgList& args )
{
    MStatus status = MS::kSuccess;

    MArgDatabase argData(syntax(), args);

    if (argData.isFlagSet(deregisterFlag))
    {
        MString event;
        argData.getFlagArgument(deregisterFlag, 0, event);
        status = MUserEventMessage::deregisterUserEvent(event);
    }
    else if (argData.isFlagSet(registerFlag))
    {
        // Register the new event and add two fixed callbacks to it.
        MString event;
        argData.getFlagArgument(registerFlag, 0, event);
        if (!MUserEventMessage::isUserEvent(event)) {
            status = MUserEventMessage::registerUserEvent(event);
            if (status == MS::kSuccess)
            {
                MUserEventMessage::addUserEventCallback(event,userCallback1,(void*) &stringClientData,&status);
                MUserEventMessage::addUserEventCallback(event,userCallback2,(void*) &stringClientData,&status);
            }
        }
    }
    else if (argData.isFlagSet(postFlag))
    {
        MString event;
        argData.getFlagArgument(postFlag, 0, event);
        status = MUserEventMessage::postUserEvent(event);
    }
    else if (argData.isFlagSet(testFlag))
    {
        runTests();
    }

    return status;
}


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

MSyntax userMessage::newSyntax() {
    MSyntax syntax;
    syntax.addFlag( postFlag, postLongFlag, MSyntax::kString );
    syntax.addFlag( registerFlag, registerLongFlag, MSyntax::kString );
    syntax.addFlag( deregisterFlag, deregisterLongFlag, MSyntax::kString );
    syntax.addFlag( testFlag, testLongFlag );
    return syntax;
}

void userMessage::userCallback1(void* clientData) {
    MGlobal::displayInfo("Entered userMessage::userCallback1");
    if (clientData != 0)
    {
        MString receivedDataMsg(MString("Received data: ") + *((MString*) clientData));
        MGlobal::displayInfo(receivedDataMsg);
    }
}

void userMessage::userCallback2(void* clientData) {
    MGlobal::displayInfo("Entered userMessage::userCallback2");
    if (clientData != 0)
    {
        MString receivedDataMsg(MString("Received data: ") + *((MString*) clientData));
        MGlobal::displayInfo(receivedDataMsg);
    }
}

void userMessage::runTests() {

    MStatus status;

    // Test 1: Try to register callback for nonexistent event

    MGlobal::displayInfo("Starting Test 1");

    MUserEventMessage::addUserEventCallback("TestEvent",userCallback1,0,&status);
    if (!status) {
        MGlobal::displayInfo("Test 1 passed");
    }
    else {
        MGlobal::displayInfo("Test 1 failed");
    }

    // Test 2: Register and deregister an event 
    // - Expected output: Entered userMessage::userCallback1

    MGlobal::displayInfo("Starting Test 2");

    MUserEventMessage::registerUserEvent("TestEvent");
    MUserEventMessage::addUserEventCallback("TestEvent",userCallback1,0,&status);
    MUserEventMessage::postUserEvent("TestEvent");
    MUserEventMessage::deregisterUserEvent("TestEvent");

    // Test 3: The event should be gone
    MGlobal::displayInfo("Starting Test 3");
    MUserEventMessage::addUserEventCallback("TestEvent",userCallback1,0,&status);
    if (!status) {
        MGlobal::displayInfo("Test 3 passed");
    }
    else {
        MGlobal::displayInfo("Test 3 failed");
    }

    // Test 4: Try adding multiple callbacks to an event
    // Expected output: Entered userMessage::userCallback1
    //                  Entered userMessage::userCallback2

    MGlobal::displayInfo("Starting Test 4");

    MUserEventMessage::registerUserEvent("TestEvent");
    MUserEventMessage::addUserEventCallback("TestEvent",userCallback1,0,&status);
    MUserEventMessage::addUserEventCallback("TestEvent",userCallback2,0,&status);
    MUserEventMessage::postUserEvent("TestEvent");
    MUserEventMessage::deregisterUserEvent("TestEvent");
   
    // Test 5: Try adding and posting to multiple events
    // Expected output: Posting first event
    //                  Entered userMessage::userCallback1
    //                  Entered userMessage::userCallback2
    //                  Posting second event
    //                  Entered userMessage::userCallback1
    //                  Entered userMessage::userCallback2

    MGlobal::displayInfo("Starting Test 5");

    MUserEventMessage::registerUserEvent("TestEvent");
    MUserEventMessage::registerUserEvent("TestEvent2");
    MUserEventMessage::addUserEventCallback("TestEvent",userCallback1,0,&status);
    MUserEventMessage::addUserEventCallback("TestEvent",userCallback2,0,&status);
    MUserEventMessage::addUserEventCallback("TestEvent2",userCallback1,0,&status);
    MUserEventMessage::addUserEventCallback("TestEvent2",userCallback2,0,&status);
    MGlobal::displayInfo("Posting first event");
    MUserEventMessage::postUserEvent("TestEvent");
    MGlobal::displayInfo("Posting second event");
    MUserEventMessage::postUserEvent("TestEvent2");
    MUserEventMessage::deregisterUserEvent("TestEvent");
    MUserEventMessage::deregisterUserEvent("TestEvent2");
 
    MGlobal::displayInfo("Completed all tests");
}


// standard initialize and uninitialize functions

MStatus initializePlugin(MObject obj)
{
    // Version number may need to change in the future
    //
    MFnPlugin pluginFn(obj, PLUGIN_COMPANY, "6.0");

    MStatus status;
    status = pluginFn.registerCommand("userMessage", userMessage::creator, userMessage::newSyntax);

    if( !status)
        status.perror("register Command failed");

    return status;
}


MStatus uninitializePlugin ( MObject obj )
{
    MFnPlugin pluginFn(obj);
    MStatus status = MS::kSuccess;
    
    //remove call backs
    MUserEventMessage::deregisterUserEvent("TestFoo1");
    MUserEventMessage::deregisterUserEvent("TestFoo2");

    status = pluginFn.deregisterCommand("userMessage");
    
    return status;
}