void init()
{
taskStateData[Not_Scheduled].set( "Not Scheduled", 1, 0, 0 );
taskStateData[Tentatively_Scheduled].set( "Tentatively Scheduled", 1, 0, 0 );
taskStateData[Aquiring].set( "Aquiring", 0, 1, 0 );
taskStateData[Preparing].set( "Preparing", 0, 1, 0 );
taskStateData[Executing].set( "Executing", 0, 1, 0 );
taskStateData[Warping].set( "Warping", 0, 1, 0 );
taskStateData[Halted].set( "Halted", 0, 1, 0 );
taskStateData[Completed].set( "Completed", 0, 0, 1 );
taskStateData[None].set( "None", 0, 0, 0 );
taskStateSet.insert( Not_Scheduled );
taskStateSet.insert( Tentatively_Scheduled );
taskStateSet.insert( Aquiring );
taskStateSet.insert( Preparing );
taskStateSet.insert( Executing );
taskStateSet.insert( Warping );
taskStateSet.insert( Halted );
taskStateSet.insert( Completed );
taskStateSet.insert( None );
for( TaskState i : taskStateSet )
{
std::string name = i.getName();
fixName( name );
taskStateMap.insert( std::make_pair( name, i ) );
}
initializingTaskState = false;
}
TaskState TaskStates::getTaskState( std::string name )
{
fixName( name );
std::map< std::string, TaskState >::iterator i = taskStateMap.find( name );
if ( i == taskStateMap.end() )
return TaskStates::None;
return ( *i ).second;
}
//////////////////////////////////////////////////////////////////////////////
// Mark an equal predicate between two tables.
void MVJoinGraph::markPredicateBetween(const QualifiedName& leftTable,
const QualifiedName& rightTable)
{
NAString leftTableName(fixName(leftTable));
NAString rightTableName(fixName(rightTable));
// Find the index of the left table.
MVJoinTable *leftTableObj = tableHash_.getFirstValue(&leftTableName);
Lng32 leftIndex = leftTableObj->getTableIndex();
// Find the index of the right table.
MVJoinTable *rightTableObj = tableHash_.getFirstValue(&rightTableName);
Lng32 rightIndex = rightTableObj->getTableIndex();
// Mark the predicate on both tables.
leftTableObj->markPredicateTo(rightIndex);
rightTableObj->markPredicateTo(leftIndex);
}
void AddFunction::on_AddButton_clicked()
{
AddFunction w(this);
w.argumentMode();
w.project = project;
if(w.exec()==QDialog::Accepted)
{
QStringList L;
for(int i=0;i<ui->ArgumentList->topLevelItemCount();i++)
{
L << ui->ArgumentList->topLevelItem(i)->text(0);
}
QString name = fixName(L,w.name);
QTreeWidgetItem* l = new QTreeWidgetItem();
l->setText(0,name);
l->setText(1,w.type);
ui->ArgumentList->addTopLevelItem(l);
}
}
/** Handles opcode-in-code */
int printCall (char* s, FILE* code)
{
char tmp[MAX_LINE];
char* p = tmp;
strcpy(tmp, s);
while (isspace(*p) && (*p))
p++;
if (*p != '%')
return 0;
*p = 0;
fprintf(code, "%s", tmp);
p++;
fixName(&s[p-tmp], tmp);
fprintf(code, "%s(ctx);\n", tmp);
return 1;
}
int InstallBranch::setInfo(DesuraId id, bool selectBranch)
{
m_bSelectBranch = selectBranch;
UserCore::Item::ItemInfoI* pItemInfo = GetUserCore()->getItemManager()->findItemInfo(id);
if (!pItemInfo)
return 1;
m_bIsMod = id.getType() == DesuraId::TYPE_MOD;
m_bIsExpansion = m_bIsMod == false && pItemInfo->getParentId().getType() == DesuraId::TYPE_GAME;
m_Item = id;
gcWString parName;
gcWString itemName = pItemInfo->getName();
DesuraId par = pItemInfo->getParentId();
UserCore::Item::ItemInfoI *parInfo = NULL;
if (par.isOk())
{
parInfo = GetUserCore()->getItemManager()->findItemInfo(par);
if (parInfo)
parName = gcWString(parInfo->getName());
}
fixName(parName);
fixName(itemName);
if (selectBranch == false && m_bIsMod)
{
m_labInfo->SetLabel(gcWString(Managers::GetString(L"#IF_NOTFOUND"), itemName, parName));
m_labInfo->Wrap( 350 );
}
else if (selectBranch == false && m_bIsExpansion)
{
m_labInfo->SetLabel(gcWString(Managers::GetString(L"#IF_NOTFOUND_GAME"), itemName, parName));
m_labInfo->Wrap( 350 );
}
else
{
m_labInfo->SetLabel(gcWString(Managers::GetString(L"#IF_BRANCHINFO"), itemName));
m_labInfo->Wrap( 350 );
}
uint32 count = 0;
int32 full = -1;
uint32 fullReadyCount = 0;
m_bBuy = true;
UserCore::Item::ItemInfoI *i = pItemInfo;
bool isCheckingParent = (m_bIsMod || m_bIsExpansion) && !selectBranch;
if (isCheckingParent)
{
if (!parInfo)
{
gcMessageBox(GetParent(), Managers::GetString(L"#IF_IIPARENT"), Managers::GetString(L"#IF_IIERRTITLE"));
return 1;
}
i = parInfo;
}
std::vector<UserCore::Item::BranchInfoI*> bList;
for (uint32 x=0; x<i->getBranchCount(); x++)
{
UserCore::Item::BranchInfoI* bi = i->getBranch(x);
if (!bi)
continue;
uint32 flags = bi->getFlags();
bool noRelease = HasAllFlags(flags, UserCore::Item::BranchInfoI::BF_NORELEASES);
bool isPreorder = bi->isPreOrder();
bool isDemo = HasAnyFlags(flags, UserCore::Item::BranchInfoI::BF_DEMO);
bool onAccount = HasAllFlags(flags, UserCore::Item::BranchInfoI::BF_ONACCOUNT);
bool locked = HasAnyFlags(flags, UserCore::Item::BranchInfoI::BF_MEMBERLOCK|UserCore::Item::BranchInfoI::BF_REGIONLOCK);
bool test = HasAnyFlags(flags, UserCore::Item::BranchInfoI::BF_TEST);
bool free = HasAnyFlags(flags, UserCore::Item::BranchInfoI::BF_FREE);
if (noRelease && !isPreorder)
continue;
if (!onAccount && locked)
continue;
if (!selectBranch && (isDemo || test))
continue;
if ((free || onAccount) && isPreorder && !selectBranch)
continue;
bool globalFound = false;
for (size_t x=0; x<bList.size(); x++)
{
if (bList[x]->getGlobalId() == bi->getGlobalId())
{
globalFound = true;
break;
}
}
if (globalFound)
continue;
if (isDemo || test)
{
}
else if (full == -1 || ((!m_bBuy || onAccount) && !free))
{
if (full == -1 || m_bBuy)
{
//if this is the first full game or this is the first full game that you dont have to buy
m_bBuy = (!onAccount && !free);
full = count;
}
if (onAccount || free)
fullReadyCount++;
}
bList.push_back(bi);
count++;
}
for (size_t x=0; x<bList.size(); x++)
{
UserCore::Item::BranchInfoI* bi = bList[x];
gcString name = bi->getName();
gcWString title;
uint32 flags = bi->getFlags();
bool noRelease = HasAllFlags(flags, UserCore::Item::BranchInfoI::BF_NORELEASES);
bool isPreorder = bi->isPreOrder();
bool onAccount = HasAllFlags(flags, UserCore::Item::BranchInfoI::BF_ONACCOUNT);
bool free = HasAnyFlags(flags, UserCore::Item::BranchInfoI::BF_FREE);
if (!free)
title = gcString("{0} - {1}", name, Managers::GetString("#IF_BROUGHT"));
else
title = gcString("{0} - {1}", name, Managers::GetString("#IF_FREE"));
if (!free && !onAccount)
{
gcWString cost(bi->getCost());
if (cost == "")
cost = gcString(Managers::GetString("#TBA"));
title = gcString("{0} - {1}", name, cost.c_str());
}
else if (isPreorder)
{
if (noRelease)
title = gcString("{0} - {1}", name, Managers::GetString("#IF_PREORDERED_NORELEASE"));
else
title = gcString("{0} - {1}", name, Managers::GetString("#IF_PREORDERED"));
}
m_cbBranchList->Append(title, new BranchData(bi->getBranchId(), bi->getGlobalId()));
}
count = bList.size();
if (full == -1)
full = 0;
#ifdef WIN32
if (HasAnyFlags(i->getStatus(), UserCore::Item::ItemInfoI::STATUS_ONCOMPUTER))
m_cbBranchList->Append(Managers::GetString("#IF_ONCOMPUTER"), new BranchData(MCFBranch::BranchFromInt(-1), MCFBranch::BranchFromInt(-1)));
else
m_cbBranchList->Append(Managers::GetString("#IF_FINDONCOMPUTER"), new BranchData(MCFBranch::BranchFromInt(-2), MCFBranch::BranchFromInt(-2)));
#endif
m_cbBranchList->SetSelection(full);
if (pItemInfo->getIcon() && UTIL::FS::isValidFile(UTIL::FS::PathWithFile(pItemInfo->getIcon())))
setIcon(pItemInfo->getIcon());
SetTitle(gcWString(Managers::GetString(L"#IF_BRANCHTITLE"), itemName));
uint32 ret = 0;
if (count == 0)
{
if (!isCheckingParent)
gcMessageBox(GetParent(), Managers::GetString(L"#IF_IINOBRANCHES"), Managers::GetString(L"#IF_IIERRTITLE"));
else if (selectBranch)
ret = 1;
}
else if ((count == 1 || fullReadyCount == 1) && !m_bBuy)
{
ret = 1;
}
else
{
wxCommandEvent e;
onChoice(e);
}
return ret;
}
// warning, this code will not work on big endian processors.
virtual bool importMesh(const char *_meshName,const void *_data,NxU32 dlen,MeshImportInterface *callback,const char *options,MeshImportApplicationResource *appResource)
{
bool ret = false;
const char *meshName = _meshName;
const char *slash = lastSlash(meshName);
if ( slash )
{
slash++;
meshName = slash;
}
char scratch[2048];
strncpy(scratch,_meshName,2048);
char *psk = stristr(scratch,".psk");
if ( psk )
{
*psk = 0;
strcat(scratch,".psa");
}
callback->importAssetName(meshName,0);
callback->importMesh(meshName,meshName);
// have to make a local copy of the data because we are going to modify some of it.
// Primarily just truncating some whitespace from bone names.
void *data = MEMALLOC_MALLOC(dlen);
memcpy(data,_data,dlen);
if ( appResource )
{
NxU32 len;
void *mem = appResource->getApplicationResource(meshName,scratch,len);
if ( mem )
{
char *scan = ( char *)mem;
Header *baseHeader = ( Header *)scan;
scan+=sizeof(Header);
Header *bonesHeader = ( Header *)scan;
scan+=sizeof(Header);
Bone *bones = ( Bone *)scan;
assert(sizeof(Bone)==bonesHeader->mLen);
scan+=(bonesHeader->mLen*bonesHeader->mCount);
Header *animInfo = ( Header *)scan;
scan+=sizeof(Header);
assert( animInfo->mLen == sizeof(AnimInfo));
AnimInfo *ainfo = ( AnimInfo *)scan;
scan+=(animInfo->mLen*animInfo->mCount);
Header *animKeysHeader = ( Header *)scan;
scan+=sizeof(Header);
assert( animKeysHeader->mLen == sizeof(AnimKey) );
AnimKey *keys = ( AnimKey *)scan;
scan+=(animKeysHeader->mLen*animKeysHeader->mCount);
Header *scaleKeysHeader = ( Header *)scan;
scan+=sizeof(Header);
MeshAnimation ma;
ma.mName = ainfo->mName;
ma.mTrackCount = ainfo->mTotalBones;
ma.mFrameCount = ainfo->mNumRawFrames;
ma.mDtime = 1.0f / (NxF32)(ainfo->mAnimRate);
ma.mDuration = ma.mDtime*ainfo->mNumRawFrames;
ma.mTracks = (MeshAnimTrack **)MEMALLOC_MALLOC(sizeof(MeshAnimTrack *)*ma.mTrackCount);
for (NxI32 i=0; i<ma.mTrackCount; i++)
{
Bone &b = bones[i];
fixName(b.mName);
MeshAnimTrack *track = MEMALLOC_NEW(MeshAnimTrack);
ma.mTracks[i] = track;
track->mName = b.mName;
track->mFrameCount = ma.mFrameCount;
track->mDuration = ma.mDuration;
track->mDtime = ma.mDtime;
track->mPose = MEMALLOC_NEW(MeshAnimPose)[track->mFrameCount];
for (NxI32 j=0; j<ma.mFrameCount; j++)
{
NxU32 index = (j*ma.mTrackCount)+i;
AnimKey &key = keys[index];
MeshAnimPose &p = track->mPose[j];
p.mPos[0] = key.mPosition[0]*IMPORT_SCALE;
#if HACK_ANIMATION_POSITION
p.mPos[1] = -key.mPosition[1]*IMPORT_SCALE;
#else
p.mPos[1] = key.mPosition[1]*IMPORT_SCALE;
#endif
p.mPos[2] = key.mPosition[2]*IMPORT_SCALE;
p.mQuat[0] = key.mOrientation[0];
#if HACK_ANIMATION_ROTATION
p.mQuat[1] = -key.mOrientation[1];
#else
p.mQuat[1] = key.mOrientation[1];
#endif
p.mQuat[2] = key.mOrientation[2];
p.mQuat[3] = key.mOrientation[3];
#if HACK_ANIMATION_ROOT
if ( i == 0)
{
p.mQuat[3] = -p.mQuat[3];
}
#endif
index++;
}
}
callback->importAnimation(ma);
for (NxI32 i=0; i<ma.mTrackCount; i++)
{
MeshAnimTrack *track = ma.mTracks[i];
delete []track->mPose;
delete track;
}
delete []ma.mTracks;
appResource->releaseApplicationResource(mem);
}
}
char *scan = ( char *)data;
char *end = scan+dlen;
Header *baseHeader = ( Header *)scan;
scan+=sizeof(Header); // skip first dummy header
Header *h = 0;
Header *positionsHeader = h = (Header *)scan;
assert( positionsHeader->mLen == sizeof(Vector));
scan+=sizeof(Header);
Vector *positions = ( Vector *)scan;
scan+=h->mLen*h->mCount;
#if HACK_MESH_POSITION
for (NxI32 i=0; i<positionsHeader->mCount; i++)
{
Vector &v = positions[i];
v.y*=-1; // flip the Y-coordinate
}
#endif
Header *verticesHeader = h = ( Header *)scan;
assert( verticesHeader->mLen == sizeof(Vertex));
scan+=sizeof(Header);
Vertex *vertices = ( Vertex *)scan;
scan+=h->mLen*h->mCount;
Header *trianglesHeader = h = ( Header *)scan;
assert( trianglesHeader->mLen == sizeof(Triangle));
scan+=sizeof(Header);
Triangle *triangles = ( Triangle *)scan;
scan+=h->mLen*h->mCount;
Header *materialsHeader = h = ( Header *)scan;
assert( materialsHeader->mLen == sizeof(Material));
scan+=sizeof(Header);
Material *materials= ( Material *)scan;
scan+=h->mLen*h->mCount;
Header *bonesHeader = h = ( Header *)scan;
assert( bonesHeader->mLen == sizeof(Bone));
scan+=sizeof(Header);
Bone *bones= ( Bone *)scan;
scan+=h->mLen*h->mCount;
Header *boneInfluencesHeader = h = ( Header *)scan;
assert( boneInfluencesHeader->mLen == sizeof(BoneInfluence));
scan+=sizeof(Header);
BoneInfluence *boneInfluences = ( BoneInfluence *)scan;
scan+=h->mLen*h->mCount;
if ( bonesHeader->mCount > 0 )
{
MeshSkeleton *ms = MEMALLOC_NEW(MeshSkeleton);
ms->mName = meshName;
ms->mBoneCount = bonesHeader->mCount;
ms->mBones = MEMALLOC_NEW(MeshBone)[ms->mBoneCount];
for (NxI32 i=0; i<ms->mBoneCount; i++)
{
MeshBone &dest = ms->mBones[i];
Bone &src = bones[i];
fixName(src.mName);
dest.mName = src.mName;
dest.mParentIndex = (i==0) ? -1 : src.mParentIndex;
dest.mPosition[0] = src.mPosition[0]*IMPORT_SCALE;
#if HACK_SKELETON_POSITION
dest.mPosition[1] = -src.mPosition[1]*IMPORT_SCALE;
#else
dest.mPosition[1] = src.mPosition[1]*IMPORT_SCALE;
#endif
dest.mPosition[2] = src.mPosition[2]*IMPORT_SCALE;
dest.mOrientation[0] = src.mOrientation[0];
#if HACK_SKELETON_ROTATION
dest.mOrientation[1] = -src.mOrientation[1];
#else
dest.mOrientation[1] = src.mOrientation[1];
#endif
dest.mOrientation[2] = src.mOrientation[2];
dest.mOrientation[3] = src.mOrientation[3];
#if HACK_SKELETON_ROOT
if ( i == 0 )
{
dest.mOrientation[3]*=-1;
}
#endif
dest.mScale[0] = 1; //src.mXSize;
dest.mScale[1] = 1; //src.mYSize;
dest.mScale[2] = 1; //src.mZSize;
}
callback->importSkeleton(*ms);
delete []ms->mBones;
delete ms;
}
assert( scan == end );
DeformVector *dvertices = MEMALLOC_NEW(DeformVector)[positionsHeader->mCount];
for (NxI32 i=0; i<boneInfluencesHeader->mCount; i++)
{
BoneInfluence &b = boneInfluences[i];
DeformVector &d = dvertices[b.mVertexIndex];
if ( d.mCount < 4 )
{
d.mWeight[d.mCount] = b.mWeight;
d.mBone[d.mCount] = (NxU16)b.mBoneIndex;
d.mCount++;
}
}
Vector *normals = (Vector *)MEMALLOC_MALLOC( sizeof(Vector)*positionsHeader->mCount);
memset(normals,0,sizeof(Vector)*positionsHeader->mCount);
for (NxI32 i=0; i<trianglesHeader->mCount; i++)
{
Triangle &t = triangles[i];
MeshVertex mv1,mv2,mv3;
Vertex &v1 = vertices[t.mWedgeIndex[0]];
Vertex &v2 = vertices[t.mWedgeIndex[1]];
Vertex &v3 = vertices[t.mWedgeIndex[2]];
Vector &p1 = positions[v1.mIndex];
Vector &p2 = positions[v2.mIndex];
Vector &p3 = positions[v3.mIndex];
Vector &n1 = normals[v1.mIndex];
Vector &n2 = normals[v2.mIndex];
Vector &n3 = normals[v3.mIndex];
Vector normal;
fm_computePlane( &p1.x, &p3.x, &p2.x, &normal.x );
n1.x+=normal.x;
n1.y+=normal.y;
n1.z+=normal.z;
n2.x+=normal.x;
n2.y+=normal.y;
n2.z+=normal.z;
n3.x+=normal.x;
n3.y+=normal.y;
n3.z+=normal.z;
}
for (NxI32 i=0; i<positionsHeader->mCount; i++)
{
Vector &n = normals[i];
fm_normalize(&n.x);
}
for (NxI32 i=0; i<trianglesHeader->mCount; i++)
{
Triangle &t = triangles[i];
MeshVertex mv1,mv2,mv3;
Vertex &v1 = vertices[t.mWedgeIndex[0]];
Vertex &v2 = vertices[t.mWedgeIndex[1]];
Vertex &v3 = vertices[t.mWedgeIndex[2]];
Vector &p1 = positions[v1.mIndex];
Vector &p2 = positions[v2.mIndex];
Vector &p3 = positions[v3.mIndex];
Vector &n1 = normals[v1.mIndex];
Vector &n2 = normals[v2.mIndex];
Vector &n3 = normals[v3.mIndex];
DeformVector &dv1 = dvertices[v1.mIndex];
DeformVector &dv2 = dvertices[v2.mIndex];
DeformVector &dv3 = dvertices[v3.mIndex];
getVertex(mv1,p1,v1,dv1,n1);
getVertex(mv2,p2,v2,dv2,n2);
getVertex(mv3,p3,v3,dv3,n3);
const char *material = "default";
if ( t.mMaterialIndex >= 0 && t.mMaterialIndex < materialsHeader->mCount )
{
material = materials[ t.mMaterialIndex ].mMaterialName;
}
#if HACK_MESH_WINDING
callback->importTriangle(meshName,material, MIVF_ALL, mv1, mv3, mv2 );
#else
callback->importTriangle(meshName,material, MIVF_ALL, mv1, mv2, mv3 );
#endif
}
delete []dvertices;
MEMALLOC_FREE(data);
return ret;
}
void scanOpcodes(FILE* opcodes, struct Z80OpcodeTable* mainTable)
{
char line[MAX_LINE];
char name[MAX_LINE];
char fmt[MAX_LINE];
char* cur;
byte code;
TokenType tt;
struct Z80OpcodeTable* current;
struct Z80OpcodeEntry* ent;
int opType;
rewind(opcodes);
do
{
fgets(line, MAX_LINE, opcodes);
trim(line);
if (feof(opcodes))
break;
mkFormat(&line[OPCODE_OFFSET], fmt);
fixName(&line[OPCODE_OFFSET], name);
line[OPCODE_OFFSET] = 0;
current = mainTable;
cur = line;
opType = OP_NONE;
do
{
cur = nextToken(cur, &code, &tt);
if (tt == TT_END)
{
break;
}
else if (tt == TT_OPCODE)
{
if (current->entries[code].table)
{
current = current->entries[code].table;
continue;
}
ent = ¤t->entries[code];
ent->func = strdup(name);
ent->format = strdup(fmt);
}
else if (tt == TT_NN)
{
opType = OP_WORD;
}
else if ((tt == TT_N) | (tt == TT_D))
{
opType = OP_BYTE;
}
else if (tt == TT_E)
{
opType = OP_OFFSET;
}
} while(1);
ent->operand_type = opType;
} while (1);
}
/** Reads the opcode list and generates output code based on the spec */
void generateCodeTable (FILE* opcodes, FILE* code)
{
char line[MAX_LINE];
char last[MAX_LINE];
char tmp[MAX_LINE];
char name[MAX_LINE];
char parm[5], subst[20];
int i;
char* p, *q;
char** cmds;
regmatch_t matches[MAX_MATCH];
Item* item;
printf("Generating opcode implementations...");
last[0] = 0;
do
{
fgets(line, MAX_LINE, opcodes);
trim(line);
if (feof(opcodes))
break;
for (q = line, p = q+OPCODE_OFFSET; *p; *q++ = *p++); /* Skip the hex part */
*q = 0;
/* Avoid duplicate opcodes */
if (strcmp(last, line) == 0)
continue;
strcpy(last, line);
/* Find the appropriate pattern */
for (i = 0; i < nItems; i++)
{
if (regexec(&items[i].re, line, MAX_MATCH, matches, REG_EXTENDED) == 0)
{
if (matches[0].rm_so == 0) /* Match only at beginning of line */
{
/*printf("%s : match %s\n", &line, items[i].pat);*/
break;
}
}
}
if (i >= nItems)
fatal2(line, " didn't match anything");
item = &items[i];
/* Print function stub */
fixName(line, name);
fprintf(code, "static void %s (Z80Context* ctx)\n{\n", name);
/* Substitute submatches in each output line and print the code */
cmds = item->line;
strcpy(parm, "%0");
while (*cmds)
{
if (!printCall(*cmds, code))
{
strncpy(tmp, *cmds, MAX_LINE);
q = tmp;
for (i = 1; i < MAX_MATCH; i++)
{
parm[1] = i + '0';
strncpy(subst, &line[matches[i].rm_so], matches[i].rm_eo - matches[i].rm_so);
subst[matches[i].rm_eo - matches[i].rm_so] = 0;
substStr(tmp, parm, subst);
}
fprintf(code, "%s\n", tmp);
}
cmds++;
}
fprintf(code, "}\n\n\n");
} while(1);
printf("done\n");
}
bool CUserItem::setFromString( wxString userSettings )
{
wxString strToken;
wxStringTokenizer tkz( userSettings, _(";") );
// name
if ( tkz.HasMoreTokens() ) {
strToken = tkz.GetNextToken();
strToken.Trim();
strToken.Trim(false);
if ( strToken.Length() ) {
setUser( strToken );
fixName();
}
}
// password
if ( tkz.HasMoreTokens() ) {
strToken = tkz.GetNextToken();
strToken.Trim();
strToken.Trim(false);
if ( strToken.Length() ) {
setPassword( strToken );
}
}
// fullname
if ( tkz.HasMoreTokens() ) {
strToken = tkz.GetNextToken();
strToken.Trim();
strToken.Trim(false);
if ( strToken.Length() ) {
setFullname( strToken );
}
}
// filter
if ( tkz.HasMoreTokens() ) {
strToken = tkz.GetNextToken();
strToken.Trim();
strToken.Trim(false);
if ( strToken.Length() ) {
setFilterFromString( strToken );
}
}
// mask
if ( tkz.HasMoreTokens() ) {
strToken = tkz.GetNextToken();
setFilterFromString( strToken );
}
// rights
if ( tkz.HasMoreTokens() ) {
strToken = tkz.GetNextToken();
strToken.Trim();
strToken.Trim(false);
if ( strToken.Length() ) {
setUserRightsFromString( strToken );
}
}
// remotes
if ( tkz.HasMoreTokens() ) {
strToken = tkz.GetNextToken();
setAllowedRemotesFromString( strToken );
}
// events
if ( tkz.HasMoreTokens() ) {
strToken = tkz.GetNextToken();
strToken.Trim();
strToken.Trim(false);
if ( strToken.Length() ) {
setAllowedEventsFromString( strToken );
}
}
// note
if ( tkz.HasMoreTokens() ) {
strToken = tkz.GetNextToken();
strToken.Trim();
strToken.Trim(false);
if ( strToken.Length() ) {
size_t len = wxBase64Decode( NULL, 0, strToken );
if ( 0 == len ) return false;
uint8_t *pbuf = new uint8_t[len];
if ( NULL == pbuf ) return false;
len = wxBase64Decode( pbuf, len, strToken );
strToken = wxString::FromUTF8( (const char *)pbuf, len );
delete [] pbuf;
setNote( strToken );
}
}
return true;
}
