void MatrixArchive::setScalar(std::string const & scalarName, double scalar)
{
validateName(scalarName,SM_SOURCE_FILE_POS);
Eigen::MatrixXd & M = m_values[scalarName];
M.resize(1,1);
M(0,0) = scalar;
}
/////////////////////////////////////////////////////////////////////////////
// handle registering the player
/////////////////////////////////////////////////////////////////////////////
void CNewPlayerDialog::OnRegisterButton()
{
CString str;
CConnectorRegisterDlg dlg;
//check name
if(FALSE == validateName())
{
return;
}
//set the player info
dlg.setPlayer(m_Player);
//run the dialog
if(IDOK == dlg.DoModal())
{
m_Player = dlg.getPlayer();
//reinit
initDialog();
//they created a ladder player just now
m_bLadderNow = TRUE;
}
}
/////////////////////////////////////////////////////////////////////////////
// recheck a name
/////////////////////////////////////////////////////////////////////////////
void CConnectorRegisterDlg::OnValidateButton()
{
CString str;
//set the handle value
m_player.setHandle(m_OneNameCheck.GetCheck());
//get first name
m_FirstNameEdit.GetWindowText(str);
//validate that they have a first name
if(TRUE == str.IsEmpty())
{
MessageBox("The new player must at least have a first name or handle.", "New Player");
return;
}
m_player.setFirstName(str);
//last name
m_LastNameEdit.GetWindowText(str);
m_player.setLastName(str);
//run it
validateName();
}
OkState
RpcServerManager::addMyReservation(const std::string & name, const std::string & spec)
{
OkState valid = validateName(name);
if (valid.failed()) return valid;
const NamedService *old = _rpcsrvmap.lookupManaged(name);
if (old != nullptr) {
if (old->getSpec() == spec) {
// was alright already
return OkState(0, "already registered");
} else {
return OkState(FRTE_RPC_METHOD_FAILED, vespalib::make_string(
"name %s registered (to %s), cannot register %s",
name.c_str(), old->getSpec().c_str(), spec.c_str()));
}
}
// check if we already are in the progress of adding this
if (_rpcsrvmap.conflictingReservation(name, spec)) {
const ReservedName * rsv = _rpcsrvmap.getReservation(name);
LOG(warning, "conflicting registrations: wanted [%s -> %s] but [%s -> %s] already reserved",
name.c_str(), spec.c_str(), rsv->getName().c_str(), rsv->getSpec().c_str());
return OkState(FRTE_RPC_METHOD_FAILED,
"registration for name already in progress with a different spec");
}
_rpcsrvmap.removeReservation(name);
_rpcsrvmap.addReservation(std::make_unique<ReservedName>(name, spec, true));
return OkState(0, "done");
}
/////////////////////////////////////////////////////////////////////////////
// startup
/////////////////////////////////////////////////////////////////////////////
BOOL CConnectorRegisterDlg::OnInitDialog()
{
CHelpDialog::OnInitDialog();
//clear status messages
m_NameStatusStatic.SetWindowText("");
m_RegisterStatusStatic.SetWindowText("");
//set values
m_OneNameCheck.SetCheck(m_player.getHandle());
//hide others if needed
if(TRUE == m_player.getHandle())
{
m_LastNameStatic.ShowWindow(SW_HIDE);
m_LastNameEdit.ShowWindow(SW_HIDE);
m_HandleStatic.SetWindowText("Handle:");
}
//set values
m_FirstNameEdit.SetWindowText(m_player.getFirstName());
m_LastNameEdit.SetWindowText(m_player.getLastName());
//run the name through
validateName();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
static bool eeLoadGeneral()
{
theFile.openRd(FILE_GENERAL);
memset(&g_eeGeneral, 0, sizeof(EEGeneral));
// uint8_t sz = theFile.readRlc((uint8_t*)&g_eeGeneral, sizeof(EEGeneral));
theFile.readRlc((uint8_t*)&g_eeGeneral, sizeof(EEGeneral));
validateName( g_eeGeneral.ownerName, sizeof(g_eeGeneral.ownerName) ) ;
// for(uint8_t i=0; i<sizeof(g_eeGeneral.ownerName);i++) // makes sure name is valid
// {
// uint8_t idx = char2idx(g_eeGeneral.ownerName[i]);
// g_eeGeneral.ownerName[i] = idx2char(idx);
// }
if(g_eeGeneral.myVers<MDVERS)
{
sysFlags |= sysFLAG_OLD_EEPROM; // if old EEPROM - Raise flag
g_eeGeneral.myVers = MDVERS; // update myvers
STORE_GENERALVARS;
}
// if(sz>(sizeof(EEGeneral)-20)) for(uint8_t i=0; i<12;i++) sum+=g_eeGeneral.calibMid[i];
return g_eeGeneral.chkSum == evalChkSum() ;
}
OkState
RpcServerManager::addRemote(const std::string & name, const std::string &spec)
{
OkState valid = validateName(name);
if (valid.failed()) return valid;
if (alreadyManaged(name, spec)) {
return OkState(0, "already correct");
}
const NamedService *old = _rpcsrvmap.lookup(name);
if (old != nullptr) {
if (old->getSpec() != spec) {
LOG(warning, "collision on remote add: name %s registered to %s locally, "
"but another location broker wants it registered to %s",
name.c_str(), old->getSpec().c_str(), spec.c_str());
removeRemote(name, old->getSpec());
return OkState(13, "registered, with different spec");
}
// was alright already, remove reservation
_rpcsrvmap.removeReservation(name);
return OkState(0, "already correct");
}
_rpcsrvmap.removeReservation(name);
auto rpcsrv = std::make_unique<ManagedRpcServer>(name, spec, *this);
ManagedRpcServer & rpcServer = *rpcsrv;
_rpcsrvmap.addNew(std::move(rpcsrv));
rpcServer.healthCheck();
return OkState(0, "done");
}
const String NameManager::makeResourceName(bool isOrganic) {
int nameLength = 4 + System::random(6);
String name;
do {
name = "";
if (nameLength > 5 && System::random(2) == 1) {
addPrefix(name, isOrganic);
}
if(name.length() < 2) {
name += chooseNextLetter(' ', ' ');
name += chooseNextLetter(name[0], ' ');
}
assert(name.length() != 0);
while (name.length() < nameLength)
name += chooseNextLetter(name[name.length() - 1], name[name.length() - 2]);
if (!isVowel(name[name.length() - 1]) && name[name.length() - 1] != 'q' && System::random(1) == 1 )
addSuffix(name, isOrganic);
name[0] = Character::toUpperCase(name[0]);
} while (validateName(name, -1) != NameManagerResult::ACCEPTED);
return name;
}
int NameManager::validateName(CreatureObject* obj) {
StringId* objectName = obj->getObjectName();
UnicodeString name = obj->getCustomObjectName();
int species = obj->getSpecies();
return validateName(name.toString(), species);
}
OkState
RpcServerManager::addRemReservation(const std::string & remslobrok, const std::string & name, const std::string &spec)
{
OkState state = checkPartner(remslobrok);
if (state.failed()) return state;
OkState valid = validateName(name);
if (valid.failed()) return valid;
const NamedService *old = _rpcsrvmap.lookupManaged(name);
if (old != nullptr) {
if (old->getSpec() == spec) {
// was alright already
return OkState(0, "already registered");
}
LOG(warning, "remote %s tried to register [%s -> %s] but we already have [%s -> %s] registered!",
remslobrok.c_str(), name.c_str(), spec.c_str(), old->getName().c_str(), old->getSpec().c_str());
return OkState(FRTE_RPC_METHOD_FAILED, "already managed by me");
}
if (_rpcsrvmap.conflictingReservation(name, spec)) {
return OkState(FRTE_RPC_METHOD_FAILED, "registration for name already in progress");
}
_rpcsrvmap.addReservation(std::make_unique<ReservedName>(name, spec, false));
return OkState(0, "done");
}
void MatrixArchive::load(boost::filesystem::path const & amaFilePath, std::set<std::string> const & validNames)
{
std::ifstream fin(amaFilePath.string().c_str(), std::ios::binary);
SM_ASSERT_TRUE(MatrixArchiveException, fin.good(), "Unable to open file " << amaFilePath << " for reading");
std::string name, valueString;
Eigen::MatrixXd matrix;
fin.peek();
while(!fin.eof())
{
BlockType blockType = readBlock(fin, name, matrix, valueString);
if(validNames.empty() || validNames.count(name) > 0)
{
validateName(name,SM_SOURCE_FILE_POS);
switch(blockType){
case MATRIX:
m_values[name] = matrix;
break;
case STRING:
m_strings[name] = valueString;
break;
}
}
fin.peek();
}
}
QString OrganismHdl::tran2ID(QString name)
{
if(validateName(name)) {
return ogMap.value(name);
}else {
return "null";
}
}
void DataframeMergeSettingsFormDialog::addExtraWidgets()
{
QFormLayout *nameLayout = new QFormLayout;
nameLineEdit = new QLineEdit;
connect(nameLineEdit, SIGNAL(editingFinished()), this, SLOT(validateName()));
nameLayout->addRow("Dataframe name:", nameLineEdit);
mainLayout->addLayout(nameLayout);
}
void MatrixArchive::setString(std::string const & stringName, std::string const & value)
{
validateName(stringName, SM_SOURCE_FILE_POS);
if(m_values.count(stringName) > 0){
m_values.erase(stringName);
}
m_strings[stringName] = value;
}
void MatrixArchive::writeName(std::ostream & fout, std::string const & name) const
{
// fixed size character name
validateName(name, SM_SOURCE_FILE_POS);
fout.fill(' ');
fout.width(s_fixedNameSize);
fout << name;
}
bool parse(int argc, char **argv, Args &args)
{
for (int i = 0; i < argc; ++i)
{
const char *opt = argv[i];
if (strcmp("-T", opt) == 0 && i+1 < argc)
{
args.timestamp = (Timestamp) QByteArray(argv[++i]).toUInt(&args.hasTimestamp);
if (!args.hasTimestamp || !validateTime(args.timestamp))
return DEBUGRET(false, "invalid timestamp: " << argv[i]);
}
else if (strcmp("-K", opt) == 0 && i+1 < argc)
{
const char *token = argv[++i];
args.token = token;
if (!validateToken(token))
return DEBUGRET(false, "invalid token: " << token);
}
else if ((strcmp("-E", opt) == 0 || strcmp("-G", opt) == 0) && i+1 < argc)
{
const char *name = argv[++i];
if (!validateName(name))
return DEBUGRET(false, "invalid name: " << name);
args.person.isGuest = (strcmp("-G", opt) == 0);
args.person.name = name;
args.person.id = PersonID(0);
}
else if (strcmp("-A", opt) == 0)
{
args.mode = ArriveLeaveMode::Arrive;
}
else if (strcmp("-L", opt) == 0)
{
args.mode = ArriveLeaveMode::Leave;
}
else if (strcmp("-R", opt) == 0 && i+1 < argc)
{
args.room = (RoomID) QByteArray(argv[++i]).toUInt(&args.hasRoom);
if (!args.hasRoom || !validateRoom(args.room))
return false;
}
else if (*opt == '-') // unknown option
{
return DEBUGRET(false, "unknown option: " << opt);
}
else // log file
{
if (!args.path.isEmpty())
return DEBUGRET(false, "path already specified");
args.path = opt;
}
}
// check mandatory values
return (args.hasTimestamp && !args.token.isEmpty() && !args.person.name.isEmpty() &&
args.mode != ArriveLeaveMode::None && !args.path.isEmpty());
}
void ParamGeneratorGUI::initConnections()
{
connect(ptype,SIGNAL(currentIndexChanged(const QString&)),this,SLOT(updateGUIType(const QString&)));
connect(ptype,SIGNAL(currentIndexChanged(const QString&)),this,SLOT(updateOptionalWidgetVisibility(const QString&)));
connect(pguitype,SIGNAL(currentIndexChanged(const QString&)),this,SLOT(updateGUIWidgetInterface(const QString&)));
connect(pname,SIGNAL(textChanged(const QString&)),this,SLOT(updateItemLabel(const QString&)));
connect(pname,SIGNAL(textChanged(const QString&)),this,SLOT(updateGUILabel(const QString&)));
connect(pname,SIGNAL(editingFinished()),this,SLOT(validateName()));
}
contact *createContact(char *first, char *last, char *phone, unsigned short officenum, char gender, char hacker)
{
contact *ret = NULL;
ret = (contact *)calloc(1, sizeof(contact));
if(ret == NULL)
{
puts("Couldn't allocate contact. Something's wrong.");
_terminate(-1);
}
if(validateName(first)) {
memcpy(ret->first, first, strlen(first));
} else {
puts("Invalid first name. Must begin with a capital letter.");
free(ret);
ret = NULL;
return NULL;
}
if(validateName(last)) {
memcpy(ret->last, last, strlen(last));
} else {
puts("Invalid last name. Must begin with a capital letter.");
free(ret);
ret = NULL;
return NULL;
}
if(validatePhone(phone)) {
memcpy(ret->phone, phone, strlen(phone));
} else {
puts("Invalid phone number...must look like (nnn)nnn-nnnn");
free(ret);
ret = NULL;
return NULL;
}
ret->officenum = officenum;
ret->gender = gender;
ret->hacker = hacker;
ret->cookie = cookie;
ret->pad = 0;
ret->next = NULL;
ret->prev = NULL;
return ret;
}
void insertName()
{
char name[30];
printf("Insert your first name (Max 30 characters): ");
scanf("%s", name);
int isValid = validateName(name);
if (isValid)
printf("Hi %s! Nice to meet you!\n\n", name);
else
insertName();
}
String NameManager::makeName(int nameLength) {
String name;
do {
name = "";
/// Get first 2 letters
name += chooseNextLetter(' ', ' ');
name += chooseNextLetter(name[0], ' ');
assert(name.length() != 0);
while (name.length() < nameLength)
name += chooseNextLetter(name[name.length() - 1], name[name.length() - 2]);
name[0] = Character::toUpperCase(name[0]);
} while (validateName(name, -1) != NameManagerResult::ACCEPTED);
return name;
}
/////////////////////////////////////////////////////////////////////////////
// handle download
/////////////////////////////////////////////////////////////////////////////
void CNewPlayerDialog::OnBnClickedDownloadButton()
{
CConnectorDownloadDlg dlg;
//get the name into the data structure
validateName(FALSE);
//set the player info
dlg.setPlayer(m_Player);
//run the dialog
if(IDOK == dlg.DoModal())
{
m_Player = dlg.getPlayer();
//reinit
initDialog();
//they created a ladder player just now
m_bLadderNow = TRUE;
}
}
/////////////////////////////////////////////////////////////////////////////
// set new stuff
/////////////////////////////////////////////////////////////////////////////
void CNewPlayerDialog::OnOK()
{
int i;
int iSel;
CString str;
CButton *pButton;
//check name
if(FALSE == validateName())
{
return;
}
//get colors
m_Player.setColor1(m_Color1Combo.GetCurSel());
m_Player.setColor2(m_Color2Combo.GetCurSel());
//get language
iSel = m_LangCombo.GetCurSel();
m_Player.setLanguage(1 << iSel);
//get known
for(i = 0, iSel = 0; i < LANGUAGES_SIZE; i++)
{
pButton = &m_Lang1Check + i;
//check for check
if(TRUE == pButton->GetCheck())
{
iSel |= (1 << i);
}
}
//set the known
m_Player.setKnown(iSel);
CHelpDialog::OnOK();
}
Cliente::Cliente(ifstream &in){
string stringTemporaria;
getline(in, stringTemporaria);
if (stringTemporaria.size() == 0) {
this->id = 0;
return;
}
this->id = atoi(stringTemporaria.substr(0, stringTemporaria.find(';', 0)).c_str());
stringTemporaria = stringTemporaria.substr(stringTemporaria.find(';', 0) + 1);
this->nome = stringTemporaria.substr(0, stringTemporaria.find(';', 0));
validateName(this->nome);
stringTemporaria = stringTemporaria.substr(stringTemporaria.find(';', 0) + 1);
string dataString = stringTemporaria.substr(0, stringTemporaria.find(';', 0));
trimString(dataString);
Data dataCartao(dataString);
this->cartaoCliente = dataCartao;
stringTemporaria = stringTemporaria.substr(stringTemporaria.find(';', 0) + 1);
this->volCompras = atof(stringTemporaria.c_str());
this->active = true;
if (numClientes < this->id) {
numClientes = this->id;
}
}
MojErr MojDbIndex::fromObject(const MojObject& obj, const MojString& locale)
{
LOG_TRACE("Entering function %s", __FUNCTION__);
// check name
MojString name;
MojErr err = obj.getRequired(NameKey, name);
MojErrCheck(err);
err = validateName(name);
MojErrCheck(err);
m_name = name;
m_locale = locale;
if(m_locale == _T("en_CN"))
m_locale = locale;
// get deleted flag
bool includeDel = false;
if (obj.get(IncludeDeletedKey, includeDel)) {
incDel(includeDel);
}
// add props
MojObject props;
err = obj.getRequired(PropsKey, props);
MojErrCheck(err);
MojObject propObj;
MojSize j = 0;
while (props.at(j++, propObj)) {
err = addProp(propObj);
MojErrCheck(err);
}
if (m_props.empty()) {
MojErrThrowMsg(MojErrDbInvalidIndex, _T("db: no properties specified in index '%s'"), name.data());
}
m_obj = obj;
return MojErrNone;
}
struct hash *checkNames(struct mdbObj *mdbObjs, struct slName *terms)
{
struct dyString *dy = dyStringNew(100);
struct hash *mapping = newHash(10);
for(; mdbObjs; mdbObjs=mdbObjs->next)
{
struct mdbVar *mdbVar = hashFindVal(mdbObjs->varHash, "docId");
char *docId = "";
if (mdbVar)
docId = mdbVar->val;
docId += strlen("wgEncode");
dyStringClear(dy);
//dyStringPrintf(dy, "wgEncode");
struct slName *t;
for(t=terms; t; t = t->next)
{
struct mdbVar *mdbVar = hashFindVal(mdbObjs->varHash, t->name);
dyStringPrintf(dy, "%s", mdbVar->val);
}
dyStringPrintf(dy, "%s", docId);
validateName(dy->string);
char *newString = cloneString(dy->string);
if (hashLookup(mapping, mdbObjs->obj) != NULL)
errAbort("multiple mappings for %s\n", mdbObjs->obj);
hashAdd(mapping, mdbObjs->obj, newString);
//printf("changing %s to %s\n", mdbObjs->obj, dy->string);
}
return mapping;
}
TInt CFsObjectCon::CheckUniqueName(const CFsObject* anObject) const
//
// Returns KErrBadName if the name is invalid or
// returns KErrAlreadyExists if the full name is not unique.
//
{
TName name(*(anObject->iName));
TInt r=validateName(name);
if (r!=KErrNone)
return r;
if (!iCount)
return KErrNone;
CFsObject** pS=iObjects;
CFsObject** pE=pS+iCount;
// if it's name is null, just need to check it's not already there
if (!anObject->iName)
{
do
{
if (*pS==anObject)
return KErrAlreadyExists;
} while(++pS<pE);
return KErrNone;
}
do
{
if (NamesMatch(name,*pS))
return KErrAlreadyExists;
} while(++pS<pE);
return KErrNone;
}
as_object*
SharedObjectLibrary::getLocal(const std::string& objName,
const std::string& root)
{
assert (!objName.empty());
// already warned about it at construction time
if (_solSafeDir.empty()) return 0;
if (rcfile.getSOLLocalDomain() && !_baseDomain.empty())
{
log_security("Attempting to open SOL file from non "
"localhost-loaded SWF");
return 0;
}
// Check that the name is valid; if not, return null
if (!validateName(objName)) return 0;
// The 'root' argument, otherwise known as localPath, specifies where
// in the SWF path the SOL should be stored. It cannot be outside this
// path.
std::string requestedPath;
// If a root is specified, check it first for validity
if (!root.empty()) {
const movie_root& mr = _vm.getRoot();
const std::string& swfURL = mr.getOriginalURL();
// The specified root may or may not have a domain. If it doesn't,
// this constructor will add the SWF's domain.
URL localPath(root, swfURL);
StringNoCaseEqual noCaseCompare;
// All we care about is whether the domains match. They may be
// empty filesystem-loaded.
if (!noCaseCompare(localPath.hostname(), _baseDomain)) {
log_security(_("SharedObject path %s is outside the SWF domain "
"%s. Cannot access this object."), localPath,
_baseDomain);
return 0;
}
requestedPath = localPath.path();
// The domains match. Now check that the path is a sub-path of
// the SWF's URL. It is done by case-insensitive string comparison,
// so a double slash in the requested path will fail.
if (!noCaseCompare(requestedPath,
_basePath.substr(0, requestedPath.size()))) {
log_security(_("SharedObject path %s is not part of the SWF path "
"%s. Cannot access this object."), requestedPath,
_basePath);
return 0;
}
}
// A leading slash is added later
std::ostringstream solPath;
// If the domain name is empty, the SWF was loaded from the filesystem.
// Use "localhost".
solPath << (_baseDomain.empty() ? "localhost" : _baseDomain);
// Paths should start with a '/', so we shouldn't have to add another
// one.
assert(requestedPath.empty() ? _basePath[0] == '/' :
requestedPath[0] == '/');
// If no path was requested, use the SWF's path.
solPath << (requestedPath.empty() ? _basePath : requestedPath) << "/"
<< objName;
// TODO: normalize key!
const std::string& key = solPath.str();
// If the shared object was already opened, use it.
SoLib::iterator it = _soLib.find(key);
if (it != _soLib.end()) {
log_debug("SharedObject %s already known, returning it", key);
return &it->second->owner();
}
log_debug("SharedObject %s not loaded. Loading it now", key);
// Otherwise create a new one and register to the lib
SharedObject_as* sh = createSharedObject(*_vm.getGlobal());
if (!sh) return 0;
sh->setObjectName(objName);
std::string newspec = _solSafeDir;
newspec += "/";
newspec += key;
newspec += ".sol";
sh->setFilespec(newspec);
log_debug("SharedObject path: %s", newspec);
as_object* data = readSOL(_vm, newspec);
/// Don't set to 0, or it will initialize a property.
if (data) sh->setData(data);
// The SharedObjectLibrary must set this as reachable.
_soLib[key] = sh;
return &sh->owner();
}
void editUser(contact *ptr) {
char data[32];
char number[8];
if(ptr != NULL) {
puts("Updating fields. Send just a newline to keep old data.");
put("New first name: ");
recvUntil(data, 32, '\n');
if(data[0] && validateName(data) == 0){
puts("Not a legal first name. Stopping edit.");
return;
}
#ifdef PATCHED
data[31] = 0;
#endif
if(data[0] != 0) {
memset(ptr->first, 0, 32);
memcpy(ptr->first, data, strlen(data));
}
put("New last name: ");
recvUntil(data, 32, '\n');
#ifdef PATCHED
data[31] = 0;
#endif
if(data[0] && validateName(data) == 0) {
puts("Not a legal last name. Stopping edit.");
return;
}
if(data[0] != 0){
memset(ptr->last, 0, 32);
memcpy(ptr->last, data, strlen(data));
}
put("New phone number: ");
recvUntil(data, 14, '\n');
#ifdef PATCHED
data[13] = 0;
#endif
if(data[0] && validatePhone(data) == 0) {
puts("Not a legal phone number. Stopping edit.");
return;
}
if(data[0] != 0) {
memset(ptr->phone, 0, 16);
memcpy(ptr->phone, data, strlen(data));
}
put("New office number: ");
recvUntil(data, 6, '\n');
if(data[0]) {
memcpy(number, data, 5);
ptr->officenum = atoi(number);
}
put("New gender: ");
recvUntil(data, 2, '\n');
if(data[0])
ptr->gender = data[0];
put("Is the user a hacker? ");
recvUntil(data, 2, '\n');
if(data[0])
ptr->hacker = data[0];
}
if(ptr->cookie != cookie)
{
puts("Contact corruption detected.");
_terminate(-1);
}
}
/**
* Determine if the provided text can be used as a valid column name.
*
* @param colName The candidate column name
* @return True if valid, false otherwise
*/
bool DBEditor::isValidName(const QString &colName)
{
return validateName(colName, "", columnNames());
}
/////////////////////////////////////////////////////////////////////////////
// register the player
/////////////////////////////////////////////////////////////////////////////
void CConnectorRegisterDlg::OnRegisterButton()
{
CString strName;
CString strID;
CString strPassword, strConfirm;
//get the password strings
m_PasswordEdit.GetWindowText(strPassword);
m_ConfirmEdit.GetWindowText(strConfirm);
//ensure they don't have a blank password
if(TRUE == strPassword.IsEmpty())
{
MessageBox("Your password cannot be blank.", "Sea3D Connector");
return;
}
//compare confirm
if(strConfirm != strPassword)
{
MessageBox("Your password and confirmation do not match.", "Sea3D Connector");
return;
}
//we're ready to rumble, so first disable everything
enableStep2(FALSE);
//get the player's name
strName = m_player.getName();
//renable the frame and the message text
m_Step2Static.EnableWindow();
m_RegisterStatusStatic.EnableWindow();
//now revalidate
m_RegisterStatusStatic.SetWindowText("Validating name...");
//run it
if(FALSE == CONNECTOR->validateName(strName))
{
//have to start over
validateName();
return;
}
//now register
m_RegisterStatusStatic.SetWindowText("Registering player...");
//run it
if(FALSE == CONNECTOR->registerPlayer(strName, strPassword, strID))
{
//set text
m_RegisterStatusStatic.SetWindowText("Registration failed!");
return;
}
//tell them
MessageBox("You have successfully registered this player at s3dconnector.net.", "Sea3D Connector");
//we made it, so set the value
m_player.setLadderID(strID);
m_player.setLadder(TRUE);
//we're done
EndDialog(IDOK);
}
