bool LocalWorkspace::SetWorkspaceOptions(LocalOptionsConfigPtr opts)
{
// Stored as:
// <Workspace>
// <LocalWorkspaceOptions something="on" something_else="off"/>
// </Workspace>
if(!SanityCheck()) { return false; }
wxXmlNode* oldOptions = GetLocalWorkspaceOptionsNode();
if(oldOptions) {
m_doc.GetRoot()->RemoveChild(oldOptions);
delete oldOptions;
}
m_doc.GetRoot()->AddChild(opts->ToXml(NULL, wxT("LocalWorkspaceOptions")));
return SaveXmlFile();
}
void clCxxWorkspace::SetActiveProject(const wxString& name, bool active)
{
if(!m_doc.IsOk())
return;
// update the xml file
wxXmlNode* root = m_doc.GetRoot();
wxXmlNode* child = root->GetChildren();
while(child) {
if(child->GetName() == wxT("Project") && child->GetPropVal(wxT("Name"), wxEmptyString) == name) {
XmlUtils::UpdateProperty(child, wxT("Active"), active ? wxT("Yes") : wxT("No"));
break;
}
child = child->GetNext();
}
SaveXmlFile();
}
void clCxxWorkspace::SetBuildMatrix(BuildMatrixPtr mapping)
{
wxXmlNode* parent = m_doc.GetRoot();
wxXmlNode* oldMapping = XmlUtils::FindFirstByTagName(parent, wxT("BuildMatrix"));
if(oldMapping) {
parent->RemoveChild(oldMapping);
wxDELETE(oldMapping);
}
parent->AddChild(mapping->ToXml());
SaveXmlFile();
// force regeneration of makefiles for all projects
for(std::map<wxString, ProjectPtr>::iterator iter = m_projects.begin(); iter != m_projects.end(); iter++) {
iter->second->SetModified(true);
}
DoUpdateBuildMatrix();
}
bool CXmlFile::Save(bool printError)
{
m_error.clear();
wxCHECK(!m_fileName.empty(), false);
wxCHECK(m_pDocument, false);
bool res = SaveXmlFile();
m_modificationTime = CLocalFileSystem::GetModificationTime(m_fileName);
if (!res && printError) {
wxASSERT(!m_error.empty());
wxString msg = wxString::Format(_("Could not write \"%s\":"), m_fileName);
wxMessageBoxEx(msg + _T("\n") + m_error, _("Error writing xml file"), wxICON_ERROR);
}
return res;
}
bool Project::DeleteVirtualDir(const wxString &vdFullPath)
{
wxXmlNode *vd = GetVirtualDir(vdFullPath);
if ( vd ) {
wxXmlNode *parent = vd->GetParent();
if ( parent ) {
parent->RemoveChild( vd );
}
// remove the entry from the cache
DoDeleteVDFromCache(vdFullPath);
delete vd;
SetModified(true);
return SaveXmlFile();
}
return false;
}
wxXmlNode *Project::CreateVD(const wxString &vdFullPath, bool mkpath)
{
wxXmlNode *oldVd = GetVirtualDir(vdFullPath);
if ( oldVd ) {
// VD already exist
return oldVd;
}
wxStringTokenizer tkz(vdFullPath, wxT(":"));
wxXmlNode *parent = m_doc.GetRoot();
size_t count = tkz.CountTokens();
for (size_t i=0; i<count-1; i++) {
wxString token = tkz.NextToken();
wxXmlNode *p = XmlUtils::FindNodeByName(parent, wxT("VirtualDirectory"), token);
if ( !p ) {
if ( mkpath ) {
//add the node
p = new wxXmlNode(parent, wxXML_ELEMENT_NODE, wxT("VirtualDirectory"));
p->AddProperty(wxT("Name"), token);
} else {
return NULL;
}
}
parent = p;
}
wxXmlNode *node = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("VirtualDirectory"));
node->AddProperty(wxT("Name"), tkz.GetNextToken());
parent->AddChild(node);
//if not in transaction save the changes
if (!InTransaction()) {
SaveXmlFile();
}
// cache the result
m_vdCache[vdFullPath] = node;
return node;
}
bool CXmlFile::Save(bool printError)
{
m_error.clear();
wxCHECK(!m_fileName.empty(), false);
wxCHECK(m_document, false);
UpdateMetadata();
bool res = SaveXmlFile();
m_modificationTime = fz::local_filesys::get_modification_time(fz::to_native(m_fileName));
if (!res && printError) {
assert(!m_error.empty());
wxString msg = wxString::Format(_("Could not write \"%s\":"), m_fileName);
wxMessageBoxEx(msg + _T("\n") + m_error, _("Error writing xml file"), wxICON_ERROR);
}
return res;
}
void clCxxWorkspace::SetEnvironmentVariabels(const wxString& envvars)
{
if(!m_doc.IsOk()) return;
wxXmlNode* node = XmlUtils::FindFirstByTagName(m_doc.GetRoot(), wxT("Environment"));
if(node) {
m_doc.GetRoot()->RemoveChild(node);
delete node;
}
node = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("Environment"));
m_doc.GetRoot()->AddChild(node);
wxString nodeContent = envvars;
nodeContent.Trim().Trim(false);
wxXmlNode* contentNode = new wxXmlNode(wxXML_CDATA_SECTION_NODE, wxEmptyString, nodeContent);
node->AddChild(contentNode);
SaveXmlFile();
}
void LocalWorkspace::SetParserPaths(const wxArrayString& inclduePaths, const wxArrayString& excludePaths)
{
if(!SanityCheck()) return;
wxXmlNode* workspaceInclPaths = XmlUtils::FindFirstByTagName(m_doc.GetRoot(), wxT("WorkspaceParserPaths"));
if(workspaceInclPaths) {
m_doc.GetRoot()->RemoveChild(workspaceInclPaths);
delete workspaceInclPaths;
}
workspaceInclPaths = new wxXmlNode(m_doc.GetRoot(), wxXML_ELEMENT_NODE, wxT("WorkspaceParserPaths"));
for(size_t i = 0; i < inclduePaths.GetCount(); i++) {
wxXmlNode* child = new wxXmlNode(workspaceInclPaths, wxXML_ELEMENT_NODE, wxT("Include"));
child->AddProperty(wxT("Path"), inclduePaths.Item(i));
}
for(size_t i = 0; i < excludePaths.GetCount(); i++) {
wxXmlNode* child = new wxXmlNode(workspaceInclPaths, wxXML_ELEMENT_NODE, wxT("Exclude"));
child->AddProperty(wxT("Path"), excludePaths.Item(i));
}
SaveXmlFile();
}
bool LocalWorkspace::SetPinnedProjects(const wxArrayString& projects)
{
if(!SanityCheck()) { return false; }
wxXmlNode* root = m_doc.GetRoot();
wxXmlNode* node = XmlUtils::FindFirstByTagName(root, wxT("PinnedProjects"));
if(node) {
root->RemoveChild(node);
wxDELETE(node);
}
node = new wxXmlNode(root, wxXML_ELEMENT_NODE, wxT("PinnedProjects"));
root->AddChild(node);
for(const wxString& project : projects) {
wxXmlNode* p = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("Project"));
p->AddAttribute("Name", project);
node->AddChild(p);
}
return SaveXmlFile();
}
void Project::SetFileFlags(const wxString& fileName, const wxString& virtualDirPath, size_t flags)
{
wxXmlNode *vdNode = GetVirtualDir(virtualDirPath);
if ( !vdNode ) {
return;
}
// locate our file
wxFileName tmp(fileName);
tmp.MakeRelativeTo(m_fileName.GetPath());
wxString filepath = tmp.GetFullPath(wxPATH_UNIX);
wxXmlNode *fileNode = XmlUtils::FindNodeByName(vdNode, "File", filepath);
if ( !fileNode ) {
return;
}
// we have located the file node
// updat the flags
XmlUtils::UpdateProperty(fileNode, "Flags", wxString() << flags );
SaveXmlFile();
}
void Project::SetAllPluginsData(const std::map<wxString, wxString>& pluginsDataMap, bool saveToFile /* true */)
{
if(!m_doc.IsOk()) {
return;
}
// locate the 'Plugins' node
wxXmlNode *plugins = XmlUtils::FindFirstByTagName(m_doc.GetRoot(), wxT("Plugins"));
if( plugins ) {
m_doc.GetRoot()->RemoveChild( plugins );
delete plugins;
}
std::map<wxString, wxString>::const_iterator iter = pluginsDataMap.begin();
for(; iter != pluginsDataMap.end(); iter ++) {
SetPluginData( iter->first, iter->second, saveToFile );
}
if ( saveToFile ) {
SaveXmlFile();
}
}
bool Project::Create(const wxString &name, const wxString &description, const wxString &path, const wxString &projType)
{
m_vdCache.clear();
m_fileName = path + wxFileName::GetPathSeparator() + name + wxT(".project");
m_fileName.MakeAbsolute();
wxXmlNode *root = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("CodeLite_Project"));
m_doc.SetRoot(root);
m_doc.GetRoot()->AddProperty(wxT("Name"), name);
wxXmlNode *descNode = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("Description"));
XmlUtils::SetNodeContent(descNode, description);
m_doc.GetRoot()->AddChild(descNode);
// Create the default virtual directories
wxXmlNode *srcNode = NULL, *headNode = NULL;
srcNode = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("VirtualDirectory"));
srcNode->AddProperty(wxT("Name"), wxT("src"));
m_doc.GetRoot()->AddChild(srcNode);
headNode = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("VirtualDirectory"));
headNode->AddProperty(wxT("Name"), wxT("include"));
m_doc.GetRoot()->AddChild(headNode);
//creae dependencies node
wxXmlNode *depNode = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("Dependencies"));
root->AddChild(depNode);
SaveXmlFile();
//create build settings
SetSettings(new ProjectSettings(NULL));
ProjectSettingsPtr settings = GetSettings();
settings->SetProjectType(projType);
SetSettings(settings);
SetModified(true);
return true;
}
void Project::SetFiles(ProjectPtr src)
{
// first remove all the virtual directories from this project
// Remove virtual folders
wxXmlNode *vd = XmlUtils::FindFirstByTagName(m_doc.GetRoot(), wxT("VirtualDirectory"));
while (vd) {
m_doc.GetRoot()->RemoveChild( vd );
delete vd;
vd = XmlUtils::FindFirstByTagName(m_doc.GetRoot(), wxT("VirtualDirectory"));
}
// copy the virtual directories from the src project
wxXmlNode *child = src->m_doc.GetRoot()->GetChildren();
while ( child ) {
if ( child->GetName() == wxT("VirtualDirectory") ) {
// create a new VirtualDirectory like this one
wxXmlNode *newNode = new wxXmlNode(*child);
m_doc.GetRoot()->AddChild(newNode);
}
child = child->GetNext();
}
SaveXmlFile();
}
bool clCxxWorkspace::CreateProject(const wxString& name,
const wxString& path,
const wxString& type,
bool addToBuildMatrix,
wxString& errMsg)
{
if(!m_doc.IsOk()) {
errMsg = wxT("No workspace open");
return false;
}
ProjectPtr proj(new Project());
proj->Create(name, wxEmptyString, path, type);
proj->AssociateToWorkspace(this);
m_projects[name] = proj;
// make the project path to be relative to the workspace, if it's sensible to do so
wxFileName tmp(path + wxFileName::GetPathSeparator() + name + wxT(".project"));
tmp.MakeRelativeTo(m_fileName.GetPath());
// Add an entry to the workspace file
wxXmlNode* node = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("Project"));
node->AddProperty(wxT("Name"), name);
node->AddProperty(wxT("Path"), tmp.GetFullPath(wxPATH_UNIX));
m_doc.GetRoot()->AddChild(node);
if(m_projects.size() == 1) {
SetActiveProject(name, true);
}
SaveXmlFile();
if(addToBuildMatrix) {
AddProjectToBuildMatrix(proj);
}
return true;
}
bool Project::FastAddFile(const wxString& fileName, const wxString& virtualDir)
{
wxXmlNode *vd = GetVirtualDir(virtualDir);
if ( !vd ) {
return false;
}
// Convert the file path to be relative to
// the project path
DirSaver ds;
::wxSetWorkingDirectory(m_fileName.GetPath());
wxFileName tmp(fileName);
tmp.MakeRelativeTo(m_fileName.GetPath());
wxXmlNode *node = new wxXmlNode(NULL, wxXML_ELEMENT_NODE, wxT("File"));
node->AddProperty(wxT("Name"), tmp.GetFullPath(wxPATH_UNIX));
vd->AddChild(node);
if (!InTransaction()) {
SaveXmlFile();
}
SetModified(true);
return true;
}
bool LocalWorkspace::SetProjectOptions(LocalOptionsConfigPtr opts, const wxString& projectname)
{
// Stored as:
// <Project Name="foo">
// <Options something="on" something_else="off"/>
// </Project>
if(!SanityCheck()) { return false; }
// If the project node doesn't exist, create it
wxXmlNode* project = XmlUtils::FindNodeByName(m_doc.GetRoot(), wxT("Project"), projectname);
if(!project) {
project = new wxXmlNode(m_doc.GetRoot(), wxXML_ELEMENT_NODE, wxT("Project"));
project->AddProperty(wxT("Name"), projectname);
}
wxXmlNode* oldOptions = XmlUtils::FindFirstByTagName(project, wxT("Options"));
if(oldOptions) {
project->RemoveChild(oldOptions);
delete oldOptions;
}
project->AddChild(opts->ToXml(NULL, wxT("Options")));
return SaveXmlFile();
}
void Project::Save()
{
m_tranActive = false;
if ( m_doc.IsOk() )
SaveXmlFile();
}
void CFilterDialog::SaveFilters()
{
CInterProcessMutex mutex(MUTEX_FILTERS);
wxFileName file(wxGetApp().GetSettingsDir(), _T("filters.xml"));
TiXmlElement* pDocument = GetXmlFile(file);
if (!pDocument)
{
wxString msg = wxString::Format(_("Could not load \"%s\", please make sure the file is valid and can be accessed.\nAny changes made in the Site Manager could not be saved."), file.GetFullPath().c_str());
wxMessageBox(msg, _("Error loading xml file"), wxICON_ERROR);
return;
}
TiXmlElement *pFilters = pDocument->FirstChildElement("Filters");
while (pFilters)
{
pDocument->RemoveChild(pFilters);
pFilters = pDocument->FirstChildElement("Filters");
}
pFilters = pDocument->InsertEndChild(TiXmlElement("Filters"))->ToElement();
for (std::vector<CFilter>::const_iterator iter = m_globalFilters.begin(); iter != m_globalFilters.end(); iter++)
{
const CFilter& filter = *iter;
TiXmlElement* pFilter = pFilters->InsertEndChild(TiXmlElement("Filter"))->ToElement();
AddTextElement(pFilter, "Name", filter.name);
AddTextElement(pFilter, "ApplyToFiles", filter.filterFiles ? _T("1") : _T("0"));
AddTextElement(pFilter, "ApplyToDirs", filter.filterDirs ? _T("1") : _T("0"));
AddTextElement(pFilter, "MatchType", (filter.matchType == CFilter::any) ? _T("Any") : ((filter.matchType == CFilter::none) ? _T("None") : _T("All")));
AddTextElement(pFilter, "MatchCase", filter.matchCase ? _T("1") : _T("0"));
TiXmlElement* pConditions = pFilter->InsertEndChild(TiXmlElement("Conditions"))->ToElement();
for (std::vector<CFilterCondition>::const_iterator conditionIter = filter.filters.begin(); conditionIter != filter.filters.end(); conditionIter++)
{
const CFilterCondition& condition = *conditionIter;
TiXmlElement* pCondition = pConditions->InsertEndChild(TiXmlElement("Condition"))->ToElement();
AddTextElement(pCondition, "Type", condition.type);
AddTextElement(pCondition, "Condition", condition.condition);
AddTextElement(pCondition, "Value", condition.strValue);
}
}
TiXmlElement *pSets = pDocument->FirstChildElement("Sets");
while (pSets)
{
pDocument->RemoveChild(pSets);
pSets = pDocument->FirstChildElement("Sets");
}
pSets = pDocument->InsertEndChild(TiXmlElement("Sets"))->ToElement();
SetTextAttribute(pSets, "Current", wxString::Format(_T("%d"), m_currentFilterSet));
for (std::vector<CFilterSet>::const_iterator iter = m_globalFilterSets.begin(); iter != m_globalFilterSets.end(); iter++)
{
const CFilterSet& set = *iter;
TiXmlElement* pSet = pSets->InsertEndChild(TiXmlElement("Set"))->ToElement();
if (iter != m_globalFilterSets.begin())
AddTextElement(pSet, "Name", set.name);
for (unsigned int i = 0; i < set.local.size(); i++)
{
TiXmlElement* pItem = pSet->InsertEndChild(TiXmlElement("Item"))->ToElement();
AddTextElement(pItem, "Local", set.local[i] ? _T("1") : _T("0"));
AddTextElement(pItem, "Remote", set.remote[i] ? _T("1") : _T("0"));
}
}
SaveXmlFile(file, pDocument);
delete pDocument->GetDocument();
}
void CFilterManager::LoadFilters()
{
if (m_loaded)
{
m_filters = m_globalFilters;
m_filterSets = m_globalFilterSets;
m_currentFilterSet = m_globalCurrentFilterSet;
return;
}
m_loaded = true;
CInterProcessMutex mutex(MUTEX_FILTERS);
wxFileName file(wxGetApp().GetSettingsDir(), _T("filters.xml"));
if (!file.FileExists())
{
wxFileName defaults(wxGetApp().GetResourceDir(), _T("defaultfilters.xml"));
if (defaults.FileExists())
{
TiXmlElement* pDocument = GetXmlFile(defaults);
if (pDocument)
SaveXmlFile(file, pDocument);
}
}
TiXmlElement* pDocument = GetXmlFile(file);
if (!pDocument)
{
wxString msg = wxString::Format(_("Could not load \"%s\", please make sure the file is valid and can be accessed.\nAny changes made in the Site Manager could not be saved."), file.GetFullPath().c_str());
wxMessageBox(msg, _("Error loading xml file"), wxICON_ERROR);
return;
}
TiXmlElement *pFilters = pDocument->FirstChildElement("Filters");
if (!pFilters)
{
delete pDocument->GetDocument();
return;
}
TiXmlElement *pFilter = pFilters->FirstChildElement("Filter");
while (pFilter)
{
CFilter filter;
filter.name = GetTextElement(pFilter, "Name");
if (filter.name == _T(""))
{
pFilter = pFilter->NextSiblingElement("Filter");
continue;
}
filter.filterFiles = GetTextElement(pFilter, "ApplyToFiles") == _T("1");
filter.filterDirs = GetTextElement(pFilter, "ApplyToDirs") == _T("1");
wxString type = GetTextElement(pFilter, "MatchType");
if (type == _T("Any"))
filter.matchType = CFilter::any;
else if (type == _T("None"))
filter.matchType = CFilter::none;
else
filter.matchType = CFilter::all;
filter.matchCase = GetTextElement(pFilter, "MatchCase") == _T("1");
TiXmlElement *pConditions = pFilter->FirstChildElement("Conditions");
if (!pConditions)
{
pFilter = pFilter->NextSiblingElement("Filter");
continue;
}
TiXmlElement *pCondition = pConditions->FirstChildElement("Condition");
while (pCondition)
{
CFilterCondition condition;
int type = GetTextElementInt(pCondition, "Type", 0);
if (type < 0 || type >= filterType_size)
{
pCondition = pCondition->NextSiblingElement("Condition");
continue;
}
condition.type = (enum t_filterType)type;
condition.condition = GetTextElementInt(pCondition, "Condition", 0);
condition.strValue = GetTextElement(pCondition, "Value");
condition.matchCase = filter.matchCase;
if (condition.strValue == _T(""))
{
pCondition = pCondition->NextSiblingElement("Condition");
continue;
}
// TODO: 64bit filesize
if (condition.type == size)
{
unsigned long tmp;
condition.strValue.ToULong(&tmp);
condition.value = tmp;
}
else if (condition.type == attributes || condition.type == permissions)
{
if (condition.strValue == _T("0"))
condition.value = 0;
else
condition.value = 1;
}
filter.filters.push_back(condition);
pCondition = pCondition->NextSiblingElement("Condition");
}
if (!filter.filters.empty())
m_globalFilters.push_back(filter);
pFilter = pFilter->NextSiblingElement("Filter");
}
m_filters = m_globalFilters;
TiXmlElement* pSets = pDocument->FirstChildElement("Sets");
if (!pSets)
{
delete pDocument->GetDocument();
return;
}
for (TiXmlElement* pSet = pSets->FirstChildElement("Set"); pSet; pSet = pSet->NextSiblingElement("Set"))
{
CFilterSet set;
TiXmlElement* pItem = pSet->FirstChildElement("Item");
while (pItem)
{
wxString local = GetTextElement(pItem, "Local");
wxString remote = GetTextElement(pItem, "Remote");
set.local.push_back(local == _T("1") ? true : false);
set.remote.push_back(remote == _T("1") ? true : false);
pItem = pItem->NextSiblingElement("Item");
}
if (!m_globalFilterSets.empty())
{
set.name = GetTextElement(pSet, "Name");
if (set.name == _T(""))
continue;
}
if (set.local.size() == m_filters.size())
m_globalFilterSets.push_back(set);
}
m_filterSets = m_globalFilterSets;
wxString attribute = GetTextAttribute(pSets, "Current");
unsigned long value;
if (attribute.ToULong(&value))
{
if (value < m_globalFilterSets.size())
m_globalCurrentFilterSet = value;
}
m_currentFilterSet = m_globalCurrentFilterSet;
delete pDocument->GetDocument();
}
void CFilterManager::LoadFilters()
{
if (m_loaded)
return;
m_loaded = true;
CInterProcessMutex mutex(MUTEX_FILTERS);
wxFileName file(COptions::Get()->GetOption(OPTION_DEFAULT_SETTINGSDIR), _T("filters.xml"));
if (!file.FileExists())
{
wxFileName defaults(wxGetApp().GetResourceDir(), _T("defaultfilters.xml"));
if (defaults.FileExists())
{
TiXmlElement* pDocument = GetXmlFile(defaults);
if (pDocument)
{
SaveXmlFile(file, pDocument);
delete pDocument->GetDocument();
}
}
}
CXmlFile xml(file);
TiXmlElement* pDocument = xml.Load();
if (!pDocument)
{
wxString msg = xml.GetError() + _T("\n\n") + _("Any changes made to the filters will not be saved.");
wxMessageBox(msg, _("Error loading xml file"), wxICON_ERROR);
return;
}
TiXmlElement *pFilters = pDocument->FirstChildElement("Filters");
if (!pFilters)
return;
TiXmlElement *pFilter = pFilters->FirstChildElement("Filter");
while (pFilter)
{
CFilter filter;
bool loaded = LoadFilter(pFilter, filter);
if (loaded && filter.name != _T("") && !filter.filters.empty())
m_globalFilters.push_back(filter);
pFilter = pFilter->NextSiblingElement("Filter");
}
CompileRegexes();
TiXmlElement* pSets = pDocument->FirstChildElement("Sets");
if (!pSets)
return;
for (TiXmlElement* pSet = pSets->FirstChildElement("Set"); pSet; pSet = pSet->NextSiblingElement("Set"))
{
CFilterSet set;
TiXmlElement* pItem = pSet->FirstChildElement("Item");
while (pItem)
{
wxString local = GetTextElement(pItem, "Local");
wxString remote = GetTextElement(pItem, "Remote");
set.local.push_back(local == _T("1") ? true : false);
set.remote.push_back(remote == _T("1") ? true : false);
pItem = pItem->NextSiblingElement("Item");
}
if (!m_globalFilterSets.empty())
{
set.name = GetTextElement(pSet, "Name");
if (set.name == _T(""))
continue;
}
if (set.local.size() == m_globalFilters.size())
m_globalFilterSets.push_back(set);
}
wxString attribute = GetTextAttribute(pSets, "Current");
unsigned long value;
if (attribute.ToULong(&value))
{
if (value < m_globalFilterSets.size())
m_globalCurrentFilterSet = value;
}
}
void CFilterManager::LoadFilters()
{
if (m_loaded)
return;
m_loaded = true;
CInterProcessMutex mutex(MUTEX_FILTERS);
wxFileName file(wxGetApp().GetSettingsDir(), _T("filters.xml"));
if (!file.FileExists())
{
wxFileName defaults(wxGetApp().GetResourceDir(), _T("defaultfilters.xml"));
if (defaults.FileExists())
{
TiXmlElement* pDocument = GetXmlFile(defaults);
if (pDocument)
{
SaveXmlFile(file, pDocument);
delete pDocument->GetDocument();
}
}
}
CXmlFile xml(file);
TiXmlElement* pDocument = xml.Load();
if (!pDocument)
{
wxString msg = xml.GetError() + _T("\n\n") + _("Any changes made to the filters will not be saved.");
wxMessageBox(msg, _("Error loading xml file"), wxICON_ERROR);
return;
}
TiXmlElement *pFilters = pDocument->FirstChildElement("Filters");
if (!pFilters)
return;
TiXmlElement *pFilter = pFilters->FirstChildElement("Filter");
while (pFilter)
{
CFilter filter;
filter.name = GetTextElement(pFilter, "Name");
if (filter.name == _T(""))
{
pFilter = pFilter->NextSiblingElement("Filter");
continue;
}
filter.filterFiles = GetTextElement(pFilter, "ApplyToFiles") == _T("1");
filter.filterDirs = GetTextElement(pFilter, "ApplyToDirs") == _T("1");
wxString type = GetTextElement(pFilter, "MatchType");
if (type == _T("Any"))
filter.matchType = CFilter::any;
else if (type == _T("None"))
filter.matchType = CFilter::none;
else
filter.matchType = CFilter::all;
filter.matchCase = GetTextElement(pFilter, "MatchCase") == _T("1");
TiXmlElement *pConditions = pFilter->FirstChildElement("Conditions");
if (!pConditions)
{
pFilter = pFilter->NextSiblingElement("Filter");
continue;
}
TiXmlElement *pCondition = pConditions->FirstChildElement("Condition");
while (pCondition)
{
CFilterCondition condition;
int type = GetTextElementInt(pCondition, "Type", 0);
switch (type)
{
case 0:
condition.type = filter_name;
break;
case 1:
condition.type = filter_size;
break;
case 2:
condition.type = filter_attributes;
break;
case 3:
condition.type = filter_permissions;
break;
case 4:
condition.type = filter_path;
break;
default:
pCondition = pCondition->NextSiblingElement("Condition");
continue;
}
condition.condition = GetTextElementInt(pCondition, "Condition", 0);
condition.strValue = GetTextElement(pCondition, "Value");
condition.matchCase = filter.matchCase;
if (condition.strValue == _T(""))
{
pCondition = pCondition->NextSiblingElement("Condition");
continue;
}
// TODO: 64bit filesize
if (condition.type == filter_size)
{
unsigned long tmp;
condition.strValue.ToULong(&tmp);
condition.value = tmp;
}
else if (condition.type == filter_attributes || condition.type == filter_permissions)
{
if (condition.strValue == _T("0"))
condition.value = 0;
else
condition.value = 1;
}
filter.filters.push_back(condition);
pCondition = pCondition->NextSiblingElement("Condition");
}
if (!filter.filters.empty())
m_globalFilters.push_back(filter);
pFilter = pFilter->NextSiblingElement("Filter");
}
CompileRegexes();
TiXmlElement* pSets = pDocument->FirstChildElement("Sets");
if (!pSets)
return;
for (TiXmlElement* pSet = pSets->FirstChildElement("Set"); pSet; pSet = pSet->NextSiblingElement("Set"))
{
CFilterSet set;
TiXmlElement* pItem = pSet->FirstChildElement("Item");
while (pItem)
{
wxString local = GetTextElement(pItem, "Local");
wxString remote = GetTextElement(pItem, "Remote");
set.local.push_back(local == _T("1") ? true : false);
set.remote.push_back(remote == _T("1") ? true : false);
pItem = pItem->NextSiblingElement("Item");
}
if (!m_globalFilterSets.empty())
{
set.name = GetTextElement(pSet, "Name");
if (set.name == _T(""))
continue;
}
if (set.local.size() == m_globalFilters.size())
m_globalFilterSets.push_back(set);
}
wxString attribute = GetTextAttribute(pSets, "Current");
unsigned long value;
if (attribute.ToULong(&value))
{
if (value < m_globalFilterSets.size())
m_globalCurrentFilterSet = value;
}
}
void Project::SetReconciliationData(const wxString& toplevelDir, const wxString& extensions, const wxArrayString& ignoreFiles, const wxArrayString& excludePaths, wxArrayString& regexes)
{
if (!m_doc.IsOk()) {
return;
}
wxXmlNode* reconciliation = XmlUtils::FindFirstByTagName(m_doc.GetRoot(), wxT("Reconciliation"));
if (!reconciliation) {
reconciliation = new wxXmlNode(m_doc.GetRoot(), wxXML_ELEMENT_NODE, wxT("Reconciliation"));
}
wxXmlNode* dirnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Topleveldir"));
if (!dirnode) {
dirnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Topleveldir"));
}
XmlUtils::SetNodeContent(dirnode, toplevelDir);
wxXmlNode* extsnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Extensions"));
if (!extsnode) {
extsnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Extensions"));
}
wxString tmpData(extensions);
tmpData.Trim().Trim(false);
XmlUtils::SetCDATANodeContent(extsnode, tmpData);
wxXmlNode* ignorefilesnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Ignorefiles"));
if (!ignorefilesnode) {
ignorefilesnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Ignorefiles"));
} else {
XmlUtils::RemoveChildren(ignorefilesnode);
}
for (size_t n = 0; n < ignoreFiles.GetCount(); ++n) {
wxXmlNode* pathnode = new wxXmlNode(ignorefilesnode, wxXML_ELEMENT_NODE, "Ignore");
XmlUtils::SetNodeContent(pathnode, ignoreFiles.Item(n));
}
wxXmlNode* excludesnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Excludepaths"));
if (!excludesnode) {
excludesnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Excludepaths"));
} else {
XmlUtils::RemoveChildren(excludesnode);
}
for (size_t n = 0; n < excludePaths.GetCount(); ++n) {
wxXmlNode* pathnode = new wxXmlNode(excludesnode, wxXML_ELEMENT_NODE, "Path");
XmlUtils::SetNodeContent(pathnode, excludePaths.Item(n));
}
wxXmlNode* regexnode = XmlUtils::FindFirstByTagName(reconciliation, wxT("Regexes"));
if (!regexnode) {
regexnode = new wxXmlNode(reconciliation, wxXML_ELEMENT_NODE, wxT("Regexes"));
} else {
XmlUtils::RemoveChildren(regexnode);
}
for (size_t n = 0; n < regexes.GetCount(); ++n) {
wxXmlNode* itemnode = new wxXmlNode(regexnode, wxXML_ELEMENT_NODE, "Regex");
XmlUtils::SetNodeContent(itemnode, regexes.Item(n));
}
SaveXmlFile();
}
bool clCxxWorkspace::RemoveProject(const wxString& name, wxString& errMsg)
{
ProjectPtr proj = FindProjectByName(name, errMsg);
if(!proj) {
return false;
}
// remove the associated build configuration with this
// project
RemoveProjectFromBuildMatrix(proj);
// remove the project from the internal map
std::map<wxString, ProjectPtr>::iterator iter = m_projects.find(proj->GetName());
if(iter != m_projects.end()) {
m_projects.erase(iter);
}
// update the xml file
wxXmlNode* root = m_doc.GetRoot();
wxXmlNode* child = root->GetChildren();
while(child) {
if(child->GetName() == wxT("Project") && child->GetPropVal(wxT("Name"), wxEmptyString) == name) {
if(child->GetPropVal(wxT("Active"), wxEmptyString).CmpNoCase(wxT("Yes")) == 0) {
// the removed project was active,
// select new project to be active
if(!m_projects.empty()) {
std::map<wxString, ProjectPtr>::iterator iter = m_projects.begin();
SetActiveProject(iter->first, true);
}
}
root->RemoveChild(child);
delete child;
break;
}
child = child->GetNext();
}
// go over the dependencies list of each project and remove the project
iter = m_projects.begin();
for(; iter != m_projects.end(); iter++) {
ProjectPtr p = iter->second;
if(p) {
wxArrayString configs;
// populate the choice control with the list of available configurations for this project
ProjectSettingsPtr settings = p->GetSettings();
if(settings) {
ProjectSettingsCookie cookie;
BuildConfigPtr bldConf = settings->GetFirstBuildConfiguration(cookie);
while(bldConf) {
configs.Add(bldConf->GetName());
bldConf = settings->GetNextBuildConfiguration(cookie);
}
}
// update each configuration of this project
for(size_t i = 0; i < configs.GetCount(); i++) {
wxArrayString deps = p->GetDependencies(configs.Item(i));
int where = deps.Index(name);
if(where != wxNOT_FOUND) {
deps.RemoveAt((size_t)where);
}
// update the configuration
p->SetDependencies(deps, configs.Item(i));
}
}
}
return SaveXmlFile();
}
clCxxWorkspace::~clCxxWorkspace()
{
if(m_saveOnExit && m_doc.IsOk()) {
SaveXmlFile();
}
}