OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
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.
10 Commits
81 Branches
23 Tags
172 MiB
 
 
 
 
 
Tree: ecb7d8b566
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ecb7d8b566'
${ noResults }
CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfPython/pyVaultGlue.cpp

594 lines
24 KiB
Raw Blame History

/*==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/>.
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 "pyVault.h"
#include "pyEnum.h"
#include "pyAgeInfoStruct.h"
#include "pyVaultNode.h"
#include "pySDL.h"
#include "pyAgeLinkStruct.h"
#include "../plVault/plVault.h"
#include "../plMessage/plVaultNotifyMsg.h"
#include <python.h>
#ifndef BUILDING_PYPLASMA
// glue functions
PYTHON_CLASS_DEFINITION(ptVault, pyVault);
PYTHON_DEFAULT_NEW_DEFINITION(ptVault, pyVault)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptVault)
PYTHON_INIT_DEFINITION(ptVault, args, keywords)
{
PYTHON_RETURN_INIT_OK;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getPlayerInfo)
{
return self->fThis->GetPlayerInfo();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getKIUsage)
{
return self->fThis->GetKIUsage();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getInbox)
{
return self->fThis->GetInbox();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAvatarOutfitFolder)
{
return self->fThis->GetAvatarOutfitFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAvatarClosetFolder)
{
return self->fThis->GetAvatarClosetFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getChronicleFolder)
{
return self->fThis->GetChronicleFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAgeJournalsFolder)
{
return self->fThis->GetAgeJournalsFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getIgnoreListFolder)
{
return self->fThis->GetIgnoreListFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getBuddyListFolder)
{
return self->fThis->GetBuddyListFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getPeopleIKnowAboutFolder)
{
return self->fThis->GetPeopleIKnowAboutFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAgesICanVisitFolder)
{
return self->fThis->GetAgesICanVisitFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getAgesIOwnFolder)
{
return self->fThis->GetAgesIOwnFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getInviteFolder)
{
return self->fThis->GetInviteFolder();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getLinkToMyNeighborhood)
{
return self->fThis->GetLinkToMyNeighborhood();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getLinkToCity)
{
return self->fThis->GetLinkToCity();
}
PYTHON_METHOD_DEFINITION(ptVault, getOwnedAgeLink, args)
{
PyObject* ageInfoObj = NULL;
if (!PyArg_ParseTuple(args, "O", &ageInfoObj))
{
PyErr_SetString(PyExc_TypeError, "getOwnedAgeLink expects a ptAgeInfoStruct");
PYTHON_RETURN_ERROR;
}
if (!pyAgeInfoStruct::Check(ageInfoObj))
{
PyErr_SetString(PyExc_TypeError, "getOwnedAgeLink expects a ptAgeInfoStruct");
PYTHON_RETURN_ERROR;
}
pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
return self->fThis->GetOwnedAgeLink(*ageInfo);
}
PYTHON_METHOD_DEFINITION(ptVault, getVisitAgeLink, args)
{
PyObject* ageInfoObj = NULL;
if (!PyArg_ParseTuple(args, "O", &ageInfoObj))
{
PyErr_SetString(PyExc_TypeError, "getVisitAgeLink expects a ptAgeInfoStruct");
PYTHON_RETURN_ERROR;
}
if (!pyAgeInfoStruct::Check(ageInfoObj))
{
PyErr_SetString(PyExc_TypeError, "getVisitAgeLink expects a ptAgeInfoStruct");
PYTHON_RETURN_ERROR;
}
pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
return self->fThis->GetVisitAgeLink(*ageInfo);
}
PYTHON_METHOD_DEFINITION(ptVault, findChronicleEntry, args)
{
char* entryName;
if (!PyArg_ParseTuple(args, "s", &entryName))
{
PyErr_SetString(PyExc_TypeError, "findChronicleEntry expects a string");
PYTHON_RETURN_ERROR;
}
return self->fThis->FindChronicleEntry(entryName);
}
PYTHON_METHOD_DEFINITION(ptVault, addChronicleEntry, args)
{
char* entryName;
unsigned long entryType;
char* entryValue;
if (!PyArg_ParseTuple(args, "sls", &entryName, &entryType, &entryValue))
{
PyErr_SetString(PyExc_TypeError, "addChronicleEntry expects a string, an unsigned long, and a string");
PYTHON_RETURN_ERROR;
}
self->fThis->AddChronicleEntry(entryName, entryType, entryValue);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getGlobalInbox)
{
return self->fThis->GetGlobalInbox();
}
#ifdef GlobalInboxTestCode
PYTHON_BASIC_METHOD_DEFINITION(ptVault, createGlobalInbox, CreateGlobalInbox)
#endif
PYTHON_METHOD_DEFINITION(ptVault, findNode, args)
{
PyObject* templateNodeObj = NULL;
if (!PyArg_ParseTuple(args, "O", &templateNodeObj))
{
PyErr_SetString(PyExc_TypeError, "findNode expects a ptVaultNode");
PYTHON_RETURN_ERROR;
}
if (!pyVaultNode::Check(templateNodeObj))
{
PyErr_SetString(PyExc_TypeError, "findNode expects a ptVaultNode");
PYTHON_RETURN_ERROR;
}
pyVaultNode* templateNode = pyVaultNode::ConvertFrom(templateNodeObj);
return self->fThis->FindNode(templateNode);
}
PYTHON_METHOD_DEFINITION(ptVault, sendToDevice, args)
{
PyObject* nodeObj = NULL;
char* deviceName;
if (!PyArg_ParseTuple(args, "Os", &nodeObj, &deviceName))
{
PyErr_SetString(PyExc_TypeError, "sendToDevice expects a ptVaultNode and a string");
PYTHON_RETURN_ERROR;
}
if (!pyVaultNode::Check(nodeObj))
{
PyErr_SetString(PyExc_TypeError, "sendToDevice expects a ptVaultNode and a string");
PYTHON_RETURN_ERROR;
}
pyVaultNode* node = pyVaultNode::ConvertFrom(nodeObj);
self->fThis->SendToDevice(*node, deviceName);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, getPsnlAgeSDL)
{
return self->fThis->GetPsnlAgeSDL();
}
PYTHON_METHOD_DEFINITION(ptVault, updatePsnlAgeSDL, args)
{
PyObject* pyrecObj = NULL;
if (!PyArg_ParseTuple(args, "O", &pyrecObj))
{
PyErr_SetString(PyExc_TypeError, "updatePsnlAgeSDL expects a ptSDLStateDataRecord");
PYTHON_RETURN_ERROR;
}
if (!pySDLStateDataRecord::Check(pyrecObj))
{
PyErr_SetString(PyExc_TypeError, "updatePsnlAgeSDL expects a ptSDLStateDataRecord");
PYTHON_RETURN_ERROR;
}
pySDLStateDataRecord* pyrec = pySDLStateDataRecord::ConvertFrom(pyrecObj);
self->fThis->UpdatePsnlAgeSDL(*pyrec);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, inMyPersonalAge)
{
PYTHON_RETURN_BOOL(self->fThis->InMyPersonalAge());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, inMyNeighborhoodAge)
{
PYTHON_RETURN_BOOL(self->fThis->InMyNeighborhoodAge());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, amOwnerOfCurrentAge)
{
PYTHON_RETURN_BOOL(self->fThis->AmOwnerOfCurrentAge());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVault, amCzarOfCurrentAge)
{
PYTHON_RETURN_BOOL(self->fThis->AmCzarOfCurrentAge());
}
PYTHON_METHOD_DEFINITION(ptVault, amAgeOwner, args)
{
PyObject* ageInfoObj = NULL;
if (!PyArg_ParseTuple(args, "O", &ageInfoObj))
{
PyErr_SetString(PyExc_TypeError, "amAgeOwner expects a ptAgeInfoStruct");
PYTHON_RETURN_ERROR;
}
if (!pyAgeInfoStruct::Check(ageInfoObj))
{
PyErr_SetString(PyExc_TypeError, "amAgeOwner expects a ptAgeInfoStruct");
PYTHON_RETURN_ERROR;
}
pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
PYTHON_RETURN_BOOL(self->fThis->AmAgeOwner(ageInfo));
}
PYTHON_METHOD_DEFINITION(ptVault, amAgeCzar, args)
{
PyObject* ageInfoObj = NULL;
if (!PyArg_ParseTuple(args, "O", &ageInfoObj))
{
PyErr_SetString(PyExc_TypeError, "amAgeCzar expects a ptAgeInfoStruct");
PYTHON_RETURN_ERROR;
}
if (!pyAgeInfoStruct::Check(ageInfoObj))
{
PyErr_SetString(PyExc_TypeError, "amAgeCzar expects a ptAgeInfoStruct");
PYTHON_RETURN_ERROR;
}
pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
PYTHON_RETURN_BOOL(self->fThis->AmAgeCzar(ageInfo));
}
PYTHON_METHOD_DEFINITION(ptVault, registerMTStation, args)
{
char* stationName;
char* mtSpawnPoint;
if (!PyArg_ParseTuple(args, "ss", &stationName, &mtSpawnPoint))
{
PyErr_SetString(PyExc_TypeError, "registerMTStation expects two strings");
PYTHON_RETURN_ERROR;
}
self->fThis->RegisterMTStation(stationName, mtSpawnPoint);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVault, registerOwnedAge, args)
{
PyObject* ageLinkObj = NULL;
if (!PyArg_ParseTuple(args, "O", &ageLinkObj))
{
PyErr_SetString(PyExc_TypeError, "registerOwnedAge expects a ptAgeLinkStruct");
PYTHON_RETURN_ERROR;
}
if (!pyAgeLinkStruct::Check(ageLinkObj))
{
PyErr_SetString(PyExc_TypeError, "registerOwnedAge expects a ptAgeLinkStruct");
PYTHON_RETURN_ERROR;
}
pyAgeLinkStruct* ageLink = pyAgeLinkStruct::ConvertFrom(ageLinkObj);
self->fThis->RegisterOwnedAge(*ageLink);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVault, unRegisterOwnedAge, args)
{
char* ageFilename;
if (!PyArg_ParseTuple(args, "s", &ageFilename))
{
PyErr_SetString(PyExc_TypeError, "unRegisterOwnedAge expects a string");
PYTHON_RETURN_ERROR;
}
self->fThis->UnRegisterOwnedAge(ageFilename);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVault, registerVisitAge, args)
{
PyObject* ageLinkObj = NULL;
if (!PyArg_ParseTuple(args, "O", &ageLinkObj))
{
PyErr_SetString(PyExc_TypeError, "registerVisitAge expects a ptAgeLinkStruct");
PYTHON_RETURN_ERROR;
}
if (!pyAgeLinkStruct::Check(ageLinkObj))
{
PyErr_SetString(PyExc_TypeError, "registerVisitAge expects a ptAgeLinkStruct");
PYTHON_RETURN_ERROR;
}
pyAgeLinkStruct* ageLink = pyAgeLinkStruct::ConvertFrom(ageLinkObj);
self->fThis->RegisterVisitAge(*ageLink);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVault, unRegisterVisitAge, args)
{
char* guid;
if (!PyArg_ParseTuple(args, "s", &guid))
{
PyErr_SetString(PyExc_TypeError, "unRegisterVisitAge expects a string");
PYTHON_RETURN_ERROR;
}
self->fThis->UnRegisterVisitAge(guid);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVault, invitePlayerToAge, args)
{
PyObject* ageLinkObj = NULL;
unsigned long playerID;
if (!PyArg_ParseTuple(args, "Ol", &ageLinkObj, &playerID))
{
PyErr_SetString(PyExc_TypeError, "invitePlayerToAge expects a ptAgeLinkStruct and an unsigned long");
PYTHON_RETURN_ERROR;
}
if (!pyAgeLinkStruct::Check(ageLinkObj))
{
PyErr_SetString(PyExc_TypeError, "invitePlayerToAge expects a ptAgeLinkStruct and an unsigned long");
PYTHON_RETURN_ERROR;
}
pyAgeLinkStruct* ageLink = pyAgeLinkStruct::ConvertFrom(ageLinkObj);
self->fThis->InvitePlayerToAge(*ageLink, playerID);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVault, unInvitePlayerToAge, args)
{
char* guid;
unsigned long playerID;
if (!PyArg_ParseTuple(args, "sl", &guid, &playerID))
{
PyErr_SetString(PyExc_TypeError, "unInvitePlayerToAge expects a string and an unsigned long");
PYTHON_RETURN_ERROR;
}
self->fThis->UnInvitePlayerToAge(guid, playerID);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVault, offerLinkToPlayer, args)
{
PyObject* ageLinkObj = NULL;
unsigned long playerID;
if (!PyArg_ParseTuple(args, "Ol", &ageLinkObj, &playerID))
{
PyErr_SetString(PyExc_TypeError, "offerLinkToPlayer expects a ptAgeLinkStruct and an unsigned long");
PYTHON_RETURN_ERROR;
}
if (!pyAgeLinkStruct::Check(ageLinkObj))
{
PyErr_SetString(PyExc_TypeError, "offerLinkToPlayer expects a ptAgeLinkStruct and an unsigned long");
PYTHON_RETURN_ERROR;
}
pyAgeLinkStruct* ageLink = pyAgeLinkStruct::ConvertFrom(ageLinkObj);
self->fThis->OfferLinkToPlayer(*ageLink, playerID);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_METHOD_DEFINITION(ptVault, createNeighborhood, CreateNeighborhood)
PYTHON_METHOD_DEFINITION(ptVault, setAgePublic, args)
{
PyObject* ageInfoObj = NULL;
char makePublic;
if (!PyArg_ParseTuple(args, "Ob", &ageInfoObj, &makePublic))
{
PyErr_SetString(PyExc_TypeError, "setAgePublic expects a ptAgeInfoStruct and a boolean");
PYTHON_RETURN_ERROR;
}
if (!pyAgeInfoStruct::Check(ageInfoObj))
{
PyErr_SetString(PyExc_TypeError, "setAgePublic expects a ptAgeInfoStruct and a boolean");
PYTHON_RETURN_ERROR;
}
pyAgeInfoStruct* ageInfo = pyAgeInfoStruct::ConvertFrom(ageInfoObj);
PYTHON_RETURN_BOOL(self->fThis->SetAgePublic(ageInfo, makePublic != 0));
}
PYTHON_START_METHODS_TABLE(ptVault)
PYTHON_METHOD_NOARGS(ptVault, getPlayerInfo, "Returns a ptVaultNode of type kNodeTypePlayerInfo of the current player"),
PYTHON_METHOD_NOARGS(ptVault, getKIUsage, "Returns a tuple with usage statistics of the KI (# of pics, # of text notes, # of marker games)"),
PYTHON_METHOD_NOARGS(ptVault, getInbox, "Returns a ptVaultFolderNode of the current player's inbox folder."),
PYTHON_METHOD_NOARGS(ptVault, getAvatarOutfitFolder, "Do not use.\n"
"Returns a ptVaultFolderNode of the avatars outfit."),
PYTHON_METHOD_NOARGS(ptVault, getAvatarClosetFolder, "Do not use.\n"
"Returns a ptVaultFolderNode of the avatars outfit in their closet."),
PYTHON_METHOD_NOARGS(ptVault, getChronicleFolder, "Returns a ptVaultFolderNode of the current player's chronicle folder."),
PYTHON_METHOD_NOARGS(ptVault, getAgeJournalsFolder, "Returns a ptVaultFolderNode of the current player's age journals folder."),
PYTHON_METHOD_NOARGS(ptVault, getIgnoreListFolder, "Returns a ptVaultPlayerInfoListNode of the current player's ignore list folder."),
PYTHON_METHOD_NOARGS(ptVault, getBuddyListFolder, "Returns a ptVaultPlayerInfoListNode of the current player's buddy list folder."),
PYTHON_METHOD_NOARGS(ptVault, getPeopleIKnowAboutFolder, "Returns a ptVaultPlayerInfoListNode of the current player's people I know about (Recent) list folder."),
PYTHON_METHOD_NOARGS(ptVault, getAgesICanVisitFolder, "Returns a ptVaultFolderNode of ages I can visit"),
PYTHON_METHOD_NOARGS(ptVault, getAgesIOwnFolder, "Returns a ptVaultFolderNode of ages that I own"),
PYTHON_METHOD_NOARGS(ptVault, getInviteFolder, "Returns a ptVaultFolderNode of invites"),
PYTHON_METHOD_NOARGS(ptVault, getLinkToMyNeighborhood, "Returns a ptVaultAgeLinkNode that will go to my neighborhood"),
PYTHON_METHOD_NOARGS(ptVault, getLinkToCity, "Returns a ptVaultAgeLinkNode that will go to the city"),
PYTHON_METHOD(ptVault, getOwnedAgeLink, "Params: ageInfo\nReturns a ptVaultAgeLinkNode to my owned age(ageInfo)"),
PYTHON_METHOD(ptVault, getVisitAgeLink, "Params: ageInfo\nReturns a ptVaultAgeLinkNode for a visitor to age(ageInfo)"),
PYTHON_METHOD(ptVault, findChronicleEntry, "Params: entryName\nReturns a ptVaultNode of type kNodeTypeChronicle of the current player's chronicle entry by entryName."),
PYTHON_METHOD(ptVault, addChronicleEntry, "Params: entryName,type,string\nAdds an entry to the player's chronicle with a value of 'string'."),
PYTHON_METHOD_NOARGS(ptVault, getGlobalInbox, "Returns a ptVaultFolderNode of the global inbox folder."),
#ifdef GlobalInboxTestCode
PYTHON_BASIC_METHOD(ptVault, createGlobalInbox, "Creates the global inbox folder."),
#endif
PYTHON_METHOD(ptVault, findNode, "Params: templateNode\nFind the node matching the template"),
PYTHON_METHOD(ptVault, sendToDevice, "Params: node,deviceName\nSends a ptVaultNode object to an Age's device by deviceName."),
PYTHON_METHOD_NOARGS(ptVault, getPsnlAgeSDL, "Returns the personal age SDL"),
PYTHON_METHOD(ptVault, updatePsnlAgeSDL, "Params: pyrec\nUpdates the personal age SDL to the specified data"),
PYTHON_METHOD_NOARGS(ptVault, inMyPersonalAge, "Are we in the player's personal age?"),
PYTHON_METHOD_NOARGS(ptVault, inMyNeighborhoodAge, "Are we in the player's neighborhood age?"),
PYTHON_METHOD_NOARGS(ptVault, amOwnerOfCurrentAge, "Are we the owner of the current age?"),
PYTHON_METHOD_NOARGS(ptVault, amCzarOfCurrentAge, "Are we the czar (WTH is this?) of the current age?"),
PYTHON_METHOD(ptVault, amAgeOwner, "Params: ageInfo\nAre we the owner of the specified age?"),
PYTHON_METHOD(ptVault, amAgeCzar, "Params: ageInfo\nAre we the czar (WTH is this?) of the specified age?"),
PYTHON_METHOD(ptVault, registerMTStation, "Params: stationName,mtSpawnPoint\nRegisters this player at the specified mass-transit point"),
PYTHON_METHOD(ptVault, registerOwnedAge, "Params: link\nRegisters the specified age as owned by the player"),
PYTHON_METHOD(ptVault, unRegisterOwnedAge, "Params: ageFilename\nUnregisters the specified age so it's no longer owned by this player"),
PYTHON_METHOD(ptVault, registerVisitAge, "Params: link\nRegister this age as visitable by this player"),
PYTHON_METHOD(ptVault, unRegisterVisitAge, "Params: guid\nUnregisters the specified age so it can no longer be visited by this player"),
PYTHON_METHOD(ptVault, invitePlayerToAge, "Params: link,playerID\nSends an invitation to visit the age to the specified player"),
PYTHON_METHOD(ptVault, unInvitePlayerToAge, "Params: guid,playerID\nRevokes the invitation to visit the age"),
PYTHON_METHOD(ptVault, offerLinkToPlayer, "Params: link,playerID\nOffer a one-time link to the specified player"),
PYTHON_BASIC_METHOD(ptVault, createNeighborhood, "Creates a new neighborhood"),
PYTHON_METHOD(ptVault, setAgePublic, "Params: ageInfo,makePublic\nMakes the specified age public or private"),
PYTHON_END_METHODS_TABLE;
// Type structure definition
PLASMA_DEFAULT_TYPE(ptVault, "Accessor class to the player's vault");
// required functions for PyObject interoperability
PYTHON_CLASS_NEW_IMPL(ptVault, pyVault)
PYTHON_CLASS_CHECK_IMPL(ptVault, pyVault)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptVault, pyVault)
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyVault::AddPlasmaClasses(PyObject *m)
{
PYTHON_CLASS_IMPORT_START(m);
PYTHON_CLASS_IMPORT(m, ptVault);
PYTHON_CLASS_IMPORT_END(m);
}
#endif // BUILDING_PYPLASMA
void pyVault::AddPlasmaConstantsClasses(PyObject *m)
{
PYTHON_ENUM_START(PtVaultNodeTypes);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kInvalidNode, plVault::kNodeType_Invalid);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kVNodeMgrPlayerNode, plVault::kNodeType_VNodeMgrPlayer);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kVNodeMgrAgeNode, plVault::kNodeType_VNodeMgrAge);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kFolderNode, plVault::kNodeType_Folder);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kPlayerInfoNode, plVault::kNodeType_PlayerInfo);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kImageNode, plVault::kNodeType_Image);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kTextNoteNode, plVault::kNodeType_TextNote);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kSDLNode, plVault::kNodeType_SDL);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kAgeLinkNode, plVault::kNodeType_AgeLink);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kChronicleNode, plVault::kNodeType_Chronicle);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kPlayerInfoListNode, plVault::kNodeType_PlayerInfoList);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kAgeInfoNode, plVault::kNodeType_AgeInfo);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kAgeInfoListNode, plVault::kNodeType_AgeInfoList);
PYTHON_ENUM_ELEMENT(PtVaultNodeTypes, kMarkerGameNode, plVault::kNodeType_MarkerGame);
PYTHON_ENUM_END(m, PtVaultNodeTypes);
PYTHON_ENUM_START(PtVaultStandardNodes);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kUserDefinedNode, plVault::kUserDefinedNode);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kInboxFolder, plVault::kInboxFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kBuddyListFolder, plVault::kBuddyListFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kIgnoreListFolder, plVault::kIgnoreListFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kPeopleIKnowAboutFolder, plVault::kPeopleIKnowAboutFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kChronicleFolder, plVault::kChronicleFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAvatarOutfitFolder, plVault::kAvatarOutfitFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeTypeJournalFolder, plVault::kAgeTypeJournalFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kSubAgesFolder, plVault::kSubAgesFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kHoodMembersFolder, plVault::kHoodMembersFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAllPlayersFolder, plVault::kAllPlayersFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAllAgeGlobalSDLNodesFolder, plVault::kAllAgeGlobalSDLNodesFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeMembersFolder, plVault::kAgeMembersFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeJournalsFolder, plVault::kAgeJournalsFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeInstanceSDLNode, plVault::kAgeInstanceSDLNode);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kCanVisitFolder, plVault::kCanVisitFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgeOwnersFolder, plVault::kAgeOwnersFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kPlayerInfoNode, plVault::kPlayerInfoNode);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kPublicAgesFolder, plVault::kPublicAgesFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgesIOwnFolder, plVault::kAgesIOwnFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAgesICanVisitFolder, plVault::kAgesICanVisitFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kAvatarClosetFolder, plVault::kAvatarClosetFolder);
PYTHON_ENUM_ELEMENT(PtVaultStandardNodes, kGlobalInboxFolder, plVault::kGlobalInboxFolder);
PYTHON_ENUM_END(m, PtVaultStandardNodes);
PYTHON_ENUM_START(PtVaultTextNoteTypes);
PYTHON_ENUM_ELEMENT(PtVaultTextNoteTypes, kGeneric, plVault::kNoteType_Generic);
PYTHON_ENUM_ELEMENT(PtVaultTextNoteTypes, kCCRPetition, plVault::kNoteType_CCRPetition);
PYTHON_ENUM_END(m, PtVaultTextNoteTypes);
PYTHON_ENUM_START(PtVaultTextNoteSubTypes);
PYTHON_ENUM_ELEMENT(PtVaultTextNoteSubTypes, kGeneric, plVault::kNoteSubType_Generic);
PYTHON_ENUM_END(m, PtVaultTextNoteSubTypes);
PYTHON_ENUM_START(PtVaultCallbackTypes);
PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultConnected, pyVault::kVaultConnected);
PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeSaved, pyVault::kVaultNodeSaved);
PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeRefAdded, pyVault::kVaultNodeRefAdded);
PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultRemovingNodeRef, pyVault::kVaultRemovingNodeRef);
PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeRefRemoved, pyVault::kVaultNodeRefRemoved);
PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeInitialized, pyVault::kVaultNodeInitialized);
PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultOperationFailed, pyVault::kVaultOperationFailed);
PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultNodeAdded, pyVault::kVaultNodeAdded);
PYTHON_ENUM_ELEMENT(PtVaultCallbackTypes, kVaultDisconnected, pyVault::kVaultDisconnected);
PYTHON_ENUM_END(m, PtVaultCallbackTypes);
PYTHON_ENUM_START(PtVaultNotifyTypes);
PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kRegisteredOwnedAge, plVaultNotifyMsg::kRegisteredOwnedAge);
PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kRegisteredVisitAge, plVaultNotifyMsg::kRegisteredVisitAge);
PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kUnRegisteredOwnedAge, plVaultNotifyMsg::kUnRegisteredOwnedAge);
PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kUnRegisteredVisitAge, plVaultNotifyMsg::kUnRegisteredVisitAge);
PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kPublicAgeCreated, plVaultNotifyMsg::kPublicAgeCreated);
PYTHON_ENUM_ELEMENT(PtVaultNotifyTypes, kPublicAgeRemoved, plVaultNotifyMsg::kPublicAgeRemoved);
PYTHON_ENUM_END(m, PtVaultNotifyTypes);
}