You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
650 lines
19 KiB
650 lines
19 KiB
/*==LICENSE==* |
|
|
|
CyanWorlds.com Engine - MMOG client, server and tools |
|
Copyright (C) 2011 Cyan Worlds, Inc. |
|
|
|
This program is free software: you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation, either version 3 of the License, or |
|
(at your option) any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
You can contact Cyan Worlds, Inc. by email legal@cyan.com |
|
or by snail mail at: |
|
Cyan Worlds, Inc. |
|
14617 N Newport Hwy |
|
Mead, WA 99021 |
|
|
|
*==LICENSE==*/ |
|
#include "HeadSpin.h" |
|
#include "plPythonMgr.h" |
|
|
|
#include "../MaxComponent/plAutoUIBlock.h" |
|
//#include "Python.h" |
|
#include "plMaxCFGFile.h" |
|
#include "../plFile/hsFiles.h" |
|
|
|
#include "plgDispatch.h" |
|
#include "../pfPython/cyPythonInterface.h" |
|
#include "hsUtils.h" |
|
|
|
plPythonMgr::plPythonMgr() |
|
{ |
|
} |
|
|
|
plPythonMgr& plPythonMgr::Instance() |
|
{ |
|
static plPythonMgr theInstance; |
|
return theInstance; |
|
} |
|
|
|
// Python wants char, not const char, LAME! |
|
static char* kGetBlockID = "glue_getBlockID"; |
|
static char* kGetClassName = "glue_getClassName"; |
|
static char* kGetNumParams = "glue_getNumParams"; |
|
static char* kGetParam = "glue_getParam"; |
|
static char* kGetVersion = "glue_getVersion"; |
|
static char* kIsMultiModifier = "glue_isMultiModifier"; |
|
static char* kGetVisInfo = "glue_getVisInfo"; |
|
|
|
bool ICallVoidFunc(PyObject *dict, char *funcName, PyObject*& val) |
|
{ |
|
PyObject *func = PyDict_GetItemString(dict, (char*)funcName); |
|
if (func ) |
|
{ |
|
if (PyCallable_Check(func)) |
|
{ |
|
val = PyObject_CallFunction(func, NULL); |
|
if (val) |
|
{ |
|
// there might have been some message printed, so get it out to the log file |
|
PythonInterface::getOutputAndReset(); |
|
return true; |
|
} |
|
|
|
// There was an error when calling the function |
|
// get the error message |
|
PyErr_Print(); |
|
PyErr_Clear(); |
|
PythonInterface::getOutputAndReset(); |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
bool ICallIntFunc(PyObject *dict, char *funcName, int& val) |
|
{ |
|
PyObject *obj; |
|
if (ICallVoidFunc(dict, funcName, obj)) |
|
{ |
|
if (PyInt_Check(obj)) |
|
{ |
|
val = PyInt_AsLong(obj); |
|
Py_DECREF(obj); |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
bool ICallStrFunc(PyObject *dict, char *funcName, char*& val) |
|
{ |
|
PyObject *obj; |
|
if (ICallVoidFunc(dict, funcName, obj)) |
|
{ |
|
if (PyString_Check(obj)) |
|
{ |
|
val = hsStrcpy(PyString_AsString(obj)); |
|
Py_DECREF(obj); |
|
return true; |
|
} |
|
} |
|
|
|
return false; |
|
} |
|
|
|
|
|
#include "../MaxComponent/plPythonFileComponent.h" |
|
#include "hsUtils.h" |
|
|
|
enum ParamTypes |
|
{ |
|
// These numbers used in the python/plasma/glue.py code |
|
kTypeUndefined, // 0 |
|
kTypeBool, // 1 |
|
kTypeInt, // 2 |
|
kTypeFloat, // 3 |
|
kTypeString, // 4 |
|
kTypeSceneObj, // 5 |
|
kTypeSceneObjList, // 6 |
|
kTypeActivatorList, // 7 |
|
kTypeActivator, // 8 |
|
kTypeResponder, // 9 |
|
kTypeResponderList, // 10 |
|
kTypeDynamicText, // 11 |
|
kTypeGUIDialog, // 12 |
|
kTypeExcludeRegion, // 13 (x-rude-oh legion-oh) |
|
kTypeAnimation, // 14 (animation component) |
|
kTypeAvatarBehavior, // 15 (avatar behaviors, such as one-shots or multistage behaviors) |
|
kTypeMaterial, // 16 (material type) |
|
kTypeGUIPopUpMenu, // 17 (GUI pop up menu) |
|
kTypeGUISkin, // 18 (Guess) |
|
kTypeWaterComponent, // 19 |
|
kTypeDropDownList, // 20 |
|
kTypeSwimCurrentInterface, // 21 |
|
kTypeClusterComponent, // 22 |
|
kTypeMaterialAnimation, // 23 |
|
kTypeGrassComponent, // 24 |
|
}; |
|
|
|
bool IGetTupleInt(PyObject *tuple, int pos, int& val) |
|
{ |
|
PyObject *param = PyTuple_GetItem(tuple, pos); |
|
if (param && PyInt_Check(param)) |
|
{ |
|
val = PyInt_AsLong(param); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
bool IGetTupleFloat(PyObject *tuple, int pos, float& val) |
|
{ |
|
PyObject *param = PyTuple_GetItem(tuple, pos); |
|
if (param && PyFloat_Check(param)) |
|
{ |
|
val = (float)PyFloat_AsDouble(param); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
bool IGetTupleString(PyObject *tuple, int pos, char*& val) |
|
{ |
|
PyObject *param = PyTuple_GetItem(tuple, pos); |
|
if (param && PyString_Check(param)) |
|
{ |
|
val = PyString_AsString(param); |
|
return true; |
|
} |
|
|
|
return false; |
|
} |
|
|
|
void IExtractVisInfo(PyObject* tuple, int* id, std::vector<std::string>* vec) |
|
{ |
|
PyObject* vid = PyTuple_GetItem(tuple, 0); |
|
PyObject* vstates = PyTuple_GetItem(tuple, 1); |
|
|
|
if (vid && PyInt_Check(vid)) |
|
{ |
|
*id = PyInt_AsLong(vid); |
|
} |
|
|
|
if (vstates && PyList_Check(vstates)) |
|
{ |
|
PyObject* element; |
|
int lsize = PyList_Size(vstates); |
|
|
|
for (int i = 0; i < lsize; i++) |
|
{ |
|
element = PyList_GetItem(vstates, i); |
|
if (element && PyString_Check(element)) |
|
{ |
|
std::string str = PyString_AsString(element); |
|
vec->push_back(str); |
|
} |
|
} |
|
} |
|
} |
|
|
|
bool plPythonMgr::IQueryPythonFile(char *fileName) |
|
{ |
|
PyObject *module = PyImport_ImportModule(fileName); |
|
if (module) |
|
{ |
|
// attach the glue python code to the end |
|
if ( !PythonInterface::RunString("execfile('.\\python\\plasma\\glue.py')", module) ) |
|
{ |
|
// display any output (NOTE: this would be disabled in production) |
|
// get the messages |
|
PythonInterface::getOutputAndReset(); |
|
return false; // if we can't create the instance then there is nothing to do here |
|
} |
|
// Get the dictionary for this module |
|
PyObject *dict = PyModule_GetDict(module); |
|
// set the name of the file for the glue.py code to find |
|
PyObject* pfilename = PyString_FromString(fileName); |
|
PyDict_SetItemString(dict, "glue_name", pfilename); |
|
|
|
// Get the block ID |
|
int blockID = 0; |
|
if (!ICallIntFunc(dict, kGetBlockID, blockID)) |
|
{ |
|
Py_DECREF(module); |
|
return false; |
|
} |
|
|
|
// Get the class name |
|
char *className = nil; |
|
if (!ICallStrFunc(dict, kGetClassName, className)) |
|
{ |
|
Py_DECREF(module); |
|
return false; |
|
} |
|
|
|
// Get the number of parameters |
|
int numParams = 0; |
|
if (!ICallIntFunc(dict, kGetNumParams, numParams)) |
|
{ |
|
Py_DECREF(module); |
|
return false; |
|
} |
|
|
|
// determine if this is a multimodifier |
|
int isMulti = 0; |
|
ICallIntFunc(dict, kIsMultiModifier, isMulti); |
|
|
|
// Get the version |
|
//====================== |
|
// Get version must be the last call that needs a pythonfile class instance |
|
// ... because it delete the instance afterwards |
|
// NOTE: get attribute params doesn't need the pythonfile class instance |
|
int version = 0; |
|
if (!ICallIntFunc(dict, kGetVersion, version)) |
|
{ |
|
Py_DECREF(module); |
|
return false; |
|
} |
|
|
|
PyObject *getParamFunc = PyDict_GetItemString(dict, kGetParam); |
|
PyObject *getVisInfoFunc = PyDict_GetItemString(dict, kGetVisInfo); |
|
|
|
if (PyCallable_Check(getParamFunc)) |
|
{ |
|
plAutoUIBlock *autoUI = TRACKED_NEW plAutoUIBlock(PythonFile::GetClassDesc(), blockID, className, version); |
|
// test to see if it is a multi-modifier type class |
|
if (isMulti) |
|
autoUI->SetMultiModifierFlag(true); |
|
|
|
for (int i = numParams-1; i >= 0; i--) |
|
{ |
|
PyObject *ret = PyObject_CallFunction(getParamFunc, "l", i); |
|
|
|
PyObject *visinfo = nil; |
|
int ddlParamID = -1; |
|
std::vector<std::string> vec; |
|
|
|
if (PyCallable_Check(getVisInfoFunc)) |
|
{ |
|
visinfo = PyObject_CallFunction(getVisInfoFunc, "l", i); |
|
if (visinfo && PyTuple_Check(visinfo)) |
|
{ |
|
IExtractVisInfo(visinfo, &ddlParamID, &vec); |
|
} |
|
} |
|
|
|
if (ret) |
|
{ |
|
if (PyTuple_Check(ret)) |
|
{ |
|
int paramID = -1; |
|
char *paramName = nil; |
|
int paramType = kTypeUndefined; |
|
|
|
// Get the param ID, name, and type |
|
if (IGetTupleInt(ret, 0, paramID) && |
|
IGetTupleString(ret, 1, paramName) && |
|
IGetTupleInt(ret, 2, paramType)) |
|
{ |
|
// Get the type specific params and add the param to the AutoUI block |
|
switch (paramType) |
|
{ |
|
case kTypeInt: |
|
IAddInt(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeFloat: |
|
IAddFloat(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeString: |
|
IAddString(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeBool: |
|
IAddBool(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeSceneObj: |
|
IAddSceneObj(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeSceneObjList: |
|
IAddSceneObjList(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeActivator: |
|
IAddActivator(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeActivatorList: |
|
IAddActivatorList(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeResponder: |
|
IAddResponder(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeResponderList: |
|
IAddResponderList(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeDynamicText: |
|
IAddDynamicText(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeGUIDialog: |
|
IAddGUIDialog(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeExcludeRegion: |
|
IAddExcludeRegion(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeAnimation: |
|
IAddAnimation(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeAvatarBehavior: |
|
IAddBehavior(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeMaterial: |
|
IAddMaterial(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeGUIPopUpMenu: |
|
IAddGUIPopUpMenu(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
|
|
case kTypeGUISkin: |
|
IAddGUISkin(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
case kTypeWaterComponent: |
|
IAddWaterComponent(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
case kTypeSwimCurrentInterface: |
|
IAddSwimCurrentInterface(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
case kTypeDropDownList: |
|
IAddDropDownList(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
case kTypeClusterComponent: |
|
IAddClusterComponent(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
case kTypeMaterialAnimation: |
|
IAddMaterialAnimation(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
case kTypeGrassComponent: |
|
IAddGrassComponent(autoUI, ret, paramName, paramID, ddlParamID, &vec); |
|
break; |
|
} |
|
} |
|
} |
|
|
|
Py_DECREF(ret); |
|
} |
|
} |
|
|
|
PythonFile::AddAutoUIBlock(autoUI); |
|
} |
|
|
|
delete [] className; |
|
Py_DECREF(module); |
|
} |
|
else |
|
{ |
|
// There was an error when importing the module |
|
// get the error message and put it in the log |
|
PyErr_Print(); |
|
PyErr_Clear(); |
|
PythonInterface::getOutputAndReset(); |
|
} |
|
|
|
|
|
return false; |
|
} |
|
|
|
void plPythonMgr::IAddBool(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
hsBool def = false; |
|
IGetTupleInt(tuple, 3, def); |
|
|
|
autoUI->AddCheckBox(id, nil, paramName, vid, vstates, def); |
|
} |
|
|
|
void plPythonMgr::IAddInt(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
int def=0, min=0, max=100; |
|
|
|
IGetTupleInt(tuple, 3, def); |
|
|
|
PyObject *range = PyTuple_GetItem(tuple, 4); |
|
if (range && PyTuple_Check(range)) |
|
{ |
|
IGetTupleInt(range, 0, min); |
|
IGetTupleInt(range, 1, max); |
|
} |
|
|
|
autoUI->AddIntSpinner(id, nil, paramName, vid, vstates, def, min, max); |
|
} |
|
|
|
void plPythonMgr::IAddFloat(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
float def=0, min=0, max=1; |
|
|
|
IGetTupleFloat(tuple, 3, def); |
|
|
|
PyObject *range = PyTuple_GetItem(tuple, 4); |
|
if (range && PyTuple_Check(range)) |
|
{ |
|
IGetTupleFloat(range, 0, min); |
|
IGetTupleFloat(range, 1, max); |
|
} |
|
|
|
autoUI->AddFloatSpinner(id, nil, paramName, vid, vstates, def, min, max); |
|
} |
|
|
|
void plPythonMgr::IAddString(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
char *def = nil; |
|
IGetTupleString(tuple, 3, def); |
|
|
|
autoUI->AddEditBox(id, nil, paramName, vid, vstates, def); |
|
} |
|
|
|
void plPythonMgr::IAddSceneObj(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickNodeButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddSceneObjList(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickNodeList(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddActivator(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickActivatorButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddActivatorList(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickActivatorList(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddDynamicText(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickDynamicTextButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddGUIDialog(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickGUIDialogButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddExcludeRegion(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickExcludeRegionButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddWaterComponent(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickWaterComponentButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddSwimCurrentInterface(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickSwimCurrentInterfaceButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddClusterComponent(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickClusterComponentButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddAnimation(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickAnimationButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddBehavior(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickBehaviorButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddMaterial(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickMaterialButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddGUIPopUpMenu(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickGUIPopUpMenuButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddGUISkin(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickGUISkinButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
#include "../MaxComponent/plResponderComponent.h" |
|
|
|
void plPythonMgr::IAddResponder(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
std::vector<Class_ID> cids; |
|
cids.push_back(RESPONDER_CID); |
|
|
|
autoUI->AddPickComponentButton(id, nil, paramName, vid, vstates, &cids, true); |
|
} |
|
|
|
void plPythonMgr::IAddResponderList(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
std::vector<Class_ID> cids; |
|
cids.push_back(RESPONDER_CID); |
|
|
|
autoUI->AddPickComponentList(id, nil, paramName, vid, vstates, &cids); |
|
} |
|
|
|
void plPythonMgr::IAddMaterialAnimation(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickMaterialAnimationButton(id, nil, paramName, vid, vstates); |
|
} |
|
|
|
void plPythonMgr::IAddGrassComponent(plAutoUIBlock *autoUI, PyObject *objTuple, std::string paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
autoUI->AddPickGrassComponentButton(id, nil, paramName.c_str(), vid, vstates); |
|
} |
|
|
|
#include <direct.h> |
|
|
|
void plPythonMgr::LoadPythonFiles() |
|
{ |
|
const char *clientPath = plMaxConfig::GetClientPath(false, true); |
|
if (clientPath) |
|
{ |
|
char oldCwd[MAX_PATH]; |
|
_getcwd(oldCwd, sizeof(oldCwd)); |
|
_chdir(clientPath); |
|
|
|
// Get the path to the Python subdirectory of the client |
|
char pythonPath[MAX_PATH]; |
|
strcpy(pythonPath, clientPath); |
|
strcat(pythonPath, "Python"); |
|
|
|
PythonInterface::initPython(); |
|
|
|
// Iterate through all the Python files in the folder |
|
hsFolderIterator folder(pythonPath); |
|
while (folder.NextFileSuffix(".py")) |
|
{ |
|
// Get the filename without the ".py" (module name) |
|
const char *fullFileName = folder.GetFileName(); |
|
char fileName[_MAX_FNAME]; |
|
_splitpath(fullFileName, NULL, NULL, fileName, NULL); |
|
|
|
IQueryPythonFile(fileName); |
|
} |
|
|
|
PythonInterface::finiPython(); |
|
|
|
_chdir(oldCwd); |
|
} |
|
} |
|
|
|
void plPythonMgr::IAddDropDownList(plAutoUIBlock *autoUI, PyObject *tuple, char *paramName, int id, int vid, std::vector<std::string>* vstates) |
|
{ |
|
PyObject *options = PyTuple_GetItem(tuple, 3); |
|
if (options && PyTuple_Check(options)) |
|
{ |
|
int size = PyTuple_Size(options); |
|
char* opt = nil; |
|
std::vector<std::string> optionsVec; |
|
|
|
for (int i = 0; i < size; i++) |
|
{ |
|
IGetTupleString(options, i, opt); |
|
std::string str = opt; |
|
optionsVec.push_back(str); |
|
} |
|
|
|
autoUI->AddDropDownList(id, nil, paramName, vid, vstates, &optionsVec); |
|
} |
|
}
|
|
|