MStatus AlembicProfileBeginCommand::doIt(const MArgList& args) { MStatus status = MS::kSuccess; #ifdef ESS_PROFILING MArgParser argData(syntax(), args, &status); if(!argData.isFlagSet("fileNameArg")) { // TODO: display dialog MGlobal::displayError("[ExocortexAlembic] No fileName specified."); return status; } // get the filename arg MString fileName = argData.flagArgumentString("fileNameArg",0); std::string strFileName( fileName.asChar() ); if( nameToProfiler.find( strFileName ) == nameToProfiler.end() ) { boost::shared_ptr<Profiler> profiler( new Profiler( strFileName.c_str() ) ); nameToProfiler.insert( std::pair<std::string, boost::shared_ptr<Profiler>>( strFileName, profiler ) ); } else { nameToProfiler[ strFileName]->resume(); } #endif return status; }
MStatus linearFrictionCmd::doIt(const MArgList& args) { MStatus stat; MArgDatabase argData(syntax(),args,&stat); if(argData.isFlagSet(lfFlag))argData.getFlagArgument(lfFlag,0,linearFriction); MSelectionList activeSelect; MGlobal::getActiveSelectionList(activeSelect); for(int i=0;i<activeSelect.length();i++) { MObject tNode; activeSelect.getDependNode(i,tNode); MFnDagNode fnDagNode(tNode); MObject pNode=fnDagNode.child(0); MFnDependencyNode fnNode(pNode); //MString name=fnNode1.name().asChar(); if(fnNode.typeId() == particleNode::typeId) { //get solver message attribute from particleNode MPlug(pNode, particleNode::linearFriction).setValue(linearFriction); } } return dgMod.doIt(); }
MStatus AlembicResolvePathCommand::doIt(const MArgList & args) { ESS_PROFILE_SCOPE("AlembicResolvePathCommand::doIt"); MStatus status = MS::kSuccess; MArgParser argData(syntax(), args, &status); if (argData.isFlagSet("help")) { MGlobal::displayInfo("[ExocortexAlembic]: ExocortexAlembic_resolvePath command:"); MGlobal::displayInfo(" -f : provide an unresolved fileName (string)"); return MS::kSuccess; } if(!argData.isFlagSet("fileNameArg")) { // TODO: display dialog MGlobal::displayError("[ExocortexAlembic] No fileName specified."); return status; } // get the filename arg MString fileName = argData.flagArgumentString("fileNameArg",0); setResult(resolvePath(fileName)); return status; }
MStatus classificationCommand::doIt( const MArgList& args ){ MStatus stat = MS::kSuccess; MString filePath,selectedList; unsigned int selectedNum; MArgDatabase argData( syntax(), args ); if( argData.isFlagSet( selectedNumFlag ) ) argData.getFlagArgument( selectedNumFlag, 0, selectedNum ); if( argData.isFlagSet( pathFlag ) ) argData.getFlagArgument( pathFlag, 0, filePath ); if( argData.isFlagSet( selectedFlag ) ) argData.getFlagArgument( selectedFlag, 0, selectedList ); MGlobal::displayInfo(selectedList); std::string s = std::to_string((long double)selectedNum); MString ms(s.c_str()); MGlobal::displayInfo(ms); return stat; }
MStatus AlembicProfileEndCommand::doIt(const MArgList& args) { MStatus status = MS::kSuccess; #ifdef ESS_PROFILING MArgParser argData(syntax(), args, &status); if(!argData.isFlagSet("fileNameArg")) { // TODO: display dialog MGlobal::displayError("[ExocortexAlembic] No fileName specified."); return status; } // get the filename arg MString fileName = argData.flagArgumentString("fileNameArg",0); std::string strFileName( fileName.asChar() ); if( nameToProfiler.find( strFileName ) != nameToProfiler.end() ) { nameToProfiler[ strFileName ]->stop(); } #endif return status; }
MStatus radiusCmd::doIt(const MArgList&args) { MStatus status=MStatus::kSuccess; MArgDatabase argData(syntax(),args,&status); if(argData.isFlagSet(rFlag))argData.getFlagArgument(rFlag,0,radius); MItDag dagItr(MItDag::kDepthFirst, MFn::kInvalid,&status); if(status!=MS::kSuccess){MGlobal::displayError(" Failure in DAG iterator");return status;} for(;!dagItr.isDone();dagItr.next()) { MDagPath dagPath; status = dagItr.getPath(dagPath); if(status!=MS::kSuccess){MGlobal::displayError(" Failure in getting path");return status;} MFnDagNode dagNode(dagPath,&status); if(dagNode.isIntermediateObject())continue; if(!dagPath.hasFn(MFn::kDependencyNode))continue; MObject mObj=dagNode.object(&status); if(status!=MS::kSuccess){MGlobal::displayError(" Failure in getting object");return status;} //getParticle MFnDependencyNode fnNode(mObj, &status); if(status!=MS::kSuccess){MGlobal::displayError(" Failure in getting dependency node");return status;} if(fnNode.typeId() == OParticleNode::typeId) MPlug(mObj, OParticleNode::radius).setValue(radius); } return status; }
MStatus GetMetaNodeConnectionCmd::parseArgs(const MArgList & args) { MStatus status; if( args.length() == 0 ) { return MS::kNotFound; } MArgDatabase argData(syntax(), args); //get the node name argument if (argData.isFlagSet(GetMetaNodeConnectionCmd::FileParam())) { MString tmp; status = argData.getFlagArgument(GetMetaNodeConnectionCmd::FileParam(), 0, tmp); if (!status) { status.perror("node flag parsing failed"); return status; } this->m_metaNodeName = tmp; } //get the connection name argument if (argData.isFlagSet(GetMetaNodeConnectionCmd::FileParam2())) { MString tmp; status = argData.getFlagArgument(GetMetaNodeConnectionCmd::FileParam2(), 0, tmp); if (!status) { status.perror("connection flag parsing failed"); return status; } this->m_connectionName = tmp; } return MS::kSuccess; }
MStatus TransferUV::doIt(const MArgList& args) { MStatus status; // if (args.length() != 1) // { // MGlobal::displayError("Need 1 arg!"); // return MStatus::kFailure; // } MArgDatabase argData(syntax(), args); // arg // MString argument = args.asString(0, &status); // if (status != MS::kSuccess) { // return MStatus::kFailure; // } // CHECK_MSTATUS_AND_RETURN_IT(status); if (argData.isFlagSet(sourceUvSetFlag)) { status = argData.getFlagArgument(sourceUvSetFlag, 0, sourceUvSet); CHECK_MSTATUS_AND_RETURN_IT(status); } if (argData.isFlagSet(targetUvSetFlag)) { status = argData.getFlagArgument(targetUvSetFlag, 0, targetUvSet); CHECK_MSTATUS_AND_RETURN_IT(status); } if (argData.isFlagSet(sourceMeshFlag)) { status = argData.getFlagArgument(sourceMeshFlag, 0, sourceMesh); } else { MGlobal::displayError( "Source mesh is not specified. -sm flag is required."); return MS::kFailure; } if (argData.isFlagSet(targetMeshFlag)) { status = argData.getFlagArgument(targetMeshFlag, 0, targetMesh); } else { MGlobal::displayError( "Target mesh is not specified. -tm flag is required."); return MS::kFailure; } MString info = "Copying uv from " + sourceUvSet + " to " + targetUvSet; MGlobal::displayInfo(info); MSelectionList mList; mList.add(sourceMesh); mList.add(targetMesh); mList.getDagPath(0, sourceDagPath); mList.getDagPath(1, targetDagPath); return redoIt(); }
MStatus particlePathsCmd::parseArgs( const MArgList& args ) { MArgDatabase argData(syntax(), args); // // Parse the time flags // if (argData.isFlagSet(startFlag)) { argData.getFlagArgument(startFlag, 0, start); } if (argData.isFlagSet(finishFlag)) { argData.getFlagArgument(finishFlag, 0, finish); } if (argData.isFlagSet(incrementFlag)) { argData.getFlagArgument(incrementFlag, 0, increment); } if (finish <= start || increment <= 0.0) { MGlobal::displayError( "Invalid time arguments." ); return MS::kFailure; } // // Get the particle system object // MSelectionList selectList; argData.getObjects(selectList); if( selectList.length() < 1 ) { MGlobal::displayError( "Missing particle node name argument." ); return MS::kFailure; } else if( selectList.length() > 1 ) { MGlobal::displayError( "Too many particle nodes given." ); return MS::kFailure; } selectList.getDependNode(0,particleNode); if (particleNode.isNull() || !particleNode.hasFn(MFn::kParticle)) { MGlobal::displayError( "Invalid node argument." ); return MS::kFailure; } return MS::kSuccess; }
MStatus lockEvent::parseArgs( const MArgList &args ) { MStatus status; MArgDatabase argData( syntax(), args ); fAttach = kAttachDV; fOverrideFlag = kOverrideDV; fClearCB = kClearCBDV; // begin-parse-args if ( argData.isFlagSet( kClearCB ) ) { fClearCB = !kClearCBDV; } if ( argData.isFlagSet( kOverride ) ) { bool tmp; status = argData.getFlagArgument( kOverride, 0, tmp ); if ( !status ) { MGlobal::displayError( "override flag parsing failed" ); return status; } fOverrideFlag = !kOverrideDV; fOverrideVal = tmp; } if ( argData.isFlagSet( kAttach ) ) { unsigned int tmp; status = argData.getFlagArgument( kAttach, 0, tmp ); if ( !status ) { MGlobal::displayError( "attach flag parsing failed" ); return status; } fAttach = tmp; } if ( fAttach ) { status = argData.getObjects( theList ); if ( theList.length() == 0 ) { MString msg = "You must specify a node/plug to attach to!"; MGlobal::displayError(msg); status = MS::kFailure; } } // Ensure that the caller did not specify too many arguments! // if ( status && fAttach && fOverrideFlag ) { MString msg = "You specified too many flags!" ; MGlobal::displayError(msg); status = MS::kFailure; } // end-parse-args return status; }
MStatus nodeInfo::parseArgs( const MArgList& args ) { MStatus stat; MArgDatabase argData(syntax(), args); if (argData.isFlagSet(kQuietFlag)) quiet = true; return stat; }
MStatus SelectRingToolCmd2::doIt( const MArgList &args ) { //MGlobal::displayInfo( "doIt" ); MStatus stat; MGlobal::getActiveSelectionList( prevSel ); // Initialize to default values selEdges = true; selFaces = false; selVertices = false; selEdgeObject = MDagPath(); selEdgeComp = MObject::kNullObj; listAdjust = MGlobal::kReplaceList; selType = RING; // Get the options from the command line MArgDatabase argData( syntax(), args, &stat ); if( !stat ) return stat; if( argData.isFlagSet( edgeFlag ) ) { MString edgeSpec; argData.getFlagArgument( edgeFlag, 0, edgeSpec ); MSelectionList sel; sel.add( edgeSpec ); sel.getDagPath( 0, selEdgeObject, selEdgeComp ); //MFnSingleIndexedComponent si( selEdgeComp ); //MGlobal::displayInfo( MString("doing stuff on ") + selEdgeObject.fullPathName() + " " + si.element(0) ); } if( argData.isFlagSet( selEdgesFlag ) ) argData.getFlagArgument( selEdgesFlag, 0, selEdges ); if( argData.isFlagSet( selFacesFlag ) ) argData.getFlagArgument( selFacesFlag, 0, selFaces ); if( argData.isFlagSet( selVerticesFlag ) ) argData.getFlagArgument( selVerticesFlag, 0, selVertices ); if( argData.isFlagSet( listAdjustFlag ) ) { unsigned value; argData.getFlagArgument( listAdjustFlag, 0, value ); listAdjust = MGlobal::ListAdjustment( value ); } if( argData.isFlagSet( selTypeFlag ) ) argData.getFlagArgument( selTypeFlag, 0, selType ); return redoIt(); }
QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::call(Object *o, QScriptContext *ctxt) { MethodData *method = static_cast<MethodData *>(o); if (method->data.flags & QDeclarativePropertyCache::Data::HasArguments) { QMetaMethod m = method->object->metaObject()->method(method->data.coreIndex); QList<QByteArray> argTypeNames = m.parameterTypes(); QVarLengthArray<int, 9> argTypes(argTypeNames.count()); // ### Cache for (int ii = 0; ii < argTypeNames.count(); ++ii) { argTypes[ii] = QMetaType::type(argTypeNames.at(ii)); if (argTypes[ii] == QVariant::Invalid) return Value(ctxt, ctxt->throwError(QString::fromLatin1("Unknown method parameter type: %1").arg(QLatin1String(argTypeNames.at(ii))))); } if (argTypes.count() > ctxt->argumentCount()) return Value(ctxt, ctxt->throwError(QLatin1String("Insufficient arguments"))); QVarLengthArray<MetaCallArgument, 9> args(argTypes.count() + 1); args[0].initAsType(method->data.propType, engine); for (int ii = 0; ii < argTypes.count(); ++ii) args[ii + 1].fromScriptValue(argTypes[ii], engine, ctxt->argument(ii)); QVarLengthArray<void *, 9> argData(args.count()); for (int ii = 0; ii < args.count(); ++ii) argData[ii] = args[ii].dataPtr(); QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, argData.data()); return args[0].toValue(engine); } else if (method->data.propType != 0) { MetaCallArgument arg; arg.initAsType(method->data.propType, engine); void *args[] = { arg.dataPtr() }; QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, args); return arg.toValue(engine); } else { void *args[] = { 0 }; QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, args); return Value(); } return Value(); }
MStatus particleCmd::doIt(const MArgList& args) { MStatus status=MStatus::kSuccess; MArgDatabase argData(syntax(),args,&status); if(argData.isFlagSet(pxFlag))argData.getFlagArgument(pxFlag,0,x); if(argData.isFlagSet(pyFlag))argData.getFlagArgument(pyFlag,0,y); if(argData.isFlagSet(pzFlag))argData.getFlagArgument(pzFlag,0,z); if(status==MS::kFailure)return status; return redoIt(); }
//********************************************************* // Name: parseCommandFlags // Desc: Parsed the command flags and stores the values // in the appropriate variables //********************************************************* void BreakdownCommand::parseCommandFlags( const MArgList &args ) { MArgDatabase argData( syntax(), args, &status ); if( !status ) { pluginError( "BreakdownCommand", "parseCommandFlags", "Failed to create MArgDatabase for the breakdown command" ); } else { if( argData.isFlagSet( weightFlag )) argData.getFlagArgument( weightFlag, 0, breakdownWeight ); if( argData.isFlagSet( selectedAttrFlag )) argData.getFlagArgument( selectedAttrFlag, 0, selectedAttrOnly ); if( argData.isFlagSet( ignoreRippleCheckFlag )) argData.getFlagArgument( ignoreRippleCheckFlag, 0, ignoreRippleCheck ); if( argData.isFlagSet( tickDrawSpecialFlag )) argData.getFlagArgument( tickDrawSpecialFlag, 0, tickDrawSpecial ); if( argData.isFlagSet( invalidAttrOpFlag )) { MString strAttrOp; argData.getFlagArgument( invalidAttrOpFlag, 0, strAttrOp ); if( strAttrOp == "skipAll" ) invalidAttrOp = kSkipAll; else if( strAttrOp == "skipObject" ) invalidAttrOp = kSkipObject; else if( strAttrOp == "skipAttr" ) invalidAttrOp = kSkipAttr; else MGlobal::displayWarning( "Invalid arguement for -invalidAttrOp. Using default value." ); } if( argData.isFlagSet( modeFlag )) { MString strMode; argData.getFlagArgument( modeFlag, 0, strMode ); if( strMode == "overwrite" ) breakdownMode = Breakdown::kOverwrite; else if( strMode == "ripple" ) breakdownMode = Breakdown::kRipple; } // Ripple mode ignores the selectedAttrOnly flag. // All attributes will be affected. if( breakdownMode == Breakdown::kRipple ) { if( selectedAttrOnly == true ) { selectedAttrOnly = false; MGlobal::displayWarning( "Key Selected flag is ignored in Ripple Mode" ); } } } }
MStatus Molecule3Cmd::doIt( const MArgList &args ) { MStatus stat; // Initialize options to default values MFnTypedAttribute tAttr( /* radius.setValue( 0.1 ); segs = 6; ballRodRatio = 2.0; */ selMeshes.clear(); // Get the options from the command line MArgDatabase argData( syntax(), args, &stat ); if( !stat ) return stat; if( argData.isFlagSet( radiusFlag ) ) argData.getFlagArgument( radiusFlag, 0, radius ); if( argData.isFlagSet( segsFlag ) ) argData.getFlagArgument( segsFlag, 0, segs ); if( argData.isFlagSet( ballRatioFlag ) ) argData.getFlagArgument( ballRatioFlag, 0, ballRodRatio ); // Get a list of currently selected objects MSelectionList selection; MGlobal::getActiveSelectionList( selection ); // Iterate over the meshes MDagPath dagPath; MItSelectionList iter( selection, MFn::kMesh ); for ( ; !iter.isDone(); iter.next() ) { iter.getDagPath( dagPath ); selMeshes.append( dagPath ); } if( selMeshes.length() == 0 ) { MGlobal::displayWarning( "Select one or more meshes" ); return MS::kFailure; } return redoIt(); }
MStatus MeshControlCmd::doIt( const MArgList& args ) { MStatus s; MSelectionList selection; MSyntax syn = syntax(); MArgDatabase argData(syn, args); setResult(0); if (argData.isFlagSet(m_nameFlag[1], &s)) { MString nodeName; // 提取某个名字的节点 s = argData.getFlagArgument(m_nameFlag[1],0, nodeName); s = MGlobal::getSelectionListByName(nodeName, selection); } else s = MGlobal::getActiveSelectionList(selection); // 提取选中节点 if (!s)return MS::kSuccess; bool isInitFlagSet = argData.isFlagSet(m_initFlag[1], &s); MItSelectionList pSel(selection, MFn::kDependencyNode , &s); MObject obj; for (; !pSel.isDone(); pSel.next()) { MObject depNode; pSel.getDependNode(depNode); MFnDependencyNode nodeFn(depNode, &s); MString typeName = nodeFn.typeName(&s); if (typeName != NODE_CAGE_DEFORMER_NAME) continue; CageDeformerNode* node = (CageDeformerNode*)nodeFn.userNode(&s); if (!s) continue; if (isInitFlagSet) { s = node->computeWeight(); } if (!s) { MGlobal::displayError("faild to compute weight"); } else MGlobal::displayInfo("succeed to compute weight"); } return MS::kSuccess; }
// parseArgs // MStatus viewCallbackTest::parseArgs(const MArgList& args) { MStatus status; MArgDatabase argData(syntax(), args); // Buffer operation argument variables mBufferOperation = kInvertColorBuffer; MString operationString; MString arg; for ( unsigned int i = 0; i < args.length(); i++ ) { arg = args.asString( i, &status ); if (!status) continue; if ( arg == MString(bufferOperationShortName) || arg == MString(bufferOperationLongName) ) { if (i == args.length()-1) { arg += ": must specify a buffer operation."; displayError(arg); return MS::kFailure; } i++; args.get(i, operationString ); bool validOperation = false; for (unsigned int k=0; k<_NUMBER_BUFFER_OPERATIONS_; k++) { if (bufferOperationStrings[i] == operationString) { mBufferOperation = bufferOperations[k]; validOperation = true; } } if (!validOperation) status.perror("Invalid operation specified. Using invert by default."); } } // Read off the panel name status = argData.getCommandArgument(0, mPanelName); if (!status) { status.perror("No panel name specified as command argument"); return status; } return MS::kSuccess; }
MStatus NeuronForMayaCmd::parseArgs( const MArgList& args ) { MStatus status = MStatus::kSuccess; MArgDatabase argData(syntax(), args); if (argData.isFlagSet(kStartFlag)) status = argData.getFlagArgument(kStartFlag, 0, mStart); if( argData.isFlagSet(kDeviceNameFlag)) status = argData.getFlagArgument(kDeviceNameFlag, 0, mDeviceName ); return status; }
MStatus brushToolCommand::parseArgs(const MArgList& args) { MArgDatabase argData(syntax(), args); MStatus status; if (argData.isFlagSet(radiusFlag)) { double tmp; status=argData.getFlagArgument(radiusFlag, 0, tmp); if (!status) { status.perror("radius flag parsing failed"); return status; } radius=(float)tmp; } if (argData.isFlagSet(lockBaseFlag)) { status=argData.getFlagArgument(lockBaseFlag, 0,lockbase); if (!status) { status.perror("lockbase flag parsing failed"); return status; } } if (argData.isFlagSet(intensityFlag)) { status=argData.getFlagArgument(intensityFlag, 0,inten); if (!status) { status.perror("intensity flag parsing failed"); return status; } } if (argData.isFlagSet(brushModeFlag)) { status=argData.getFlagArgument(brushModeFlag, 0,brushModeVal); if (!status) { status.perror("brush mode flag parsing failed"); return status; } } return MS::kSuccess; }
MStatus clusterWeightFunctionCmd::parseArgs(const MArgList &argList) { MArgDatabase argData(syntax(), argList); if (argData.isFlagSet(kSineFlag)) { fEffectType = kSine; } else if (argData.isFlagSet(kSineDistanceFlag)) { fEffectType = kSineDistance; } else if (argData.isFlagSet(kSineDistance2Flag)) { fEffectType = kSineDistance2; } else if (argData.isFlagSet(kDistanceSineDistanceFlag)) { fEffectType = kDistanceSineDistance; } else if (argData.isFlagSet(kInverseDistanceSineDistanceFlag)) { fEffectType = kInverseDistanceSineDistance; } else if (argData.isFlagSet(kDistanceFlag)) { fEffectType = kDistance; } else if (argData.isFlagSet(kDistance2Flag)) { fEffectType = kDistance2; } else if (argData.isFlagSet(kDistance3Flag)) { fEffectType = kDistance3; } else if (argData.isFlagSet(kDistance4Flag)) { fEffectType = kDistance4; } else if (argData.isFlagSet(kInverseDistanceFlag)) { fEffectType = kInverseDistance; } else if (argData.isFlagSet(kInverseDistance2Flag)) { fEffectType = kInverseDistance2; } else if (argData.isFlagSet(kInverseDistance3Flag)) { fEffectType = kInverseDistance3; } else if (argData.isFlagSet(kInverseDistance4Flag)) { fEffectType = kInverseDistance4; } return MS::kSuccess; }
// parseArgs // MStatus eventTest::parseArgs(const MArgList& args) { MStatus status; MArgDatabase argData(syntax(), args); if (argData.isFlagSet(kMessageFlag)) { bool flag; status = argData.getFlagArgument(kMessageFlag, 0, flag); if (!status) { status.perror("could not parse message flag"); return status; } if (flag) { addMessage = true; } else { delMessage = true; } } status = argData.getObjects(events); if (!status) { status.perror("could not parse event names"); } // If there are no events specified, operate on all of them // if (events.length() == 0) { // eventNames is set in initializePlugin to all the // currently available event names. // events = eventNames; } return status; }
MStatus exportTerrain::parseArguments(const MArgList &args, bool& phy) { MStatus status; MArgDatabase argData(syntax(), args,&status); if(!status){ fout << status << "Some error!"; return status; } phy=argData.isFlagSet(kPhysicsFlag); return MStatus::kSuccess; }
MStatus deletedMessage::doIt( const MArgList& args ) { MStatus status = MS::kSuccess; MArgDatabase argData(syntax(), args); MSelectionList objects; argData.getObjects(objects); for (unsigned int i = 0; i < objects.length(); i++) { MObject node; objects.getDependNode(i, node); callbackIds.append( MNodeMessage::addNodeAboutToDeleteCallback (node, aboutToDeleteCB, NULL, &status) ); if (!status) { MGlobal::displayWarning("Could not attach about to delete callback for node."); continue; } callbackIds.append( MNodeMessage::addNodePreRemovalCallback (node, preRemovalCB, NULL, &status) ); if (!status) { MGlobal::displayWarning("Could not attach pre-removal callback for node."); continue; } if (!nodeRemovedCBRegistered) { callbackIds.append( MDGMessage::addNodeRemovedCallback(removeCB, "dependNode", NULL, &status) ); if (!status) { MGlobal::displayWarning("Could not attach node removal callback."); continue; } nodeRemovedCBRegistered = true; } } return status; }
MStatus peltOverlap::parseArgs( const MArgList& args ) { MStatus status = MS::kSuccess; MArgDatabase argData(syntax(), args); if (argData.isFlagSet(kExitFlag)) { status = argData.getFlagArgument(kExitFlag, 0, fNthPairs); if (status != MS::kSuccess) { MGlobal::displayError("-ea/exitAfterNthPairs is missing an int argument"); return status; } } status = argData.getObjects(fShadingGroups); if (status != MS::kSuccess || fShadingGroups.length() < 1) { MGlobal::displayError("Missing shading group(s) input"); status = MS::kFailure; } return status; }
QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::callMethod(QObject *object, int index, int returnType, int argCount, int *argTypes, QScriptContext *ctxt) { if (argCount > 0) { QVarLengthArray<MetaCallArgument, 9> args(argCount + 1); args[0].initAsType(returnType, engine); for (int ii = 0; ii < argCount; ++ii) args[ii + 1].fromScriptValue(argTypes[ii], engine, ctxt->argument(ii)); QVarLengthArray<void *, 9> argData(args.count()); for (int ii = 0; ii < args.count(); ++ii) argData[ii] = args[ii].dataPtr(); QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, argData.data()); return args[0].toValue(engine); } else if (returnType != 0) { MetaCallArgument arg; arg.initAsType(returnType, engine); void *args[] = { arg.dataPtr() }; QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args); return arg.toValue(engine); } else { void *args[] = { 0 }; QMetaObject::metacall(object, QMetaObject::InvokeMetaMethod, index, args); return Value(); } }
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; }
MStatus tm_polyExtract::doIt( const MArgList& args ) { MStatus stat = MS::kSuccess; clearResult(); MArgDatabase argData( syntax(), args); // if(argData.isFlagSet( extractFaces_Flag)) { MSelectionList selectionList; argData.getObjects( selectionList); MStringArray node_names; bool result = extractFaces_Func( selectionList, node_names); if(!result) { MGlobal::displayError("tm_polyExtract: extractFaces function call failed."); return MStatus::kFailure; } setResult( node_names); return stat; } }
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 AlembicPolyMeshToSubdivCommand::doIt(const MArgList& args) { MStatus status; MArgParser argData(syntax(), args, &status); if (argData.isFlagSet("help")) { MGlobal::displayInfo("[ExocortexAlembic]: ExocortexAlembic_meshToSubdiv command:"); MGlobal::displayInfo(" -m : mesh to assign the initialShadingGroup on"); return MS::kSuccess; } const MString mesh = argData.isFlagSet("mesh") ? ("\"" + argData.flagArgumentString("mesh", 0) + "\"") : ""; MString result; MGlobal::executePythonCommand(("ExoAlembic._functions.alembicPolyMeshToSubdiv(" + mesh) + ")", result); if (result.length()) { MPxCommand::setResult(result); return MS::kFailure; } return MS::kSuccess; }