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);
}
}
BuildConfigPtr clCxxWorkspace::GetProjBuildConf(const wxString& projectName, const wxString& confName) const
{
BuildMatrixPtr matrix = GetBuildMatrix();
if(!matrix) {
return NULL;
}
wxString projConf(confName);
if(projConf.IsEmpty()) {
wxString workspaceConfig = matrix->GetSelectedConfigurationName();
projConf = matrix->GetProjectSelectedConf(workspaceConfig, projectName);
}
// Get the project setting and retrieve the selected configuration
wxString errMsg;
ProjectPtr proj = FindProjectByName(projectName, errMsg);
if(proj) {
ProjectSettingsPtr settings = proj->GetSettings();
if(settings) {
return settings->GetBuildConfiguration(projConf, true);
}
}
return NULL;
}
void ConfigurationManagerDlg::PopulateConfigurations()
{
//popuplate the configurations
BuildMatrixPtr matrix = ManagerST::Get()->GetWorkspaceBuildMatrix();
if (!matrix) {
return;
}
wxFlexGridSizer *mainSizer = dynamic_cast<wxFlexGridSizer*>(m_scrolledWindow->GetSizer());
if (!mainSizer) return;
Freeze();
// remove old entries from the configuration table
wxSizerItemList list = mainSizer->GetChildren();
for ( wxSizerItemList::Node *node = list.GetFirst(); node; node = node->GetNext() ) {
wxSizerItem *current = node->GetData();
current->GetWindow()->Destroy();
}
m_projSettingsMap.clear();
std::list<CSolitionConfigurationPtr> configs = matrix->GetConfigurations();
std::list<CSolitionConfigurationPtr>::iterator iter = configs.begin();
m_choiceConfigurations->Clear();
for (; iter != configs.end(); iter++) {
m_choiceConfigurations->Append((*iter)->GetName());
}
// append the 'New' & 'Delete' commands
m_choiceConfigurations->Append(clCMD_NEW);
m_choiceConfigurations->Append(clCMD_EDIT);
int sel = m_choiceConfigurations->FindString(matrix->GetSelectedConfigurationName());
if (sel != wxNOT_FOUND) {
m_choiceConfigurations->SetSelection(sel);
} else if (m_choiceConfigurations->GetCount() > 2) {
m_choiceConfigurations->SetSelection(2);
} else {
m_choiceConfigurations->Append(wxT("Debug"));
m_choiceConfigurations->SetSelection(2);
}
// keep the current workspace configuration
m_currentWorkspaceConfiguration = m_choiceConfigurations->GetStringSelection();
wxArrayString projects;
ManagerST::Get()->GetProjectList(projects);
projects.Sort(wxStringCmpFunc);
for (size_t i=0; i<projects.GetCount(); i++) {
wxString selConf = matrix->GetProjectSelectedConf(matrix->GetSelectedConfigurationName(), projects.Item(i));
AddEntry(projects.Item(i), selConf);
}
Thaw();
mainSizer->Fit(m_scrolledWindow);
Layout();
}
wxArrayString Project::GetIncludePaths()
{
wxArrayString paths;
BuildMatrixPtr matrix = WorkspaceST::Get()->GetBuildMatrix();
if(!matrix) {
return paths;
}
wxString workspaceSelConf = matrix->GetSelectedConfigurationName();
wxString projectSelConf = matrix->GetProjectSelectedConf(workspaceSelConf, GetName());
BuildConfigPtr buildConf = WorkspaceST::Get()->GetProjBuildConf(this->GetName(), projectSelConf);
// for non custom projects, take the settings from the build configuration
if(buildConf && !buildConf->IsCustomBuild()) {
// Get the include paths and add them
wxString projectIncludePaths = buildConf->GetIncludePath();
wxArrayString projectIncludePathsArr = wxStringTokenize(projectIncludePaths, wxT(";"), wxTOKEN_STRTOK);
for(size_t i=0; i<projectIncludePathsArr.GetCount(); i++) {
wxFileName fn;
if(projectIncludePathsArr.Item(i) == wxT("..")) {
fn = wxFileName(GetFileName().GetPath(), wxT(""));
fn.RemoveLastDir();
} else if(projectIncludePathsArr.Item(i) == wxT(".")) {
fn = wxFileName(GetFileName().GetPath(), wxT(""));
} else {
fn = projectIncludePathsArr.Item(i);
if(fn.IsRelative()) {
fn.MakeAbsolute(GetFileName().GetPath());
}
}
paths.Add( fn.GetFullPath() );
}
// get the compiler options and add them
wxString projectCompileOptions = buildConf->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);
// expand backticks, if the option is not a backtick the value remains
// unchanged
wxArrayString includePaths = DoBacktickToIncludePath(cmpOption);
if(includePaths.IsEmpty() == false)
paths.insert(paths.end(), includePaths.begin(), includePaths.end());
}
}
return paths;
}
void ConfigurationManagerDlg::LoadWorkspaceConfiguration(const wxString &confName)
{
BuildMatrixPtr matrix = ManagerST::Get()->GetWorkspaceBuildMatrix();
if (!matrix) {
return;
}
m_choiceConfigurations->SetStringSelection(confName);
std::map<int, ConfigEntry>::iterator iter = m_projSettingsMap.begin();
for (; iter != m_projSettingsMap.end(); iter++) {
wxString selConf = matrix->GetProjectSelectedConf(confName, iter->second.project);
iter->second.choiceControl->SetStringSelection(selConf);
}
}
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 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;
}
}
}
}
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 );
}
}
