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; }