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; }