bool MSVC10Loader::DoCreateConfigurations()
{
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
// create the project targets
for (HashProjectsConfs::iterator it = m_pc.begin(); it != m_pc.end(); ++it)
{
ProjectBuildTarget* bt = m_pProject->AddBuildTarget(it->second.sName);
if (bt)
{
bt->SetCompilerID(m_pProject->GetCompilerID());
bt->AddPlatform(spAll); // target all platforms, SupportedPlatforms enum in "globals.h"
TargetType tt = ttExecutable;
if (it->second.TargetType == _T("Application")) tt = ttExecutable;
else if (it->second.TargetType == _T("Console")) tt = ttConsoleOnly;
else if (it->second.TargetType == _T("StaticLibrary")) tt = ttStaticLib;
else if (it->second.TargetType == _T("DynamicLibrary")) tt = ttDynamicLib;
else
pMsg->DebugLog(_("Import; Unsupported target type: ") + it->second.TargetType);
bt->SetTargetType(tt); // executable by default, TargetType enum in "globals.h"
it->second.bt = bt; // apply
pMsg->DebugLog(_("Created project build target: ") + it->second.sName);
bResult = true; // at least one config imported
}
}
return bResult;
}
bool MSVC10Loader::Open(const wxString& filename)
{
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
m_ConvertSwitches = m_pProject->GetCompilerID().IsSameAs(_T("gcc"));
m_ProjectName = wxFileName(filename).GetName();
pMsg->DebugLog(F(_("Importing MSVC 10.xx project: %s"), filename.wx_str()));
TiXmlDocument doc(filename.mb_str());
if (!doc.LoadFile())
return false;
pMsg->DebugLog(_("Parsing project file..."));
const TiXmlElement* root = doc.FirstChildElement("Project");
if (!root)
{
pMsg->DebugLog(_("Not a valid MS Visual Studio project file..."));
return false;
}
// initialisation of the project
m_pProject->ClearAllProperties();
m_pProject->SetModified(true);
bool bResult = GetProjectGlobals(root) // get project name & type
// get the project list of configuration => 1 configuration = 1 build target in CodeBlocks
&& GetProjectConfigurations(root);
if (!bResult)
{
pMsg->DebugLog(_("Could not obtain project configurations."));
return false;
}
if ( !DoSelectConfigurations() )
return true; // user cancelled
if ( !DoCreateConfigurations() )
{
pMsg->DebugLog(_("Failed to create configurations in the project."));
return false;
}
// get the project list of files and add them to the targets
bResult = GetProjectConfigurationFiles(root)
// get the project/target list of includes and add them to the targets
&& GetProjectIncludes(root)
// get the project/target specific settings
&& GetTargetSpecific(root);
return bResult;
}
bool MSVC7Loader::Open(const wxString& filename)
{
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg)
return false;
/* NOTE (mandrav#1#): not necessary to ask for switches conversion... */
m_ConvertSwitches = m_pProject->GetCompilerID().IsSameAs(_T("gcc"));
m_ProjectName = wxFileName(filename).GetName();
pMsg->DebugLog(F(_T("Importing MSVC 7.xx project: %s"), filename.wx_str()));
TiXmlDocument doc(filename.mb_str());
if (!doc.LoadFile())
return false;
pMsg->DebugLog(_T("Parsing project file..."));
TiXmlElement* root;
root = doc.FirstChildElement("VisualStudioProject");
if (!root)
{
pMsg->DebugLog(_T("Not a valid MS Visual Studio project file..."));
return false;
}
if (strcmp(root->Attribute("ProjectType"), "Visual C++") != 0)
{
pMsg->DebugLog(_T("Project is not Visual C++..."));
return false;
}
wxString ver = cbC2U(root->Attribute("Version"));
if (ver.IsSameAs(_T("7.0")) || ver.IsSameAs(_T("7.00"))) m_Version = 70;
if (ver.IsSameAs(_T("7.1")) || ver.IsSameAs(_T("7.10"))) m_Version = 71;
if (ver.IsSameAs(_T("8.0")) || ver.IsSameAs(_T("8.00"))) m_Version = 80;
if ((m_Version!=70) && (m_Version!=71))
{
// seems to work with visual 8 too ;)
pMsg->DebugLog(F(_T("Project version is '%s'. Although this loader was designed for version 7.xx, will try to import..."), ver.wx_str()));
}
m_pProject->ClearAllProperties();
m_pProject->SetModified(true);
m_pProject->SetTitle(cbC2U(root->Attribute("Name")));
// delete all targets of the project (we 'll create new ones from the imported configurations)
while (m_pProject->GetBuildTargetsCount())
m_pProject->RemoveBuildTarget(0);
return DoSelectConfiguration(root);
}
/** get project name, type and GUID
* \param root : the root node of the XML project file (<Project >
**/
bool MSVC10Loader::GetProjectGlobals(const TiXmlElement* root)
{
if (!root) return false;
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
const char* title = root->Attribute("NoName");
if (title) m_pProject->SetTitle(cbC2U(title));
// parse all global parameters
const TiXmlElement* prop = root->FirstChildElement("PropertyGroup");
while (prop)
{
const char* attr = prop->Attribute("Label");
if (!attr) { prop = prop->NextSiblingElement(); continue; }
wxString label = cbC2U(attr);
if (label.MakeUpper().IsSameAs(_T("GLOBALS")))
{
const TiXmlElement* pGUID = prop->FirstChildElement("ProjectGuid");
if (pGUID) m_ProjectGUID = GetText(pGUID);
const TiXmlElement* pProjectType = prop->FirstChildElement("Keyword");
if (pProjectType) m_ProjectType = GetText(pProjectType);
const TiXmlElement* pProjectName = prop->FirstChildElement("RootNamespace");
if (pProjectName) m_ProjectName = GetText(pProjectName);
// logging
pMsg->DebugLog(wxString::Format(_("Project global properties: GUID=%s, Type=%s, Name=%s"),
m_ProjectGUID.wx_str(), m_ProjectType.wx_str(), m_ProjectName.wx_str()));
bResult = true; // got everything we need
break; // exit loop
}
prop = prop->NextSiblingElement();
}
if (!bResult)
pMsg->DebugLog(_("Failed to find global project properties, using default one."));
m_pProject->SetTitle(m_ProjectName);
return bResult;
}
bool ProjectTemplateLoader::Open(const wxString& filename)
{
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg)
return false;
// pMsg->DebugLog(_T("Reading template file %s"), filename.c_str());
TiXmlDocument doc(filename.mb_str());
if (!doc.LoadFile())
return false;
TiXmlElement* root;
root = doc.FirstChildElement("CodeBlocks_template_file");
if (!root)
{
// old tag
root = doc.FirstChildElement("Em::Blocks_template_file");
if (!root)
{
pMsg->DebugLog(_T("Not a valid Em::Blocks template file..."));
return false;
}
}
DoTemplate(root);
return true;
}
bool MSVC10Loader::DoSelectConfigurations()
{
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
if ( ImportersGlobals::ImportAllTargets ) // by default, all targets are imported
return true;
// ask the user to select a configuration - multiple choice ;)
wxArrayString configurations;
for (HashProjectsConfs::iterator it = m_pc.begin(); it != m_pc.end(); ++it)
configurations.Add(it->second.sName);
MultiSelectDlg dlg(0, configurations, true, _("Select configurations to import:"), m_pProject->GetTitle());
PlaceWindow(&dlg);
if (dlg.ShowModal() == wxID_CANCEL)
{
pMsg->DebugLog(_("Cancelled.."));
return false;
}
wxArrayString asSelectedStrings = dlg.GetSelectedStrings();
if (asSelectedStrings.GetCount() < 1)
{
pMsg->DebugLog(_("No selection -> cancelled."));
return false;
}
for (HashProjectsConfs::iterator it = m_pc.begin(); it != m_pc.end(); )
{
if (asSelectedStrings.Index(it->second.sName)==wxNOT_FOUND)
m_pc.erase(it++); // remove deselected
else
++it;
}
return true;
}
/** get project includes
* \param root : the root node of the XML project file (<Project >
**/
bool MSVC10Loader::GetProjectIncludes(const TiXmlElement* root)
{
if (!root) return false;
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
// parse all global parameters
const TiXmlElement* prop = root->FirstChildElement("PropertyGroup");
while (prop)
{
const char* attr = prop->Attribute("Condition");
if (!attr) { prop = prop->NextSiblingElement(); continue; }
wxString conf = cbC2U(attr);
for (size_t i=0; i<m_pcNames.Count(); ++i)
{
wxString sName = m_pcNames.Item(i);
wxString sConf = SubstituteConfigMacros(conf);
if (sConf.IsSameAs(sName))
{
const TiXmlElement* cinc = prop->FirstChildElement("IncludePath");
wxArrayString cdirs = GetDirectories(cinc);
for (size_t j=0; j<cdirs.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt) bt->AddIncludeDir(cdirs.Item(j));
}
const TiXmlElement* linc = prop->FirstChildElement("LibraryPath");
wxArrayString ldirs = GetDirectories(linc);
for (size_t j=0; j<ldirs.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt) bt->AddLibDir(ldirs.Item(j));
}
bResult = true; // got something
}
}
prop = prop->NextSiblingElement();
}
if (!bResult)
pMsg->DebugLog(_("Failed to find any includes in the project...?!"));
return bResult;
}
bool MSVC10Loader::GetProjectIncludes(const TiXmlElement* root)
{
if (!root) return false;
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
// parse all global parameters
const TiXmlElement* prop = root->FirstChildElement("PropertyGroup");
for (; prop; prop=prop->NextSiblingElement("PropertyGroup"))
{
const char* attr = prop->Attribute("Condition");
if (!attr) continue;
wxString conf = cbC2U(attr);
for (HashProjectsConfs::iterator it=m_pc.begin(); it!=m_pc.end(); ++it)
{
wxString sName = it->second.sName;
wxString sConf = SubstituteConfigMacros(conf);
if (sConf.IsSameAs(sName))
{
// $(VCInstallDir)include , $(VCInstallDir)atlmfc\include , $(WindowsSdkDir)include , $(FrameworkSDKDir)\include
const TiXmlElement* cinc = prop->FirstChildElement("IncludePath");
wxArrayString cdirs = GetArrayPaths(cinc, m_pc[sName]);
for (size_t j=0; j<cdirs.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt) bt->AddIncludeDir(cdirs.Item(j));
}
// $(VCInstallDir)lib , $(VCInstallDir)atlmfc\lib , $(WindowsSdkDir)lib , $(FrameworkSDKDir)\lib
const TiXmlElement* linc = prop->FirstChildElement("LibraryPath");
wxArrayString ldirs = GetArrayPaths(linc, m_pc[sName]);
for (size_t j=0; j<ldirs.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt) bt->AddLibDir(ldirs.Item(j));
}
bResult = true; // got something
}
}
}
if (!bResult)
pMsg->DebugLog(_("Failed to find any includes in the project...?!"));
return bResult;
}
/** get target specific stuff
* \param root : the root node of the XML project file (<Project >
**/
bool MSVC10Loader::GetTargetSpecific(const TiXmlElement* root)
{
if (!root) return false;
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
// parse all global parameters
const TiXmlElement* idef = root->FirstChildElement("ItemDefinitionGroup");
while (idef)
{
const char* attr = idef->Attribute("Condition");
if (!attr) { idef = idef->NextSiblingElement(); continue; }
wxString conf = cbC2U(attr);
for (size_t i=0; i<m_pcNames.Count(); ++i)
{
wxString sName = m_pcNames.Item(i);
wxString sConf = SubstituteConfigMacros(conf);
if (sConf.IsSameAs(sName))
{
const TiXmlElement* comp = idef->FirstChildElement("ClCompile");
if (comp)
{
const TiXmlElement* pp = comp->FirstChildElement("PreprocessorDefinitions");
wxArrayString pps = GetPreprocessors(pp);
for (size_t j=0; j<pps.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt) bt->AddCompilerOption((m_ConvertSwitches ? _T("-D") : _T("/D")) + pps.Item(j));
}
const TiXmlElement* cinc = comp->FirstChildElement("AdditionalIncludeDirectories");
wxArrayString cdirs = GetDirectories(cinc);
for (size_t j=0; j<cdirs.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt) bt->AddIncludeDir(cdirs.Item(j));
}
const TiXmlElement* copt = comp->FirstChildElement("AdditionalOptions");
wxArrayString copts = GetOptions(copt);
for (size_t j=0; j<copts.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt && !m_ConvertSwitches) bt->AddCompilerOption(copts.Item(j));
}
}
const TiXmlElement* link = idef->FirstChildElement("Link");
if (link)
{
const TiXmlElement* llib = link->FirstChildElement("AdditionalDependencies");
wxArrayString libs = GetLibs(llib);
for (size_t j=0; j<libs.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt) bt->AddLinkLib(libs.Item(j));
}
const TiXmlElement* linc = link->FirstChildElement("AdditionalLibraryDirectories");
wxArrayString ldirs = GetDirectories(linc);
for (size_t j=0; j<ldirs.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt) bt->AddLibDir(ldirs.Item(j));
}
const TiXmlElement* lopt = comp->FirstChildElement("AdditionalOptions");
wxArrayString lopts = GetOptions(lopt);
for (size_t j=0; j<lopts.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt && !m_ConvertSwitches) bt->AddLinkerOption(lopts.Item(j));
}
const TiXmlElement* debug = link->FirstChildElement("GenerateDebugInformation");
wxString sDebug = GetText(debug);
if (sDebug.MakeUpper().IsSameAs(_T("TRUE")))
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt && !m_ConvertSwitches) bt->AddLinkerOption(_T("/debug"));
}
}
const TiXmlElement* res = idef->FirstChildElement("ResourceCompile");
if (res)
{
const TiXmlElement* pp = res->FirstChildElement("PreprocessorDefinitions");
wxArrayString pps = GetPreprocessors(pp);
for (size_t j=0; j<pps.Count(); ++j)
{
ProjectBuildTarget* bt = m_pc[sName].bt;
if (bt) bt->AddCompilerOption((m_ConvertSwitches ? _T("-D") : _T("/D")) + pps.Item(j));
}
}
bResult = true; // got something
}
}
idef = idef->NextSiblingElement();
}
if (!bResult)
pMsg->DebugLog(_("Failed to find any includes in the project...?!"));
return bResult;
}
/** get the list of files in the project
* For each configuration found, the files will be added
* \param root : the root node of the XML project file (<Project >
**/
bool MSVC10Loader::GetProjectConfigurationFiles(const TiXmlElement* root)
{
if (!root) return false;
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
// parse each ItemGroup
const TiXmlElement* prop = root->FirstChildElement("ItemGroup");
while (prop)
{
const TiXmlElement* none = prop->FirstChildElement("None");
while (none)
{
const char* attr = none->Attribute("Include");
if (attr)
{
ProjectFile* pf = m_pProject->AddFile(0, cbC2U(attr), false, false);
HandleFilesAndExcludes(none, pf);
}
none = none->NextSiblingElement();
bResult = true; // at least one file imported
}
const TiXmlElement* incl = prop->FirstChildElement("ClInclude");
while (incl)
{
const char* attr = incl->Attribute("Include");
if (attr)
{
ProjectFile* pf = m_pProject->AddFile(0, cbC2U(attr), false, false);
HandleFilesAndExcludes(incl, pf);
}
incl = incl->NextSiblingElement();
bResult = true; // at least one file imported
}
const TiXmlElement* comp = prop->FirstChildElement("ClCompile");
while (comp)
{
const char* attr = comp->Attribute("Include");
if (attr)
{
ProjectFile* pf = m_pProject->AddFile(0, cbC2U(attr), true, true);
HandleFilesAndExcludes(comp, pf);
}
comp = comp->NextSiblingElement();
bResult = true; // at least one file imported
}
const TiXmlElement* res = prop->FirstChildElement("ResourceCompile");
while (res)
{
const char* attr = res->Attribute("Include");
if (attr)
{
ProjectFile* pf = m_pProject->AddFile(0, cbC2U(attr), true, true);
HandleFilesAndExcludes(res, pf);
}
res = res->NextSiblingElement();
bResult = true; // at least one file imported
}
prop = prop->NextSiblingElement();
}
if (!bResult)
pMsg->DebugLog(_("Failed to find any files in the project...?!"));
return bResult;
}
/** get the configuration in the project
* \param root : the root node of the XML project file (<Project >
**/
bool MSVC10Loader::GetConfiguration(const TiXmlElement* root)
{
if (!root) return false;
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
// now that we have (in theory) the list of configurations, we will parse each configuration
const TiXmlElement* prop = root->FirstChildElement("PropertyGroup");
while (prop)
{
const char* attr = prop->Attribute("Label");
if (!attr) { prop = prop->NextSiblingElement(); continue; }
wxString label = cbC2U(attr);
if (label.MakeUpper().IsSameAs(_T("CONFIGURATION")))
{
const char* name = prop->Attribute("Condition");
const TiXmlElement* type = prop->FirstChildElement("ConfigurationType");
const TiXmlElement* dbg = prop->FirstChildElement("UseDebugLibraries");
const TiXmlElement* cset = prop->FirstChildElement("CharacterSet");
if (name && type && dbg && cset)
{
wxString sName = cbC2U(name); sName = SubstituteConfigMacros(sName);
if (m_pcNames.Index(sName)==wxNOT_FOUND) m_pcNames.Add(sName);
m_pc[sName].sName = sName; // OK, probably not so useful, just for completeness sake
m_pc[sName].TargetType = GetText(type);
m_pc[sName].UseDebugLibs = GetText(dbg);
m_pc[sName].Charset = GetText(cset);
const TiXmlElement* e = NULL;
// By default, OutDir is $(SolutionDir)$(Configuration)
e = prop->FirstChildElement("OutDir");
if (e) m_pc[sName].sOutDir = GetText(e);
// By default, IntDir is $(Configuration)
e = prop->FirstChildElement("IntDir");
if (e) m_pc[sName].sIntDir = GetText(e);
// By default, TargetName is $(ProjectName)
e = prop->FirstChildElement("TargetName");
if (e) m_pc[sName].sTargetName = GetText(e);
// By default, TargetExt is .exe
e = prop->FirstChildElement("TargetExt");
if (e) m_pc[sName].sTargetExt = GetText(e);
// $(VCInstallDir)include , $(VCInstallDir)atlmfc\include , $(WindowsSdkDir)include , $(FrameworkSDKDir)\include
e = prop->FirstChildElement("IncludePath");
if (e) m_pc[sName].sIncludePath = GetText(e);
// $(VCInstallDir)lib , $(VCInstallDir)atlmfc\lib , $(WindowsSdkDir)lib , $(FrameworkSDKDir)\lib
e = prop->FirstChildElement("LibraryPath");
if (e) m_pc[sName].sLibPath = GetText(e);
// $(VCInstallDir)bin , $(WindowsSdkDir)bin\NETFX 4.0 Tools , $(WindowsSdkDir)bin , $(VSInstallDir)Common7\Tools\bin ,
// $(VSInstallDir)Common7\tools , $(VSInstallDir)Common7\ide , $(ProgramFiles)\HTML Help Workshop , $(FrameworkSDKDir)\bin ,
// $(MSBuildToolsPath32) , $(VSInstallDir) , $(SystemRoot)\SysWow64 , $(FxCopDir) , $(PATH)
e = prop->FirstChildElement("ExecutablePath");
if (e) m_pc[sName].sExePath = GetText(e);
// $(VCInstallDir)atlmfc\src\mfc , $(VCInstallDir)atlmfc\src\mfcm , $(VCInstallDir)atlmfc\src\atl , $(VCInstallDir)crt\src
e = prop->FirstChildElement("SourcePath");
if (e) m_pc[sName].sSourcePath = GetText(e);
bResult = true;
}
}
prop = prop->NextSiblingElement();
}
if (!bResult)
pMsg->DebugLog(_("Failed to find configuration, using default one."));
return bResult;
}
/** get the list of configurations in the project
* For each configuration found, a target will be created
* \param root : the root node of the XML project file (<Project >
**/
bool MSVC10Loader::GetProjectConfigurations(const TiXmlElement* root)
{
// delete all targets of the project (we 'll create new ones from the imported configurations)
while (m_pProject && m_pProject->GetBuildTargetsCount())
m_pProject->RemoveBuildTarget(0);
if (!root) return false;
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
// first we try to get the list of configurations : there is normally a specific chapter for that
// this is not truly necessary, but it is cleaner like that:
// the plugin will be easier to understand, and easier to extend if necessary
const TiXmlElement* prop = root->FirstChildElement("ItemGroup");
while (prop)
{
const char* attr = prop->Attribute("Label");
if (!attr) { prop = prop->NextSiblingElement(); continue; }
wxString label = cbC2U(attr);
if (label.MakeUpper().IsSameAs(_T("PROJECTCONFIGURATIONS")))
{
const TiXmlElement* conf = prop->FirstChildElement("ProjectConfiguration");
while (conf)
{
// loop over all the configurations
const char* name = conf->Attribute("Include");
const TiXmlElement* cfg = conf->FirstChildElement("Configuration");
const TiXmlElement* plat = conf->FirstChildElement("Platform");
if (name && cfg && plat)
{
wxString sName = cbC2U(name); sName.Replace(_T("|"), _T(" "));
wxString sConf = GetText(cfg);
wxString sPlat = GetText(plat);
if (m_pcNames.Index(sName)==wxNOT_FOUND) m_pcNames.Add(sName);
SProjectConfiguration pc;
pc.bt = NULL;
pc.sName = sName;
pc.sPlatform = sPlat;
pc.sConf = sConf;
pc.TargetType = _T("Application");
pc.UseDebugLibs = _T("true");
pc.bIsDefault = false;
pc.bImport = true;
m_pc[sName] = pc;
pMsg->DebugLog(_("Found project configuration: ") + sName);
bResult = true;
}
conf = conf->NextSiblingElement();
}
}
prop = prop->NextSiblingElement();
}
if (!bResult)
{
pMsg->DebugLog(_("Failed to find project configurations."));
return false;
}
// now that we have (in theory) the list of configurations, we will parse each configuration
bResult &= GetConfiguration(root);
m_pProject->SetTitle(m_ProjectName);
return true;
}
// IMPORTANT! We have to be careful of what to unicode and what not to.
// TinyXML must use NON-unicode strings!
// ----------------------------------------------------------------------------
bool BrowseTrackerLayout::Open(const wxString& filename, FileBrowse_MarksHash& m_FileBrowse_MarksArchive , FileBrowse_MarksHash& m_EdBook_MarksArchive )
// ----------------------------------------------------------------------------
{
TiXmlDocument doc;
if (!TinyXML::LoadDocument(filename, &doc))
return false;
ProjectManager* pMan = Manager::Get()->GetProjectManager();
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMan || !pMsg)
return false;
TiXmlElement* root;
TiXmlElement* elem;
wxString fname;
ProjectFile* pf;
root = doc.FirstChildElement("BrowseTracker_layout_file");
if (!root)
{
// old tag
root = doc.FirstChildElement("BrowseTracker_layout_file");
if (!root)
{
pMsg->DebugLog(_T("Not a valid BrowseTracker layout file..."));
return false;
}
}
elem = root->FirstChildElement("ActiveTarget");
if (elem)
{
if (elem->Attribute("name"))
;//m_pProject->SetActiveBuildTarget(cbC2U(elem->Attribute("name")));
}
elem = root->FirstChildElement("File");
if (!elem)
{
//pMsg->DebugLog(_T("No 'File' element in file..."));
return false;
}
while (elem)
{
//pMsg->DebugLog(elem->Value());
fname = cbC2U(elem->Attribute("name"));
if (fname.IsEmpty())
{
//pMsg->DebugLog(_T("'File' node exists, but no filename?!?"));
pf = 0L;
}
else
pf = m_pProject->GetFileByFilename(fname);
if (pf)
{
//pf->editorOpen = false;
//pf->editorPos = 0;
//pf->editorTopLine = 0;
int open = 0;
int top = 0;
int tabpos = 0;
if (elem->QueryIntAttribute("open", &open) == TIXML_SUCCESS)
;//pf->editorOpen = open != 0;
if (elem->QueryIntAttribute("top", &top) == TIXML_SUCCESS)
{
if(top)
m_TopProjectFile = pf;
}
if (elem->QueryIntAttribute("tabpos", &tabpos) == TIXML_SUCCESS)
;//pf->editorTabPos = tabpos;
TiXmlElement* cursor = elem->FirstChildElement();
if (cursor)
{
int pos = 0;
int topline = 0;
if (cursor->QueryIntAttribute("position", &pos) == TIXML_SUCCESS)
;//pf->editorPos = pos;
if (cursor->QueryIntAttribute("topLine", &topline) == TIXML_SUCCESS)
;//pf->editorTopLine = topline;
}
#if defined(LOGGING)
///LOGIT( _T("Open Layout processing for[%s]"),fname.c_str() );
#endif
TiXmlElement* browsemarks = cursor->NextSiblingElement("BrowseMarks");
///if (not browsemarks)
/// LOGIT( _T("OPEN LAYOUT failed for BrowseMarks") );
if (browsemarks)
{
wxString marksString = cbC2U(browsemarks->Attribute("positions"));
#if defined(LOGGING)
////LOGIT( _T("OPEN_LAYOUT BROWSEMarksStrng[%s][%s]"), fname.c_str(), marksString.c_str() );
#endif
ParseBrowse_MarksString( fname, marksString, m_FileBrowse_MarksArchive );
}
TiXmlElement* bookmarks = cursor->NextSiblingElement("Book_Marks");
///if (not bookmarks)
/// LOGIT( _T("OPEN LAYOUT failed for Book_Marks") );
if (bookmarks)
{
wxString marksString = cbC2U(bookmarks->Attribute("positions"));
#if defined(LOGGING)
////LOGIT( _T("OPEN_LAYOUT BOOKMarksStrng[%s][%s]"), fname.c_str(), marksString.c_str() );
#endif
ParseBrowse_MarksString( fname, marksString, m_EdBook_MarksArchive );
}
}
elem = elem->NextSiblingElement();
}
return true;
}//Open
bool EncodingDetector::ConvertToWxString(const wxByte* buffer, size_t size)
{
LogManager* logmgr = Manager::Get()->GetLogManager();
wxString logmsg;
if (!buffer || size == 0)
{
if (m_UseLog)
{
logmsg.Printf(_T("Encoding conversion has failed (buffer is empty)!"));
logmgr->DebugLog(logmsg);
}
return false; // Nothing we can do...
}
if (m_BOMSizeInBytes > 0)
{
for (int i = 0; i < m_BOMSizeInBytes; ++i)
buffer++;
}
size_t outlen = 0;
/* NOTE (Biplab#5#): FileManager returns a buffer with 4 extra NULL chars appended.
But the buffer size is returned sans the NULL chars */
wxWCharBuffer wideBuff;
// if possible use the special conversion-routines, they are much faster than wxCSCov (at least on linux)
if ( m_Encoding == wxFONTENCODING_UTF7 )
{
wxMBConvUTF7 conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF8 )
{
wxMBConvUTF8 conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF16BE )
{
wxMBConvUTF16BE conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF16LE )
{
wxMBConvUTF16LE conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF32BE )
{
wxMBConvUTF32BE conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else if ( m_Encoding == wxFONTENCODING_UTF32LE )
{
wxMBConvUTF32LE conv;
wideBuff = conv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
}
else
{
// try wxEncodingConverter first, even it it only works for
// wxFONTENCODING_ISO8859_1..15, wxFONTENCODING_CP1250..1257 and wxFONTENCODING_KOI8
// but it's much, much faster than wxCSConv (at least on Linux)
wxEncodingConverter conv;
wchar_t* tmp = new wchar_t[size + 4 - m_BOMSizeInBytes];
if ( conv.Init(m_Encoding, wxFONTENCODING_UNICODE)
&& conv.Convert((const char*)buffer, tmp) )
{
wideBuff = tmp;
outlen = size + 4 - m_BOMSizeInBytes; // should be correct, because Convert has returned true
if (m_UseLog && outlen>0)
{
logmsg.Printf(_T("Conversion succeeded using wxEncodingConverter "
"(buffer size = %lu, converted size = %lu."), static_cast<unsigned long>(size), static_cast<unsigned long>(outlen));
logmgr->DebugLog(logmsg);
}
}
else
{
// try wxCSConv, if nothing else works
wxCSConv csconv(m_Encoding);
if (csconv.IsOk())
{
wideBuff = csconv.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
if (m_UseLog && outlen>0)
{
logmsg.Printf(_T("Conversion succeeded using wxCSConv "
"(buffer size = %lu, converted size = %lu."), static_cast<unsigned long>(size), static_cast<unsigned long>(outlen));
logmgr->DebugLog(logmsg);
}
}
}
delete [] tmp;
}
if (outlen>0)
{
m_ConvStr = wxString(wideBuff);
return true; // Done.
}
// Here, outlen == 0, so an error occurred during conversion.
if (m_UseLog)
{
logmsg.Printf(_T("Encoding conversion using settings has failed!\n"
"Encoding chosen was: %s (ID: %d)"),
wxFontMapper::Get()->GetEncodingDescription(m_Encoding).wx_str(),
m_Encoding);
logmgr->DebugLog(logmsg);
}
// Try system locale as fall-back (if requested by the settings)
ConfigManager* cfgMgr = Manager::Get()->GetConfigManager(_T("editor"));
if (cfgMgr->ReadBool(_T("/default_encoding/use_system"), true))
{
if (platform::windows)
{
if (m_UseLog)
logmgr->DebugLog(_T("Trying system locale as fallback..."));
m_Encoding = wxLocale::GetSystemEncoding();
}
else
{
// We can rely on the UTF-8 detection code ;-)
if (m_UseLog)
logmgr->DebugLog(_T("Trying ISO-8859-1 as fallback..."));
m_Encoding = wxFONTENCODING_ISO8859_1;
}
wxCSConv conv_system(m_Encoding);
wideBuff = conv_system.cMB2WC((const char*)buffer, size + 4 - m_BOMSizeInBytes, &outlen);
m_ConvStr = wxString(wideBuff);
if (outlen == 0)
{
if (m_UseLog)
{
logmsg.Printf(_T("Encoding conversion using system locale fallback has failed!\n"
"Last encoding choosen was: %s (ID: %d)\n"
"Don't know what to do."),
wxFontMapper::Get()->GetEncodingDescription(m_Encoding).c_str(),
m_Encoding);
logmgr->DebugLog(logmsg);
}
return false; // Nothing we can do...
}
}
else
{
if (m_UseLog)
{
logmgr->DebugLog(_T("Encoding conversion has seriously failed!\n"
"Don't know what to do."));
}
return false; // Nothing we can do...
}
return true;
}
bool MSVC10Loader::Open(const wxString& filename)
{
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
m_ConvertSwitches = m_pProject->GetCompilerID().IsSameAs(_T("gcc"));
m_ProjectName = wxFileName(filename).GetName();
if (!MSVC7WorkspaceLoader::g_WorkspacePath.IsEmpty())
{
wxFileName tmp(MSVC7WorkspaceLoader::g_WorkspacePath); tmp.MakeRelativeTo(m_pProject->GetBasePath());
m_WorkspacePath = tmp.GetPathWithSep();
}
pMsg->DebugLog(F(_("Importing MSVC 10+ project: %s"), filename.wx_str()));
TiXmlDocument doc(filename.mb_str());
if (!doc.LoadFile())
return false;
pMsg->DebugLog(_("Parsing project file..."));
const TiXmlElement* root = doc.FirstChildElement("Project");
if (!root)
{
pMsg->DebugLog(_("Not a valid MS Visual Studio project file..."));
return false;
}
// initialisation of the project
m_pProject->ClearAllProperties();
m_pProject->SetModified(true);
if (!m_ConvertSwitches)
{
// m_pProject->AddCompilerOption(_T("/EHsc")); // default, "/EHs /EHc" works as well
m_pProject->AddLinkerOption(_T("/pdb:$(TARGET_OUTPUT_DIR)$(TARGET_OUTPUT_BASENAME).pdb"));
m_pProject->AddIncludeDir(_T(".")); // some projects require it. Implicit with Visual Studio
m_pProject->AddResourceIncludeDir(_T("."));
}
bool bResult = GetProjectGlobals(root) // get project name & type
&& GetProjectConfigurations(root); // get the project list of configuration => 1 configuration = 1 build target in CodeBlocks
if (!bResult)
{
pMsg->DebugLog(_("Could not obtain project configurations."));
return false;
}
if ( !DoSelectConfigurations() )
return true; // user cancelled
if ( !DoCreateConfigurations() )
{
pMsg->DebugLog(_("Failed to create configurations in the project."));
return false;
}
bResult = GetProjectConfigurationFiles(root) // get the project list of files and add them to the targets
&& GetProjectIncludes(root) // get the project/target list of includes and add them to the targets
&& GetTargetSpecific(root); // get the project/target specific settings
return bResult;
}
bool MSVC10Loader::GetTargetSpecific(const TiXmlElement* root)
{
if (!root) return false;
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
// parse all global parameters
const TiXmlElement* idef = root->FirstChildElement("ItemDefinitionGroup");
for (; idef; idef=idef->NextSiblingElement("ItemDefinitionGroup"))
{
const char* attr = idef->Attribute("Condition");
if (!attr) continue;
wxString conf = cbC2U(attr);
for (HashProjectsConfs::iterator it=m_pc.begin(); it!=m_pc.end(); ++it)
{
wxString sName = it->second.sName;
wxString sConf = SubstituteConfigMacros(conf);
if (sConf.IsSameAs(sName))
{
assert(m_pc[sName].bt);
if (!m_pc[sName].bt)
continue;
ProjectBuildTarget* bt = m_pc[sName].bt;
if (!m_ConvertSwitches && !m_pc[sName].Charset.IsEmpty())
{
if (m_pc[sName].Charset.IsSameAs(_T("NotSet"),false))
; // nop
else if (m_pc[sName].Charset.IsSameAs(_T("Unicode"),false))
bt->AddCompilerOption(_T("/D_UNICODE /DUNICODE"));
else if (m_pc[sName].Charset.IsSameAs(_T("MultiByte"),false))
bt->AddCompilerOption(_T("/D_MBCS"));
else
pMsg->DebugLog(_("Import; Unsupported CharacterSet: ") + m_pc[sName].Charset);
}
if (!m_pc[sName].sIntDir.IsEmpty())
bt->SetObjectOutput(m_pc[sName].sIntDir);
if (!m_pc[sName].sOutDir.IsEmpty())
{
bt->SetOutputFilename(m_pc[sName].sOutDir+m_pc[sName].sTargetName+m_pc[sName].sTargetExt);
bt->SetDepsOutput(m_pc[sName].sOutDir);
}
if (!m_pc[sName].sConf.IsEmpty())
{
if (m_pc[sName].sConf.IsSameAs(_T("Release"), false))
{
// nop
}
else if (m_pc[sName].sConf.IsSameAs(_T("Debug"),false))
bt->AddCompilerOption(!m_ConvertSwitches ? _T("/Zi") : _T("-g"));
else
pMsg->DebugLog(_("Import; Unsupported Configuration: ") + m_pc[sName].sConf);
}
if (m_pc[sName].bNoImportLib)
{
bt->SetCreateDefFile(false);
bt->SetCreateStaticLib(false);
}
const TiXmlElement* comp = idef->FirstChildElement("ClCompile");
if (comp)
{
const TiXmlElement* pp = comp->FirstChildElement("PreprocessorDefinitions");
wxArrayString pps = GetArray(pp);
for (size_t j=0; j<pps.Count(); ++j)
bt->AddCompilerOption((m_ConvertSwitches ? _T("-D") : _T("/D")) + pps.Item(j));
const TiXmlElement* cinc = comp->FirstChildElement("AdditionalIncludeDirectories");
wxArrayString cdirs = GetArrayPaths(cinc, m_pc[sName]);
for (size_t j=0; j<cdirs.Count(); ++j)
bt->AddIncludeDir(cdirs.Item(j));
const TiXmlElement* copt = comp->FirstChildElement("AdditionalOptions");
wxArrayString copts = GetArray(copt,_T(" "));
if (!m_ConvertSwitches)
{
for (size_t j=0; j<copts.Count(); ++j)
bt->AddCompilerOption(copts.Item(j));
}
if ((copt=comp->FirstChildElement("Optimization")))
{
wxString val = GetText(copt);
if (val.IsSameAs(_T("Disabled"),false))
bt->AddCompilerOption(!m_ConvertSwitches ? _T("/Od") : _T("-O0"));
else if (val.IsSameAs(_T("MinSpace"), false))
{
if (!m_ConvertSwitches) bt->AddCompilerOption(_T("/O1"));
else
{
bt->AddLinkerOption(_T("-s"));
bt->AddCompilerOption(_T("-Os"));
}
}
else if (val.IsSameAs(_T("MaxSpeed"),false))
{
if (!m_ConvertSwitches) bt->AddCompilerOption(_T("/O2"));
else
{
bt->AddLinkerOption(_T("-s"));
bt->AddCompilerOption(_T("-O1"));
}
}
else if (val.IsSameAs(_T("Full"),false))
{
if (!m_ConvertSwitches) bt->AddCompilerOption(_T("/Ox"));
else
{
bt->AddLinkerOption(_T("-s"));
bt->AddCompilerOption(_T("-O2"));
}
}
else
pMsg->DebugLog(_("Import; Unsupported Optimization: ") + val+_T("\n"));
}
if (!m_ConvertSwitches && (copt=comp->FirstChildElement("RuntimeLibrary")))
{
wxString val = GetText(copt);
if (val.IsSameAs(_T("MultiThreaded"),false))
bt->AddCompilerOption(_T("/MT"));
else if (val.IsSameAs(_T("MultiThreadedDebug"),false))
bt->AddCompilerOption(_T("/MTd"));
else if (val.IsSameAs(_T("MultiThreadedDll"),false))
bt->AddCompilerOption(_T("/MD"));
else if(val.IsSameAs(_T("MultiThreadedDebugDll"),false))
bt->AddCompilerOption(_T("/MDd"));
else
pMsg->DebugLog(_("Import; Unsupported RuntimeLibrary: ")+val);
}
if ((copt=comp->FirstChildElement("WarningLevel")))
{
wxString val = GetText(copt);
if (val.IsSameAs(_T("Level1"),false))
{ if (!m_ConvertSwitches) bt->AddCompilerOption(_T("/W1")); }
else if (val.IsSameAs(_T("Level2"),false))
bt->AddCompilerOption(!m_ConvertSwitches ? _T("/W2") : _T("-Wall"));
else if (val.IsSameAs(_T("Level3"),false))
bt->AddCompilerOption(!m_ConvertSwitches ? _T("/W3") : _T("-Wall"));
else if (val.IsSameAs(_T("Level4"),false))
{
if (!m_ConvertSwitches) bt->AddCompilerOption(_T("/W4"));
else
{
bt->AddCompilerOption(_T("-Wall"));
bt->AddCompilerOption(_T("-Wextra"));
}
}
else
pMsg->DebugLog(_("Import; Unsupported WarningLevel: ") + val);
}
if (!m_ConvertSwitches && (copt=comp->FirstChildElement("DisableSpecificWarnings")))
{
wxArrayString warns = GetArray(copt);
for (size_t j=0; j<warns.Count(); ++j)
bt->AddCompilerOption(_T("/wd") + warns.Item(j));
}
}
const TiXmlElement* res = idef->FirstChildElement("ResourceCompile");
if (res)
{
const TiXmlElement* pp = res->FirstChildElement("PreprocessorDefinitions");
wxArrayString pps = GetArray(pp);
for (size_t j=0; j<pps.Count(); ++j)
bt->AddCompilerOption((m_ConvertSwitches ? _T("-D") : _T("/D")) + pps.Item(j));
const TiXmlElement* cinc = res->FirstChildElement("AdditionalIncludeDirectories");
wxArrayString cdirs = GetArrayPaths(cinc,m_pc[sName]);
for (size_t j=0; j<cdirs.Count(); ++j)
bt->AddResourceIncludeDir(cdirs.Item(j));
const TiXmlElement* copt = res->FirstChildElement("AdditionalOptions");
wxArrayString copts = GetArray(copt,_T(" "));
if (!m_ConvertSwitches)
{
for (size_t j=0; j<copts.Count(); ++j)
bt->AddCompilerOption(copts.Item(j));
}
}
const TiXmlElement* link = idef->FirstChildElement("Link");
if (link)
{
const TiXmlElement* copt;
if ((copt=link->FirstChildElement("OutputFile")))
{
wxString val = GetText(copt);
ReplaceConfigMacros(m_pc[sName],val);
if (!val.IsEmpty())
bt->SetOutputFilename(val);
}
if ((copt=link->FirstChildElement("ModuleDefinitionFile")))
{
wxString val = GetText(copt);
ReplaceConfigMacros(m_pc[sName],val);
if (!val.IsEmpty())
bt->SetDefinitionFileFilename(val);
}
if ((copt=link->FirstChildElement("ImportLibrary")))
{
wxString val=GetText(copt);
ReplaceConfigMacros(m_pc[sName],val);
if (!val.IsEmpty())
bt->SetImportLibraryFilename(val);
}
copt = link->FirstChildElement("AdditionalDependencies");
wxArrayString libs = GetLibs(copt);
for (size_t j=0; j<libs.Count(); ++j)
bt->AddLinkLib(libs.Item(j));
copt = link->FirstChildElement("AdditionalLibraryDirectories"); /// @note : maybe use loops on all elements
for (; copt; copt=copt->NextSiblingElement("AdditionalLibraryDirectories"))
{
wxArrayString ldirs = GetArrayPaths(copt,m_pc[sName]);
for (size_t j=0; j<ldirs.Count(); ++j)
bt->AddLibDir(ldirs.Item(j));
}
if (!m_ConvertSwitches)
{
copt = link->FirstChildElement("AdditionalOptions");
wxArrayString lopts = GetArray(copt,_T(" "));
for (size_t j=0; j<lopts.Count(); ++j)
bt->AddLinkerOption(lopts.Item(j));
copt = link->FirstChildElement("GenerateDebugInformation");
wxString sDebug = GetText(copt);
if (sDebug.IsSameAs(_T("true"),false))
bt->AddLinkerOption(_T("/debug"));
}
}
const TiXmlElement* event;
if ((event=idef->FirstChildElement("PreBuildEvent")))
{
const TiXmlElement* copt=event->FirstChildElement("Command");
for (; copt; copt=copt->NextSiblingElement("Command"))
{
wxString cmd = UnixFilename(GetText(copt));
ReplaceConfigMacros(m_pc[sName],cmd);
if (!cmd.IsEmpty()) bt->AddCommandsBeforeBuild(cmd);
}
}
if ((event=idef->FirstChildElement("PostBuildEvent")))
{
const TiXmlElement* copt = event->FirstChildElement("Command");
for (; copt; copt=copt->NextSiblingElement("Command"))
{
wxString cmd=UnixFilename(GetText(copt));
ReplaceConfigMacros(m_pc[sName],cmd);
if (!cmd.IsEmpty()) bt->AddCommandsAfterBuild(cmd);
}
}
bResult = true; // got something
}
}
}
if (!bResult)
pMsg->DebugLog(_("Failed to find any includes in the project...?!"));
return bResult;
}
bool ProjectLayoutLoader::Open(const wxString& filename)
{
TiXmlDocument doc;
if (!TinyXML::LoadDocument(filename, &doc))
return false;
ProjectManager* pMan = Manager::Get()->GetProjectManager();
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMan || !pMsg)
return false;
TiXmlElement* root;
TiXmlElement* elem;
wxString fname;
ProjectFile* pf;
root = doc.FirstChildElement("CodeBlocks_layout_file");
if (!root)
{
// old tag
root = doc.FirstChildElement("Code::Blocks_layout_file");
if (!root)
{
pMsg->DebugLog(_T("Not a valid Code::Blocks layout file..."));
return false;
}
}
int major = 0;
int minor = 0;
TiXmlElement* version = root->FirstChildElement("FileVersion");
// don't show messages if we 're running a batch build (i.e. no gui)
if (!Manager::IsBatchBuild() && version)
{
version->QueryIntAttribute("major", &major);
version->QueryIntAttribute("minor", &minor);
if (major >= PROJECT_LAYOUT_FILE_VERSION_MAJOR && minor > PROJECT_LAYOUT_FILE_VERSION_MINOR)
{
pMsg->DebugLog(F(_T("Project layout file version is > %d.%d. Trying to load..."), PROJECT_LAYOUT_FILE_VERSION_MAJOR, PROJECT_LAYOUT_FILE_VERSION_MINOR));
AnnoyingDialog dlg(_("Project layout file format is newer/unknown"),
F(_("This project layout file was saved with a newer version of Code::Blocks.\n"
"Will try to load, but you might see unexpected results.\n"
"In this case close the project, delete %s and reopen the project."),filename.wx_str()),
wxART_WARNING,
AnnoyingDialog::OK);
dlg.ShowModal();
}
else
{
// use one message for all changes
wxString msg;
wxString warn_msg;
if (major == 0 && minor == 0)
{
msg << _("0.0 (unversioned) to 1.0:\n");
msg << _(" * save editor-pane layout and order.\n");
msg << _("\n");
}
if (!msg.IsEmpty())
{
msg.Prepend(wxString::Format(_("Project layout file format is older (%d.%d) than the current format (%d.%d).\n"
"The file will automatically be upgraded on close.\n"
"But please read the following list of changes, as some of them\n"
"might not automatically convert existing (old) settings.\n"
"If you don't understand what a change means, you probably don't\n"
"use that feature so you don't have to worry about it.\n\n"
"List of changes:\n"),
major,
minor,
PROJECT_LAYOUT_FILE_VERSION_MAJOR,
PROJECT_LAYOUT_FILE_VERSION_MINOR));
AnnoyingDialog dlg(_("Project layout file format changed"),
msg,
wxART_INFORMATION,
AnnoyingDialog::OK);
dlg.ShowModal();
}
if (!warn_msg.IsEmpty())
{
warn_msg.Prepend(_("!!! WARNING !!!\n\n"));
AnnoyingDialog dlg(_("Project layout file upgrade warning"),
warn_msg,
wxART_WARNING,
AnnoyingDialog::OK);
dlg.ShowModal();
}
}
}
elem = root->FirstChildElement("ActiveTarget");
if (elem)
{
if (elem->Attribute("name"))
m_pProject->SetActiveBuildTarget(cbC2U(elem->Attribute("name")));
}
elem = root->FirstChildElement("File");
if (!elem)
{
//pMsg->DebugLog(_T("No 'File' element in file..."));
return false;
}
while (elem)
{
//pMsg->DebugLog(elem->Value());
fname = cbC2U(elem->Attribute("name"));
if (fname.IsEmpty())
{
//pMsg->DebugLog(_T("'File' node exists, but no filename?!?"));
pf = nullptr;
}
else
pf = m_pProject->GetFileByFilename(fname);
if (pf)
{
pf->editorOpen = false;
pf->editorSplit = cbEditor::stNoSplit;
pf->editorSplitActive = 1;
pf->editorZoom = 0;
pf->editorPos = 0;
pf->editorTopLine = 0;
pf->editorZoom_2 = 0;
pf->editorPos_2 = 0;
pf->editorTopLine_2 = 0;
int getInt = 0; // used to fetch int values
if (elem->QueryIntAttribute("open", &getInt) == TIXML_SUCCESS)
pf->editorOpen = getInt != 0;
if (elem->QueryIntAttribute("top", &getInt) == TIXML_SUCCESS)
{
if (getInt)
m_TopProjectFile = pf;
}
if (elem->QueryIntAttribute("tabpos", &getInt) == TIXML_SUCCESS)
pf->editorTabPos = getInt;
if (elem->QueryIntAttribute("split", &getInt) == TIXML_SUCCESS)
pf->editorSplit = getInt;
if (elem->QueryIntAttribute("active", &getInt) == TIXML_SUCCESS)
pf->editorSplitActive = getInt;
if (elem->QueryIntAttribute("splitpos", &getInt) == TIXML_SUCCESS)
pf->editorSplitPos = getInt;
if (elem->QueryIntAttribute("zoom_1", &getInt) == TIXML_SUCCESS)
pf->editorZoom = getInt;
if (elem->QueryIntAttribute("zoom_2", &getInt) == TIXML_SUCCESS)
pf->editorZoom_2 = getInt;
TiXmlElement* cursor = elem->FirstChildElement("Cursor");
if (cursor)
{
cursor = cursor->FirstChildElement();
if (cursor)
{
if (cursor->QueryIntAttribute("position", &getInt) == TIXML_SUCCESS)
pf->editorPos = getInt;
if (cursor->QueryIntAttribute("topLine", &getInt) == TIXML_SUCCESS)
pf->editorTopLine = getInt;
if (pf->editorSplit != cbEditor::stNoSplit)
{
cursor = cursor->NextSiblingElement();
if (cursor)
{
if (cursor->QueryIntAttribute("position", &getInt) == TIXML_SUCCESS)
pf->editorPos_2 = getInt;
if (cursor->QueryIntAttribute("topLine", &getInt) == TIXML_SUCCESS)
pf->editorTopLine_2 = getInt;
}
}
}
}
TiXmlElement* folding = elem->FirstChildElement("Folding");
if (folding)
{
folding = folding->FirstChildElement();
while (folding)
{
if (folding->QueryIntAttribute("line", &getInt) == TIXML_SUCCESS)
pf->editorFoldLinesArray.Add(getInt);
folding = folding->NextSiblingElement();
}
}
}
elem = elem->NextSiblingElement();
}
if ( (major >= 1)
&& (Manager::Get()->GetConfigManager(_T("app"))->ReadBool(_T("/environment/enable_editor_layout"), false)) )
{
elem = root->FirstChildElement("EditorTabsLayout");
if (elem)
m_NotebookLayout = cbC2U(elem->Attribute("layout"));
}
return true;
}
bool MSVC10Loader::GetProjectConfigurations(const TiXmlElement* root)
{
// delete all targets of the project (we'll create new ones from the imported configurations)
while (m_pProject && m_pProject->GetBuildTargetsCount())
m_pProject->RemoveBuildTarget(0);
if (!root) return false;
LogManager* pMsg = Manager::Get()->GetLogManager();
if (!pMsg) return false;
bool bResult = false;
// first we try to get the list of configurations : there is normally a specific chapter for that
// this is not truly necessary, but it is cleaner like that:
// the plugin will be easier to understand, and easier to extend if necessary
const TiXmlElement* prop = root->FirstChildElement("ItemGroup");
for (; prop; prop=prop->NextSiblingElement("ItemGroup"))
{
const char* attr = prop->Attribute("Label");
if (!attr) continue;
wxString label = cbC2U(attr);
if (label.IsSameAs(_T("ProjectConfigurations"),false))
{
const TiXmlElement* conf = prop->FirstChildElement("ProjectConfiguration");
for (; conf; conf=conf->NextSiblingElement("ProjectConfiguration"))
{
// loop over all the configurations
const char* name = conf->Attribute("Include");
const TiXmlElement* cfg = conf->FirstChildElement("Configuration");
const TiXmlElement* plat = conf->FirstChildElement("Platform");
if (name && cfg && plat)
{
SProjectConfiguration pc;
pc.bt = NULL;
// ProjectConfiguration
pc.sName = cbC2U(name); pc.sName.Replace(_T("|"), _T(" "));
pc.sConf = GetText(cfg);
pc.sPlatform = GetText(plat);
// PropertyGroup
pc.TargetType = _T("Application");
// pc.UseDebugLibs = _T("true");
pc.Charset = _T("NotSet");
pc.bIsDefault = false;
pc.bNoImportLib = -1; // unset, use global
m_pc[pc.sName] = pc;
pMsg->DebugLog(_("Found project configuration: ") + pc.sName);
bResult = true;
}
}
}
}
if (!bResult)
{
pMsg->DebugLog(_("Failed to find project configurations."));
return false;
}
// now that we have (in theory) the list of configurations, we will parse each configuration
bResult = GetConfiguration(root);
// set empty values to default value and replace macros
for (HashProjectsConfs::iterator it=m_pc.begin(); it!=m_pc.end(); ++it)
{
SProjectConfiguration& pc = it->second;
if (pc.sOutDir.IsEmpty()) pc.sOutDir = m_OutDir.IsEmpty() ? wxString(_T("$(SolutionDir)$(Configuration)"))+wxFILE_SEP_PATH : m_OutDir;
if (pc.sIntDir.IsEmpty()) pc.sIntDir = m_IntDir.IsEmpty() ? wxString(_T("$(Configuration)"))+wxFILE_SEP_PATH : m_IntDir;
if (pc.sTargetName.IsEmpty()) pc.sTargetName = _T("$(ProjectName)");
if (pc.sTargetExt.IsEmpty())
{
if (pc.TargetType.IsSameAs(_T("DynamicLibrary"), false))
pc.sTargetExt =! m_ConvertSwitches ? _T(".dll") : _T(".so");
else if (pc.TargetType.IsSameAs(_T("StaticLibrary"), false))
pc.sTargetExt =! m_ConvertSwitches ? _T(".lib") : _T(".a");
else
pc.sTargetExt =! m_ConvertSwitches ? _T(".exe") : _T("");
}
if (pc.bNoImportLib==-1)
pc.bNoImportLib=m_NoImportLib;
// if (pc.sExePath.IsEmpty())
// pc.sExePath=_T("");
// if (pc.sSourcePath.IsEmpty())
// pc.sSourcePath=_T("");
ReplaceConfigMacros(pc, pc.sOutDir);
ReplaceConfigMacros(pc, pc.sIntDir);
ReplaceConfigMacros(pc, pc.sTargetName);
// crap (currently useless, probably never needed)
ReplaceConfigMacros(pc, pc.sExePath);
ReplaceConfigMacros(pc, pc.sSourcePath);
}
m_pProject->SetTitle(m_ProjectName);
return true;
}
