void
CMakeProjectSettingsPanel::SetSettings(CMakeProjectSettings* settings, const wxString& project, const wxString& config)
{
// Remove old projects
m_choiceParent->Clear();
// Get all available projects
wxArrayString projects;
m_plugin->GetManager()->GetWorkspace()->GetProjectList(projects);
// Get build matrix
// Required for translation between current config and other projects' configs.
BuildMatrixPtr matrix = m_plugin->GetManager()->GetWorkspace()->GetBuildMatrix();
// We have to find name of workspace configuration by project name and selected config
// Name of workspace config
const wxString workspaceConfig = FindWorkspaceConfig(
matrix->GetConfigurations(), project, config
);
// Foreach projects
for (wxArrayString::const_iterator it = projects.begin(),
ite = projects.end(); it != ite; ++it) {
// Translate project config
const wxString projectConfig = matrix->GetProjectSelectedConf(workspaceConfig, *it);
const CMakeSettingsManager* mgr = m_plugin->GetSettingsManager();
wxASSERT(mgr);
const CMakeProjectSettings* projectSettings = mgr->GetProjectSettings(*it, projectConfig);
const bool append =
projectSettings &&
projectSettings->enabled &&
projectSettings != settings &&
projectSettings->parentProject.IsEmpty()
;
// Add project if CMake is enabled for it
if (append)
m_choiceParent->Append(*it);
}
m_settings = settings;
LoadSettings();
}
void WorkspaceTab::DoWorkspaceConfig()
{
// Update the workspace configuration
BuildMatrixPtr matrix = WorkspaceST::Get()->GetBuildMatrix();
std::list<WorkspaceConfigurationPtr> confs = matrix->GetConfigurations();
m_workspaceConfig->Freeze();
m_workspaceConfig->Enable(true);
m_workspaceConfig->Clear();
for (std::list<WorkspaceConfigurationPtr>::iterator iter = confs.begin() ; iter != confs.end(); iter++) {
m_workspaceConfig->Append((*iter)->GetName());
}
if (m_workspaceConfig->GetCount() > 0) {
m_workspaceConfig->SetStringSelection(matrix->GetSelectedConfigurationName());
}
m_workspaceConfig->Append(OPEN_CONFIG_MGR_STR);
m_workspaceConfig->Thaw();
clMainFrame::Get()->SelectBestEnvSet();
}
void WorkspaceTab::OpenProjectSettings(const wxString& project)
{
if ( m_dlg ) {
m_dlg->Raise();
return;
}
wxString projectName = project.IsEmpty() ? ManagerST::Get()->GetActiveProjectName() : project;
wxString title( projectName );
title << _( " Project Settings" );
// Allow plugins to process this event first
clCommandEvent openEvent(wxEVT_CMD_OPEN_PROJ_SETTINGS);
openEvent.SetString( project );
if ( EventNotifier::Get()->ProcessEvent( openEvent ) ) {
return;
}
//open the project properties dialog
BuildMatrixPtr matrix = ManagerST::Get()->GetWorkspaceBuildMatrix();
#ifdef __WXMAC__
// On OSX we use a modal version of the project settings
// since otherwise we get some weird focus issues when the project
// settings dialog popups helper dialogs
ProjectSettingsDlg dlg( clMainFrame::Get(), this, matrix->GetProjectSelectedConf( matrix->GetSelectedConfigurationName(), projectName ), projectName, title );
dlg.ShowModal();
#else
// Find the project configuration name that matches the workspace selected configuration
m_dlg = new ProjectSettingsDlg( clMainFrame::Get(), this, matrix->GetProjectSelectedConf( matrix->GetSelectedConfigurationName(), projectName ), projectName, title );
m_dlg->Show();
#endif
// Mark this project as modified
ProjectPtr proj = ManagerST::Get()->GetProject(projectName);
if (proj) {
proj->SetModified(true);
}
}
void WorkspaceTab::OnConfigurationManagerChoice(wxCommandEvent& e)
{
wxString selection = m_workspaceConfig->GetStringSelection();
if(selection == OPEN_CONFIG_MGR_STR) {
wxCommandEvent e(wxEVT_COMMAND_MENU_SELECTED, XRCID("configuration_manager"));
e.SetEventObject(this);
ProcessEvent(e);
return;
}
BuildMatrixPtr matrix = ManagerST::Get()->GetWorkspaceBuildMatrix();
matrix->SetSelectedConfigurationName(selection);
ManagerST::Get()->SetWorkspaceBuildMatrix(matrix);
// Set the focus to the active editor if any
LEditor *editor = clMainFrame::Get()->GetMainBook()->GetActiveEditor();
if(editor)
editor->SetActive();
ManagerST::Get()->UpdateParserPaths(true);
}
void ConfigurationManagerDlg::LoadProjectConfiguration(const wxString &projectName)
{
std::map<int, ConfigEntry>::iterator iter = m_projSettingsMap.begin();
for (; iter != m_projSettingsMap.end(); iter++) {
if (iter->second.project == projectName) {
iter->second.choiceControl->Clear();
ProjectSettingsPtr proSet = ManagerST::Get()->GetProjectSettings(projectName);
if (proSet) {
ProjectSettingsCookie cookie;
BuildConfigPtr bldConf = proSet->GetFirstBuildConfiguration(cookie);
while (bldConf) {
iter->second.choiceControl->Append(bldConf->GetName());
bldConf = proSet->GetNextBuildConfiguration(cookie);
}
//append the EDIT & NEW commands
iter->second.choiceControl->Append(clCMD_EDIT);
iter->second.choiceControl->Append(clCMD_NEW);
//select the build configuration according to the build matrix
BuildMatrixPtr matrix = ManagerST::Get()->GetWorkspaceBuildMatrix();
if (!matrix) {
return;
}
wxString configName = matrix->GetProjectSelectedConf(m_choiceConfigurations->GetStringSelection(), projectName);
int match = iter->second.choiceControl->FindString(configName);
if (match != wxNOT_FOUND) {
iter->second.choiceControl->SetStringSelection(configName);
} else {
iter->second.choiceControl->SetSelection(0);
}
return;
}
}
}
}
void ConfigurationManagerDlg::OnButtonNew(wxCommandEvent &event)
{
wxUnusedVar(event);
wxTextEntryDialog *dlg = new wxTextEntryDialog(this, wxT("Enter New Configuration Name:"), wxT("New Configuration"));
if (dlg->ShowModal() == wxID_OK) {
wxString value = dlg->GetValue();
TrimString(value);
if (value.IsEmpty() == false) {
BuildMatrixPtr matrix = ManagerST::Get()->GetWorkspaceBuildMatrix();
if (!matrix) {
return;
}
CSolitionConfigurationPtr conf(new CSolitionConfiguration(NULL));
conf->SetName(value);
conf->SetConfigMappingList(GetCurrentSettings());
matrix->SetConfiguration(conf);
//save changes
ManagerST::Get()->SetWorkspaceBuildMatrix(matrix);
}
}
PopulateConfigurations();
dlg->Destroy();
}
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();
}
wxArrayString PluginManager::GetProjectCompileFlags(const wxString& projectName, bool isCppFile)
{
if(IsWorkspaceOpen() == false) return wxArrayString();
wxArrayString args;
// Next apppend the user include paths
wxString errMsg;
// First, we need to find the currently active workspace configuration
BuildMatrixPtr matrix = GetWorkspace()->GetBuildMatrix();
if(!matrix) {
return wxArrayString();
}
wxString workspaceSelConf = matrix->GetSelectedConfigurationName();
// Now that we got the selected workspace configuration, extract the related project configuration
ProjectPtr proj = GetWorkspace()->FindProjectByName(projectName, errMsg);
if(!proj) {
return args;
}
wxString projectSelConf = matrix->GetProjectSelectedConf(workspaceSelConf, proj->GetName());
BuildConfigPtr dependProjbldConf = GetWorkspace()->GetProjBuildConf(proj->GetName(), projectSelConf);
if(dependProjbldConf && dependProjbldConf->IsCustomBuild() == false) {
// Get the include paths and add them
wxString projectIncludePaths = dependProjbldConf->GetIncludePath();
wxArrayString projectIncludePathsArr = wxStringTokenize(projectIncludePaths, wxT(";"), wxTOKEN_STRTOK);
for(size_t i = 0; i < projectIncludePathsArr.GetCount(); i++) {
args.Add(wxString::Format(wxT("-I%s"), projectIncludePathsArr[i].c_str()));
}
// get the compiler options and add them
wxString projectCompileOptions = dependProjbldConf->GetCompileOptions();
wxArrayString projectCompileOptionsArr = wxStringTokenize(projectCompileOptions, wxT(";"), wxTOKEN_STRTOK);
for(size_t i = 0; i < projectCompileOptionsArr.GetCount(); i++) {
wxString cmpOption(projectCompileOptionsArr.Item(i));
cmpOption.Trim().Trim(false);
wxString tmp;
// Expand backticks / $(shell ...) syntax supported by codelite
if(cmpOption.StartsWith(wxT("$(shell "), &tmp) || cmpOption.StartsWith(wxT("`"), &tmp)) {
cmpOption = tmp;
tmp.Clear();
if(cmpOption.EndsWith(wxT(")"), &tmp) || cmpOption.EndsWith(wxT("`"), &tmp)) {
cmpOption = tmp;
}
if(m_backticks.find(cmpOption) == m_backticks.end()) {
// Expand the backticks into their value
wxArrayString outArr;
// Apply the environment before executing the command
EnvSetter setter(EnvironmentConfig::Instance(), NULL, projectName);
ProcUtils::SafeExecuteCommand(cmpOption, outArr);
wxString expandedValue;
for(size_t j = 0; j < outArr.size(); j++) {
expandedValue << outArr.Item(j) << wxT(" ");
}
m_backticks[cmpOption] = expandedValue;
cmpOption = expandedValue;
} else {
cmpOption = m_backticks.find(cmpOption)->second;
}
}
args.Add(cmpOption);
}
// get the compiler preprocessor and add them as well
wxString projectPreps = dependProjbldConf->GetPreprocessor();
wxArrayString projectPrepsArr = wxStringTokenize(projectPreps, wxT(";"), wxTOKEN_STRTOK);
for(size_t i = 0; i < projectPrepsArr.GetCount(); i++) {
args.Add(wxString::Format(wxT("-D%s"), projectPrepsArr[i].c_str()));
}
}
return args;
}
void OutputPane::OnBuildWindowDClick(const wxString &line, int lineno)
{
wxString fileName, strLineNumber;
bool match = false;
//get the selected compiler for the current line that was DClicked
if(lineno >= (int)m_buildLineInfo.GetCount()){
return;
}
//find the project selected build configuration for the workspace selected
//configuration
wxString projectName = m_buildLineInfo.Item(lineno);
if(projectName.IsEmpty())
return;
BuildMatrixPtr matrix = ManagerST::Get()->GetWorkspaceBuildMatrix();
wxString projecBuildConf = matrix->GetProjectSelectedConf(matrix->GetSelectedConfigurationName(),
projectName );
ProjectSettingsPtr settings = ManagerST::Get()->GetProject(projectName)->GetSettings();
if(!settings)
{
return;
}
BuildConfigPtr bldConf = settings->GetBuildConfiguration(projecBuildConf);
if( !bldConf )
{
return;
}
wxString cmpType = bldConf->GetCompilerType();
CompilerPtr cmp = BuildSettingsConfigST::Get()->GetCompiler(cmpType);
if( !cmp )
{
return;
}
long idx;
//try to match an error pattern to the line
RegexProcessor re(cmp->GetErrPattern());
cmp->GetErrFileNameIndex().ToLong(&idx);
if(re.GetGroup(line, idx, fileName))
{
//we found the file name, get the line number
cmp->GetErrLineNumberIndex().ToLong(&idx);
re.GetGroup(line, idx, strLineNumber);
match = true;
}
//try to match warning pattern
if(!match)
{
RegexProcessor re(cmp->GetWarnPattern());
cmp->GetWarnFileNameIndex().ToLong(&idx);
if(re.GetGroup(line, idx, fileName))
{
//we found the file name, get the line number
cmp->GetWarnLineNumberIndex().ToLong(&idx);
re.GetGroup(line, idx, strLineNumber);
match = true;
}
}
if(match)
{
long lineNumber = -1;
strLineNumber.ToLong(&lineNumber);
// open the file in the editor
// get the project name that is currently being built
wxString projName(wxEmptyString);
if(lineno < (int)m_buildLineInfo.GetCount())
{
projName = m_buildLineInfo.Item(lineno);
}
// if no project found, dont do anything
if(projName.IsEmpty())
{
return;
}
DirSaver ds;
ProjectPtr pro = ManagerST::Get()->GetProject(projName);
::wxSetWorkingDirectory(pro->GetFileName().GetPath());
wxFileName fn(fileName);
fn.MakeAbsolute(pro->GetFileName().GetPath());
ManagerST::Get()->OpenFile(fn.GetFullPath(), projName, lineNumber - 1 );
}
}
void clCxxWorkspace::AddProjectToBuildMatrix(ProjectPtr prj)
{
if(!prj) {
wxMessageBox(_("AddProjectToBuildMatrix was called with NULL project"), _("CodeLite"), wxICON_WARNING | wxOK);
return;
}
BuildMatrixPtr matrix = GetBuildMatrix();
wxString selConfName = matrix->GetSelectedConfigurationName();
std::list<WorkspaceConfigurationPtr> wspList = matrix->GetConfigurations();
std::list<WorkspaceConfigurationPtr>::iterator iter = wspList.begin();
for(; iter != wspList.end(); iter++) {
WorkspaceConfigurationPtr workspaceConfig = (*iter);
WorkspaceConfiguration::ConfigMappingList prjList = workspaceConfig->GetMapping();
wxString wspCnfName = workspaceConfig->GetName();
ProjectSettingsCookie cookie;
// getSettings is a bit misleading, since it actually create new instance which represents the layout
// of the XML
ProjectSettingsPtr settings = prj->GetSettings();
BuildConfigPtr prjBldConf = settings->GetFirstBuildConfiguration(cookie);
BuildConfigPtr matchConf;
if(!prjBldConf) {
// the project does not have any settings, create new one and add it
prj->SetSettings(settings);
settings = prj->GetSettings();
prjBldConf = settings->GetFirstBuildConfiguration(cookie);
matchConf = prjBldConf;
} else {
matchConf = prjBldConf;
// try to locate the best match to add to the workspace
while(prjBldConf) {
wxString projBldConfName = prjBldConf->GetName();
if(wspCnfName == projBldConfName) {
// we found a suitable match use it instead of the default one
matchConf = prjBldConf;
break;
}
prjBldConf = settings->GetNextBuildConfiguration(cookie);
}
}
ConfigMappingEntry entry(prj->GetName(), matchConf->GetName());
prjList.push_back(entry);
(*iter)->SetConfigMappingList(prjList);
matrix->SetConfiguration((*iter));
}
// and set the configuration name
matrix->SetSelectedConfigurationName(selConfName);
// this will also reset the build matrix pointer
SetBuildMatrix(matrix);
}
void CallGraph::OnShowCallGraph(wxCommandEvent& event)
{
// myLog("wxThread::IsMain(%d)", (int)wxThread::IsMain());
IConfigTool *config_tool = m_mgr->GetConfigTool();
config_tool->ReadObject(wxT("CallGraph"), &confData);
if (!wxFileExists(GetGprofPath()) || !wxFileExists(GetDotPath()))
return MessageBox(_T("Failed to locate required tools (gprof, dot). Please check the plugin settings."), wxICON_ERROR);
Workspace *ws = m_mgr->GetWorkspace();
if (!ws) return MessageBox(_("Unable to get opened workspace."), wxICON_ERROR);
wxFileName ws_cfn = ws->GetWorkspaceFileName();
wxString projectName = ws->GetActiveProjectName();
BuildMatrixPtr mtx = ws->GetBuildMatrix();
if (!mtx) return MessageBox(_("Unable to get current build matrix."), wxICON_ERROR);
wxString build_config_name = mtx->GetSelectedConfigurationName();
BuildConfigPtr bldConf = ws->GetProjBuildConf(projectName, build_config_name);
if (!bldConf) return MessageBox(_("Unable to get opened workspace."), wxICON_ERROR);
wxString projOutputFn = bldConf->GetOutputFileName();
wxString projWorkingDir = bldConf->GetWorkingDirectory();
/*
myLog("WorkspaceFileName = \"%s\"", ws_cfn.GetFullPath());
myLog("projectName \"%s\"", projectName);
myLog("build_config_name = \"%s\"", build_config_name);
myLog("projOutputFn = \"%s\"", projOutputFn);
myLog("projWorkingDir = \"%s\"", projWorkingDir);
*/
wxFileName cfn(ws_cfn.GetPath(), projOutputFn);
cfn.Normalize();
// base path
const wxString base_path = ws_cfn.GetPath();
// check source binary exists
wxString bin_fpath = cfn.GetFullPath();
if (!cfn.Exists()) {
bin_fpath = wxFileSelector("Please select the binary to analyze", base_path, "", "");
if (bin_fpath.IsEmpty()) return MessageBox("selected binary was canceled", wxICON_ERROR);
cfn.Assign(bin_fpath, wxPATH_NATIVE);
}
if (!cfn.IsFileExecutable()) return MessageBox("bin/exe isn't executable", wxICON_ERROR);
// check 'gmon.out' file exists
wxFileName gmon_cfn(base_path, GMON_FILENAME_OUT);
if (!gmon_cfn.Exists())
gmon_cfn.Normalize();
wxString gmonfn = gmon_cfn.GetFullPath();
if (!gmon_cfn.Exists()) {
gmonfn = wxFileSelector("Please select the gprof file", gmon_cfn.GetPath(), "gmon", "out");
if (gmonfn.IsEmpty()) return MessageBox("selected gprof was canceled", wxICON_ERROR);
gmon_cfn.Assign(gmonfn, wxPATH_NATIVE);
}
wxString bin, arg1, arg2;
bin = GetGprofPath();
arg1 = bin_fpath;
arg2 = gmonfn;
wxString cmdgprof = wxString::Format("%s %s %s", bin, arg1, arg2);
// myLog("about to wxExecute(\"%s\")", cmdgprof);
wxProcess *proc = new wxProcess(wxPROCESS_REDIRECT);
// wxStopWatch sw;
const int err = ::wxExecute(cmdgprof, wxEXEC_SYNC, proc);
// on sync returns 0 (success), -1 (failure / "couldn't be started")
// myLog("wxExecute() returned err %d, had pid %d", err, (int)proc->GetPid());
wxInputStream *process_is = proc->GetInputStream();
if (!process_is || !process_is->CanRead())
return MessageBox(_("wxProcess::GetInputStream() can't be opened, aborting"), wxICON_ERROR);
// start parsing and writing to dot language file
GprofParser pgp;
pgp.GprofParserStream(process_is);
// myLog("gprof done (read %d lines)", (int) pgp.lines.GetCount());
delete proc;
ConfCallGraph conf;
config_tool->ReadObject(wxT("CallGraph"), &conf);
DotWriter dotWriter;
// DotWriter
dotWriter.SetLineParser(&(pgp.lines));
int suggestedThreshold = pgp.GetSuggestedNodeThreshold();
if (suggestedThreshold <= conf.GetTresholdNode()) {
suggestedThreshold = conf.GetTresholdNode();
dotWriter.SetDotWriterFromDialogSettings(m_mgr);
} else {
dotWriter.SetDotWriterFromDetails(conf.GetColorsNode(),
conf.GetColorsEdge(),
suggestedThreshold,
conf.GetTresholdEdge(),
conf.GetHideParams(),
conf.GetStripParams(),
conf.GetHideNamespaces());
wxString suggest_msg = wxString::Format(_("The CallGraph plugin has suggested node threshold %d to speed-up the call graph creation. You can alter it on the call graph panel."), suggestedThreshold);
MessageBox(suggest_msg, wxICON_INFORMATION);
}
dotWriter.WriteToDotLanguage();
// build output dir
cfn.Assign(base_path, "");
cfn.AppendDir(CALLGRAPH_DIR);
cfn.Normalize();
if (!cfn.DirExists()) cfn.Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
cfn.SetFullName(DOT_FILENAME_TXT);
wxString dot_fn = cfn.GetFullPath();
dotWriter.SendToDotAppOutputDirectory(dot_fn);
cfn.SetFullName(DOT_FILENAME_PNG);
wxString output_png_fn = cfn.GetFullPath();
// delete any existing PNG
if (wxFileExists(output_png_fn)) wxRemoveFile(output_png_fn);
wxString cmddot_ln;
cmddot_ln << GetDotPath() << " -Tpng -o" << output_png_fn << " " << dot_fn;
// myLog("wxExecute(\"%s\")", cmddot_ln);
wxExecute(cmddot_ln, wxEXEC_SYNC);
// myLog("dot done");
if (!wxFileExists(output_png_fn))
return MessageBox(_("Failed to open file CallGraph.png. Please check the project settings, rebuild the project and try again."), wxICON_INFORMATION);
// show image and create table in the editor tab page
uicallgraphpanel *panel = new uicallgraphpanel(m_mgr->GetEditorPaneNotebook(), m_mgr, output_png_fn, base_path, suggestedThreshold, &(pgp.lines));
wxString tstamp = wxDateTime::Now().Format(wxT(" %Y-%m-%d %H:%M:%S"));
wxString title = wxT("Call graph for \"") + output_png_fn + wxT("\" " + tstamp);
m_mgr->AddEditorPage(panel, title);
}
bool WSImporter::Import(wxString& errMsg)
{
wxString compileName = defaultCompiler.Lower();
bool isGccCompile = compileName.Contains(wxT("gnu")) || compileName.Contains(wxT("gcc")) ||
compileName.Contains(wxT("g++")) || compileName.Contains(wxT("mingw"));
for(std::shared_ptr<GenericImporter> importer : importers) {
if(importer->OpenWordspace(filename, defaultCompiler)) {
if(importer->isSupportedWorkspace()) {
GenericWorkspacePtr gworskspace = importer->PerformImport();
wxString errMsgLocal;
bool showDlg = true;
if(!clCxxWorkspaceST::Get()->CreateWorkspace(gworskspace->name, gworskspace->path, errMsgLocal))
return false;
clCxxWorkspace* clWorkspace = NULL;
WorkspaceConfiguration::ConfigMappingList cmlDebug;
WorkspaceConfiguration::ConfigMappingList cmlRelease;
for(GenericProjectPtr project : gworskspace->projects) {
GenericCfgType cfgType = project->cfgType;
wxString projectType, errMsg;
switch(cfgType) {
case GenericCfgType::DYNAMIC_LIBRARY:
projectType = Project::DYNAMIC_LIBRARY;
break;
case GenericCfgType::STATIC_LIBRARY:
projectType = Project::STATIC_LIBRARY;
break;
case GenericCfgType::EXECUTABLE:
default:
projectType = Project::EXECUTABLE;
break;
}
if(!clCxxWorkspaceST::Get()->CreateProject(project->name, project->path, projectType, true, errMsg))
return false;
ProjectPtr proj = clCxxWorkspaceST::Get()->FindProjectByName(project->name, errMsg);
ProjectSettingsPtr le_settings(new ProjectSettings(NULL));
le_settings->RemoveConfiguration(wxT("Debug"));
le_settings->SetProjectType(projectType);
if(clWorkspace == NULL)
clWorkspace = proj->GetWorkspace();
for(GenericProjectCfgPtr cfg : project->cfgs) {
BuildConfigPtr le_conf(new BuildConfig(NULL));
wxString outputFileName = wxT("");
switch(cfgType) {
case GenericCfgType::DYNAMIC_LIBRARY:
outputFileName = wxT("$(IntermediateDirectory)/$(ProjectName)");
outputFileName += DYNAMIC_LIBRARY_EXT;
break;
case GenericCfgType::STATIC_LIBRARY:
outputFileName = wxT("$(IntermediateDirectory)/$(ProjectName)");
outputFileName += STATIC_LIBRARY_EXT;
if(isGccCompile && outputFileName.Contains(wxT(".lib"))) {
outputFileName.Replace(wxT(".lib"), wxT(".a"));
}
break;
case GenericCfgType::EXECUTABLE:
outputFileName = wxT("$(IntermediateDirectory)/$(ProjectName)");
outputFileName += EXECUTABLE_EXT;
break;
}
std::vector<wxString> envVarElems;
le_conf->SetName(cfg->name);
if(!cfg->includePath.IsEmpty()) {
envVarElems.push_back(cfg->includePath);
le_conf->SetIncludePath(cfg->includePath);
}
if(!cfg->libraries.IsEmpty()) {
envVarElems.push_back(cfg->libraries);
if(isGccCompile && cfg->libraries.Contains(wxT(".lib"))) {
cfg->libraries.Replace(wxT(".lib"), wxT(".a"));
}
le_conf->SetLibraries(cfg->libraries);
}
if(!cfg->libPath.IsEmpty()) {
envVarElems.push_back(cfg->libPath);
le_conf->SetLibPath(cfg->libPath);
}
if(!cfg->preprocessor.IsEmpty()) {
envVarElems.push_back(cfg->preprocessor);
le_conf->SetPreprocessor(cfg->preprocessor);
}
if(!cfg->intermediateDirectory.IsEmpty())
le_conf->SetIntermediateDirectory(cfg->intermediateDirectory);
if(!cfg->outputFilename.IsEmpty()) {
if(isGccCompile && cfg->outputFilename.Contains(wxT(".lib"))) {
cfg->outputFilename.Replace(wxT(".lib"), wxT(".a"));
}
le_conf->SetOutputFileName(cfg->outputFilename);
} else
le_conf->SetOutputFileName(outputFileName);
if(!cfg->cCompilerOptions.IsEmpty())
le_conf->SetCCompileOptions(cfg->cCompilerOptions);
if(!cfg->cppCompilerOptions.IsEmpty())
le_conf->SetCompileOptions(cfg->cppCompilerOptions);
if(!cfg->linkerOptions.IsEmpty())
le_conf->SetLinkOptions(cfg->linkerOptions);
if(!cfg->preCompiledHeader.IsEmpty())
le_conf->SetPrecompiledHeader(cfg->preCompiledHeader);
wxString outputFileNameCommand, outputFileNameWorkingDirectory;
if(!cfg->outputFilename.IsEmpty()) {
wxFileName outputFileNameInfo(cfg->outputFilename);
outputFileNameCommand = wxT("./") + outputFileNameInfo.GetFullName();
outputFileNameWorkingDirectory = outputFileNameInfo.GetPath();
outputFileNameWorkingDirectory.Replace(wxT("\\"), wxT("/"));
}
if(!cfg->command.IsEmpty())
le_conf->SetCommand(cfg->command);
else if(!outputFileNameCommand.IsEmpty())
le_conf->SetCommand(outputFileNameCommand);
else
le_conf->SetCommand(wxT("./$(ProjectName)"));
if(!cfg->workingDirectory.IsEmpty())
le_conf->SetWorkingDirectory(cfg->workingDirectory);
else if(!outputFileNameWorkingDirectory.IsEmpty())
le_conf->SetWorkingDirectory(outputFileNameWorkingDirectory);
else
le_conf->SetWorkingDirectory(wxT("./$(IntermediateDirectory)"));
le_conf->SetCompilerType(defaultCompiler);
wxString cfgName = cfg->name.Lower();
if(cfgName.Contains(wxT("debug"))) {
ConfigMappingEntry cme(project->name, cfg->name);
cmlDebug.push_back(cme);
} else if(cfgName.Contains(wxT("release"))) {
ConfigMappingEntry cme(project->name, cfg->name);
cmlRelease.push_back(cme);
} else {
ConfigMappingEntry cme(project->name, cfg->name);
cmlDebug.push_back(cme);
cmlRelease.push_back(cme);
}
wxString buildConfigType;
switch(cfgType) {
case GenericCfgType::DYNAMIC_LIBRARY:
buildConfigType = Project::DYNAMIC_LIBRARY;
break;
case GenericCfgType::STATIC_LIBRARY:
buildConfigType = Project::STATIC_LIBRARY;
break;
case GenericCfgType::EXECUTABLE:
default:
buildConfigType = Project::EXECUTABLE;
break;
}
le_conf->SetProjectType(buildConfigType);
if(showDlg) {
if(envVarElems.size() > 0 && ContainsEnvVar(envVarElems)) {
std::set<wxString> listEnvVar = GetListEnvVarName(envVarElems);
for(GenericEnvVarsValueType envVar : cfg->envVars) {
listEnvVar.erase(envVar.first);
}
if(listEnvVar.size() > 0) {
EnvVarImporterDlg envVarImporterDlg(
NULL, project->name, cfg->name, listEnvVar, le_conf, &showDlg);
envVarImporterDlg.ShowModal();
}
}
}
wxString envVars =
!le_conf->GetEnvvars().IsEmpty() ? le_conf->GetEnvvars() + wxT("\n") : wxT("");
for(GenericEnvVarsValueType envVar : cfg->envVars) {
envVars += envVar.first + wxT("=") + envVar.second + wxT("\n");
}
le_conf->SetEnvvars(envVars);
BuildCommandList preBuildCommandList;
BuildCommandList postBuildCommandList;
for (wxString preBuildCmd : cfg->preBuildCommands) {
BuildCommand preBuildCommand;
preBuildCommand.SetCommand(preBuildCmd);
preBuildCommand.SetEnabled(true);
preBuildCommandList.push_back(preBuildCommand);
}
for (wxString postBuildCmd : cfg->postBuildCommands) {
BuildCommand postBuildCommand;
postBuildCommand.SetCommand(postBuildCmd);
postBuildCommand.SetEnabled(true);
postBuildCommandList.push_back(postBuildCommand);
}
le_conf->SetPreBuildCommands(preBuildCommandList);
le_conf->SetPostBuildCommands(postBuildCommandList);
le_settings->SetBuildConfiguration(le_conf);
if(!project->deps.IsEmpty())
proj->SetDependencies(project->deps, cfg->name);
}
proj->SetSettings(le_settings);
proj->BeginTranscation();
// Delete default virtual directory
proj->DeleteVirtualDir("include");
proj->DeleteVirtualDir("src");
for(GenericProjectFilePtr file : project->files) {
wxString vpath;
if(file->vpath.IsEmpty()) {
wxFileName fileInfo(file->name);
wxString ext = fileInfo.GetExt().Lower();
if(ext == wxT("h") || ext == wxT("hpp") || ext == wxT("hxx") || ext == wxT("hh") ||
ext == wxT("inl") || ext == wxT("inc")) {
vpath = wxT("include");
} else if(ext == wxT("c") || ext == wxT("cpp") || ext == wxT("cxx") || ext == wxT("cc")) {
vpath = wxT("src");
} else if(ext == wxT("s") || ext == wxT("S") || ext == wxT("asm")) {
vpath = wxT("src");
} else {
vpath = wxT("resource");
}
} else {
vpath = file->vpath;
if(file->vpath.Contains(wxT("\\"))) {
vpath.Replace(wxT("\\"), wxT(":"));
} else if(file->vpath.Contains(wxT("/"))) {
vpath.Replace(wxT("/"), wxT(":"));
}
}
proj->CreateVirtualDir(vpath);
proj->AddFile(file->name, vpath);
}
proj->CommitTranscation();
}
if(clWorkspace) {
BuildMatrixPtr clMatrix = clWorkspace->GetBuildMatrix();
WorkspaceConfigurationPtr wsconf = clMatrix->GetConfigurationByName(wxT("Debug"));
if(wsconf) {
wsconf->SetConfigMappingList(cmlDebug);
}
wsconf = clMatrix->GetConfigurationByName(wxT("Release"));
if(wsconf) {
wsconf->SetConfigMappingList(cmlRelease);
}
clWorkspace->SetBuildMatrix(clMatrix);
}
return true;
}
}
}
return false;
}
