void MainDialog::UpdateTokenValues(ConfigToken & updateProfile, const string & searchStr, const string &replaceStr) const
{
// Get the value array in the token
uint i;
vector<string> tokenValues;
updateProfile.GetArray(updateProfile.GetNumValues(), tokenValues);
// Loop for all values in the token
for(i=0; i<tokenValues.size(); i++)
{
// Loop and find the token values
string::size_type findPos = tokenValues[i].find(searchStr);
while(findPos != string::npos)
{
// Replace the string
tokenValues[i].replace(findPos, searchStr.size(), replaceStr);
// Attempt to find more matches
findPos = tokenValues[i].find(searchStr, findPos + replaceStr.size());
}
}
// Replace the stored token values
updateProfile.SetValueArray(tokenValues);
// Loop for all children
for(i=0; i<updateProfile.GetNumChildren(); i++)
{
// Recurse
UpdateTokenValues(*updateProfile.GetChildToken(i), searchStr, replaceStr);
}
}
bool ConfigParser::ExtractTokens(RawTokenArray &rawTokens, uint &tokenNum, ConfigToken *parent)
{
ConfigToken *currToken=NULL;
bool inbracket = false;
bool assignment= false;
//NOTE: May have to use "proper" parser recursion if this gets much more complex
//Loop for all tokens
for(;tokenNum<rawTokens.size();tokenNum++)
{
string & tokenString = rawTokens[tokenNum].value;
int commandChar = (int)tokenString.find_first_of(singleTokens.c_str());
//If this is a command character, process it
if(commandChar == 0 && tokenString.length() == 1 &&
!rawTokens[tokenNum].isString)
{
if(tokenString == "{")
{
//Check that we are not in a bracket
if(inbracket || !currToken || assignment)
{
LOGERR(("ConfigParser::ExtractTokens - Un-expected '{'"));
return false;
}
//Recursive call
tokenNum++;
if(!ExtractTokens(rawTokens,tokenNum,currToken))
{
LOGERR(("ConfigParser::ExtractTokens - Error in child block"));
return false;
}
}
else if(tokenString == "}")
{
//Check that we are not in a bracket and that there was a '{'
if(inbracket || !parent || assignment)
{
LOGERR(("ConfigParser::ExtractTokens - Un-expected '}'"));
return false;
}
return true;
}
else if(tokenString == "(")
{
if(inbracket || !assignment || !currToken)
{
LOGERR(("ConfigParser::ExtractTokens - Un-expected '('"));
return false;
}
//Set bracket flag
inbracket = true;
}
else if(tokenString == ")")
{
//Check for missing opening bracket
if(!inbracket || !assignment || !currToken)
{
LOGERR(("ConfigParser::ExtractTokens - Un-expected ')'"));
return false;
}
//Un-set bracket flag
inbracket = false;
assignment= false;
}
else if(tokenString == ",")
{
//NOTE: does not check for excess comma's (ie double or extra trailing commas)
//Check for missing previous child and in a bracket
if(!inbracket || !currToken || currToken->GetNumValues() == 0)
{
LOGERR(("ConfigParser::ExtractTokens - Un-expected ','"));
return false;
}
}
else if(tokenString == "=")
{
//Check for current token
if(!currToken || assignment || inbracket)
{
LOGERR(("ConfigParser::ExtractTokens - Un-expected '='"));
return false;
}
assignment=true;
}
else if(tokenString == ";")
{
//Check for current token
if(!currToken || assignment || inbracket)
{
LOGERR(("ConfigParser::ExtractTokens - Un-expected ';'"));
return false;
}
//The token is just a seperator, so do nothing
}
else
{
LOGERR(("ConfigParser::ExtractTokens - Unknown command '%s'",tokenString.c_str()));
return false;
}
}
//Process the non-command token
else
{
//Else just create a new config token
if(inbracket && currToken)
{
//Add a new value to the config token
currToken->values.push_back(tokenString);
}
else if(assignment)
{
//Add a new value to the config token
currToken->values.push_back(tokenString);
//Flag that the assignment is complete
assignment =false;
}
else
{
//Create a new token
ConfigToken newToken;
newToken.name = tokenString;
//Either add to the parent or root
ConfigToken * addToToken = &rootToken;
if(parent)
{
addToToken = parent;
}
//Test if the child already exists
ConfigToken * existingToken = const_cast<ConfigToken *>(addToToken->GetChildToken(tokenString));
if(existingToken == NULL)
{
//Add the token
addToToken->children.push_back(newToken);
currToken = &addToToken->children.back();
}
else
{
//Cannot simply ignore as there may be children or ther values associated with the token
LOGERR(("ConfigParser::ExtractTokens - Extra %s token -using last value",tokenString.c_str()));
//Reset the token
existingToken->Reset();
//Assign as the current token
existingToken->name = tokenString;
currToken = existingToken;
}
}
}
}
//If this is not the root token, and we have processed all the data
// there is a missing closing bracket
if((parent != NULL || inbracket || assignment) && tokenNum>=rawTokens.size())
{
//Missing closing bracket
LOGERR(("ConfigParser::ExtractTokens - Un-expected end of tokens (end of file missing a '}' or a ')'?"));
return false;
}
/*
//Debug
for(uint i=0;i<parsedTokens.size();i++)
{
LOGERR(("%s",parsedTokens[i].name.c_str()));
}
*/
return true;
}
bool ConfigOptionsDialog::SetProfileData(const ConfigToken &setProfile, ConfigHeaderValue & headerToken)
{
uint i;
// If this is the plugins header
if(headerToken.headerName == CONFIG_PLUGINS_HEADER_NAME)
{
// Process from the plugins array
for(i=0; i<pluginGridValues.size(); i++)
{
// If there is a child with the plugin name
const ConfigToken * childToken = setProfile.GetChildToken(pluginGridValues[i].headerName);
if(childToken)
{
// Set the Plugin as enabled
for(uint pluginValue=0; pluginValue<pluginGridValues[i].childSelectArray.size(); pluginValue++)
{
// Set the plugin enabled flag to true
if(pluginGridValues[i].childSelectArray[pluginValue].typeName == CONFIG_PLUGIN_ENABLE_NAME)
{
pluginGridValues[i].childSelectArray[pluginValue].isValueDisplayed = true;
pluginGridValues[i].childSelectArray[pluginValue].defaultValue.clear();
pluginGridValues[i].childSelectArray[pluginValue].defaultValue.push_back(CONFIG_PLUGIN_TOKEN_TRUE);
break;
}
}
// Recurse
if(!SetProfileData(*childToken, pluginGridValues[i]))
{
return false;
}
}
}
return true;
}
// Loop for all read tokens
for(i=0; i<headerToken.childSelectArray.size(); i++)
{
// Find the token in the config data
const ConfigToken * childToken = setProfile.GetChildToken(headerToken.childSelectArray[i].typeName);
if(childToken)
{
// Get the new defaults
vector<string> newValues;
childToken->GetArray(childToken->GetNumValues(), newValues);
// Check the new values
if(newValues.size() == 0)
{
wxLogError("SetProfileData - Empty value for token %s", headerToken.childSelectArray[i].typeName.c_str());
return false;
}
// Check if there are a different number of values than the existing defaults
if(newValues.size() != headerToken.childSelectArray[i].defaultValue.size())
{
headerToken.childSelectArray[i].isValueDisplayed = true;
}
else
{
// Loop and check if any of the new values are different from the default string
for(uint cmpIndex=0; cmpIndex<newValues.size(); cmpIndex++)
{
// Find the first string that does not match
if(newValues[cmpIndex] != headerToken.childSelectArray[i].defaultValue[cmpIndex])
{
headerToken.childSelectArray[i].isValueDisplayed = true;
break;
}
}
}
// Assign the new values as the defaults
headerToken.childSelectArray[i].defaultValue = newValues;
}
}
// Loop for all child header tokens
for(i=0; i<headerToken.childHeaderArray.size(); i++)
{
// If there is a child with the header name
const ConfigToken * childToken = setProfile.GetChildToken(headerToken.childHeaderArray[i].headerName);
if(childToken)
{
// Recurse
if(!SetProfileData(*childToken, headerToken.childHeaderArray[i]))
{
return false;
}
}
}
return true;
}
void ConfigOptionsDialog::OnButtonSaveAs(wxCommandEvent& event)
{
// Get the profile data
ConfigToken saveConfigData;
if(!GetDisplayConfigData(saveConfigData))
{
wxLogError("Unable to get config data");
return;
}
// Convert the token data to a string
string stlConfigString;
for(uint childNum =0;childNum < saveConfigData.GetNumChildren(); childNum++)
{
//Convert each child back to raw config string data
const ConfigToken * childData = saveConfigData.GetChildToken(childNum);
if(childData)
{
string retString;
if(ConfigParser::GenerateConfigString(childData, retString))
{
stlConfigString += retString;
}
else
{
wxLogError("Unable to generate GLIntercept configuration file data");
return;
}
}
}
wxString saveConfigString = stlConfigString.c_str();
wxStandardPaths stdPaths;
wxFileName dirProcess;
// Get the main profile directory
dirProcess.AssignDir(stdPaths.GetDataDir());
dirProcess.AppendDir("Profiles");
wxString profileDir = dirProcess.GetPath();
// Open the profile save dialog
wxFileDialog fileDialog(this, _T("Save profile as"), profileDir, _T(""), _T("GLIntercept Profile (*.xni)|*.xni|Any (*.*)|*.*"), wxSAVE | wxOVERWRITE_PROMPT );
if (fileDialog.ShowModal() != wxID_OK)
{
return;
}
wxFile configWrite;
if(!configWrite.Open(fileDialog.GetPath(), wxFile::write))
{
wxLogError("Unable to open config file (%s)", fileDialog.GetPath().c_str());
return;
}
if(!configWrite.Write(saveConfigString))
{
wxLogError("Unable to write to config file (%s)", fileDialog.GetPath().c_str());
return;
}
// Flag that a config was saved
isConfigSaved = true;
}
bool MainDialog::GetSaveProfileString(bool copySystemLib, wxString &retString) const
{
wxStandardPaths stdPaths;
// Get the current selected profile
ConfigToken saveProfile;
if(!GetCurrentProfile(saveProfile))
{
wxLogError("No GLIntercept profile selected");
return false;
}
// Get the profile name (if any)
string profileName = "*Unknown*";
{
// Get the profile name if it exists
const ConfigToken * profileNameToken = saveProfile.GetChildToken("ProfileName");
if(profileNameToken)
{
profileNameToken->Get(profileName);
}
// Remove the profile/description tokens
saveProfile.RemoveChild("ProfileName");
saveProfile.RemoveChild("ProfileDescription");
}
// If copying the OpenGL system library
if(copySystemLib)
{
// Get the input files token (or create it)
ConfigToken * sourceInputFilesToken = GetCreateChildToken(saveProfile, "InputFiles");
if(sourceInputFilesToken)
{
// Get the system lib token (or create it)
ConfigToken * syslibToken = GetCreateChildToken(*sourceInputFilesToken, "GLSystemLib");
if(syslibToken)
{
// Set the new override system lib name
vector<string> newSystemLibName;
newSystemLibName.push_back("opengl32.orig.dll");
// Override the existing library name
syslibToken->SetValueArray(newSystemLibName);
}
}
}
// Replace any string that start with %InstallPath% with the current path
UpdateTokenValues(saveProfile, "%InstallPath%", stdPaths.GetDataDir().c_str());
// Generate the config string from the profile
string stlConfigString;
for(uint childNum =0;childNum < saveProfile.GetNumChildren(); childNum++)
{
//Convert each child back to raw config string data
const ConfigToken * childData = saveProfile.GetChildToken(childNum);
if(childData)
{
string retString;
if(ConfigParser::GenerateConfigString(childData, retString))
{
stlConfigString += retString;
}
else
{
wxLogError("Unable to generate GLIntercept configuration file data");
return false;
}
}
}
// Add a header comment
retString.Printf("/*\n* GLIntercept config file generated by GLIConfig.\n* Configuration based on profile \"%s\".\n*/\n\n", profileName.c_str());
retString += stlConfigString.c_str();
return true;
}