Code (Command)

Introduced

4.0

Description

Sets and returns the implementation of the Command as a String value. Use this property as an alternative to storing the Command implementation in a file. This is a convenient way to implement small, simple script-based custom commands. The code is stored as part of the Command definition.

Any script language can be represented as a string, but the "toString()" method in JScript is particularly convenient for turning a function into its string representation.

The string must include a function with the name specified in the Command.Handler property, and it can also contain helper functions or global variables.

Note: Global variables will potentially be re-initialized each time the command is executed.

C# Syntax

    // get accessor
    String rtn = Command.Code;

    // set accessor
    Command.Code = String;

Examples

1. JScript Example

    /*
       Example of an embedded command
    */

    // These are the two different implementations of
    // the command that we will use

    function FuncImpl1( arg )
    {
       Application.LogMessage( arg ) ;
    }

    function FuncImpl2( arg )
    {
       XSIUIToolkit.MsgBox( arg ) ;
    }

    Application.RemoveCommand( "EmbeddedJScript" ) ;
    var cmd = Application.CreateCommand( "EmbeddedJScript" ) ;
    cmd.ScriptingName = "EmbeddedJScript" ;
    cmd.Language = "JScript" ;
    cmd.Handler = "FuncImpl1"
    cmd.Code = FuncImpl1.toString(); // Embed the code directly in the definition
    cmd.Arguments.Add( "arg1") ;
    cmd.ReturnValue = false   // Optional, but makes it explicit that this is
                           // is a subroutine

    Application.AddCommand( cmd ) ;

    //Tip: uncomment this line to see the command
    //that has just been defined
    //EditCommand( "EmbeddedJScript" ) ;

    //Execute the command
    //This will log:
    //INFO : "56"
    EmbeddedJScript( 56 ) ;

    //Change the code by updating the command with
    //a new function
    var cmd = Application.Commands( "EmbeddedJScript" ) ;
    cmd.Code = FuncImpl2.toString() ;
    cmd.Handler = "FuncImpl2" ;
    cmd.Update() ;

    //Execute the command
    //This will pop up a message box
    EmbeddedJScript( 56 ) ;

    //Cleanup
    Application.RemoveCommand( "EmbeddedJScript" ) ;

2. VBScript Example

    '
    '  VBScript example of an embedded command
    '

    'The implementation of the command is stored in this string
    'Clearly it would be awkward to write a huge command
    'like that.  For large custom commands we recommend that
    'you store the command in a file
    'and set the Command.FileName property.

    dim strCommandImpl
    strCommandImp = _
       "sub FuncImpl( arg )" & vbCrLf & _
       "   logmessage arg" & vbCrLf & _
       "end sub"

    Application.RemoveCommand "EmbeddedVBScript"
    set cmd = Application.CreateCommand( "EmbeddedVBScript" )
    cmd.ScriptingName = "EmbeddedVBScript"
    cmd.Language = "VBScript"
    cmd.Handler = "FuncImpl"
    cmd.Code = strCommandImp  ' Embed the code directly in the definition
    cmd.Arguments.Add "arg1"
    cmd.ReturnValue = false   ' Optional, but makes it explicit that this is
                           'is a subroutine

    Application.AddCommand( cmd )

    'Tip: uncomment this line to see the command
    'that has just been defined
    'EditCommand "EmbeddedVBScript"

    'Execute the command
    'This will log:
    'INFO : "56"
    EmbeddedVBScript 56

    'Change the code by updating the command with
    'a new function
    strCommandImp = _
       "sub FuncImpl( arg )" & vbCrLf & _
       "   MsgBox arg" & vbCrLf & _
       "end sub"
    set cmd = Application.Commands( "EmbeddedVBScript" )
    cmd.Code = strCommandImp
    cmd.Update

    'Execute the command
    'This will pop up a message box
    EmbeddedVBScript 56

    'Cleanup
    Application.RemoveCommand "EmbeddedVBScript"

3. Python Example

    #g_EmbeddedCmd is some simple python code that we will
    #use as the implementation of a custom command
    g_EmbeddedCmd = """

    #This routine expects in_obj to be a light
    def FuncWithLightAsArgCmdImp( in_obj ):
       Application.LogMessage( in_obj.Shaders.Count )
       Application.LogMessage( in_obj.Name )
    """

    #
    # Function that creates custom command, provides g_EmbeddedCmd
    # as the implementation and then calls it
    #
    def DemoObjectArgument():
       oDefaultLight = Application.ActiveSceneRoot.Children( "light" )

       Application.RemoveCommand( "pythontestcmd" )
       cmd = Application.CreateCommand( "pythontestcmd" )
       cmd.ScriptingName = "pythontestcmd"
       cmd.Code = g_EmbeddedCmd
       cmd.Language = "Python"
       cmd.Handler = "FuncWithLightAsArgCmdImp"
       cmd.Arguments.AddObjectArgument( "in_obj" )
       Application.AddCommand( cmd )

       Application.pythontestcmd( oDefaultLight )

       #Because of argument handler we can also call it
       #with a string and it will automatically be converted
       #into the object equivalent
       Application.pythontestcmd( "light" )

       Application.RemoveCommand( "pythontestcmd" )

    DemoObjectArgument()

    #Expected output
    #INFO : 2
    #INFO : light
    #INFO : 2
    #INFO : light

See Also

Command.FileName | Command.Handler

Autodesk Softimage v7.5