void CMakePlugin::OnWorkspaceContextMenu(clContextMenuEvent& event)
{
event.Skip();
CHECK_COND_RET(clCxxWorkspaceST::Get()->IsOpen());
ProjectPtr p = clCxxWorkspaceST::Get()->GetActiveProject();
CHECK_COND_RET(p);
BuildConfigPtr buildConf = p->GetBuildConfiguration();
CHECK_COND_RET(buildConf);
CHECK_COND_RET(buildConf->GetBuilder()->GetName() == "CMake");
// The active project is using CMake builder
// Add our context menu
wxMenu* menu = event.GetMenu();
CHECK_PTR_RET(menu);
wxFileName workspaceFile = clCxxWorkspaceST::Get()->GetFileName();
workspaceFile.SetFullName(CMAKELISTS_FILE);
menu->InsertSeparator(0);
if(workspaceFile.FileExists()) {
wxMenuItem* item = new wxMenuItem(NULL, XRCID("cmake_open_active_project_cmake"), _("Open CMakeLists.txt"));
item->SetBitmap(m_mgr->GetStdIcons()->LoadBitmap("cmake"));
menu->Insert(0, item);
}
menu->Insert(0, XRCID("cmake_export_active_project"), _("Export CMakeLists.txt"));
menu->Bind(wxEVT_MENU, &CMakePlugin::OnOpenCMakeLists, this, XRCID("cmake_open_active_project_cmake"));
menu->Bind(wxEVT_MENU, &CMakePlugin::OnExportCMakeLists, this, XRCID("cmake_export_active_project"));
}
void CMainFrame::OnFileOpenProject()
{
using namespace engine;
util_update_obj_property_grid(GameObjectPtr());
util_update_object_view(GameObjectPtr());
CFileDialog dlg(TRUE,
L"gp",
NULL,
OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT,
L"Game Project Files (*.gp)|*.gp||");
if(IDOK != dlg.DoModal())
{
return;
}
ProjectPtr pProject = Project::Instance();
pProject->Close();
CString file = dlg.GetPathName();
if(pProject->Load(file) == false)
{
MessageBox(L"Fialed to load project.", L"error", MB_ICONERROR);
pProject->Close();
return;
}
util_update_object_view(pProject->Root());
}
void MemCheckPlugin::CheckProject(const wxString& projectName)
{
if(m_terminal.IsRunning()) {
::wxMessageBox(_("Another instance is already running. Please stop it before executing another one"),
"CodeLite",
wxICON_WARNING | wxCENTER | wxOK);
return;
}
wxString errMsg;
ProjectPtr project = m_mgr->GetWorkspace()->FindProjectByName(projectName, errMsg);
wxString path = project->GetFileName().GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
wxString wd;
wxString command = m_mgr->GetProjectExecutionCommand(projectName, wd);
DirSaver ds;
EnvSetter envGuard(m_mgr->GetEnv());
wxSetWorkingDirectory(path);
wxSetWorkingDirectory(wd);
m_mgr->AppendOutputTabText(kOutputTab_Output, _("Launching MemCheck...\n"));
m_mgr->AppendOutputTabText(kOutputTab_Output,
wxString() << _("Working directory is set to: ") << ::wxGetCwd() << "\n");
m_mgr->AppendOutputTabText(kOutputTab_Output,
wxString() << "MemCheck command: " << m_memcheckProcessor->GetExecutionCommand(command)
<< "\n");
wxString cmd = m_memcheckProcessor->GetExecutionCommand(command);
m_terminal.ExecuteConsole(cmd, "", true, wxString::Format("MemCheck: %s", projectName));
}
bool clCxxWorkspace::AddNewFile(const wxString& vdFullPath, const wxString& fileName, wxString& errMsg)
{
wxStringTokenizer tkz(vdFullPath, wxT(":"));
// We should have at least 2 tokens:
// project:virtual directory
if(tkz.CountTokens() < 2)
return false;
wxString projName = tkz.GetNextToken();
wxString fixedPath;
// Construct new path excluding the first token
size_t count = tkz.CountTokens();
for(size_t i = 0; i < count - 1; i++) {
fixedPath += tkz.GetNextToken();
fixedPath += wxT(":");
}
fixedPath += tkz.GetNextToken();
ProjectPtr proj = FindProjectByName(projName, errMsg);
if(!proj) {
errMsg = wxT("No such project");
return false;
}
return proj->AddFile(fileName, fixedPath);
}
wxString QMakePlugin::DoGetBuildCommand(const wxString& project, const wxString& config, bool projectOnly)
{
wxUnusedVar(config);
wxString errMsg;
ProjectPtr p = m_mgr->GetWorkspace()->FindProjectByName(project, errMsg);
if(!p) { return wxEmptyString; }
BuildConfigPtr bldConf = clCxxWorkspaceST::Get()->GetProjBuildConf(project, config);
wxString cmd;
wxString projectMakefile;
projectMakefile << p->GetName() << ".mk";
::WrapWithQuotes(projectMakefile);
projectMakefile.Replace("\\", "/");
if(!projectOnly) {
// part of a greater makefile, use $(MAKE)
cmd << wxT("@cd \"") << p->GetFileName().GetPath() << wxT("\" && ");
cmd << "$(MAKE) -f " << projectMakefile;
} else {
// project only
cmd = bldConf->GetCompiler()->GetTool("MAKE");
if(!cmd.Contains("-f")) { cmd << " -f "; }
cmd << " " << projectMakefile;
}
return cmd;
}
void
CMakeProjectMenu::OnMakeDirty(wxCommandEvent& event)
{
// Get settings
const CMakeProjectSettings* settings = m_plugin->GetSelectedProjectSettings();
// Event shouldn't be called when project is not enabled
wxASSERT(settings && settings->enabled);
// This function just touch .cmake_dirty file
ProjectPtr project = m_plugin->GetSelectedProject();
// Real project
wxString projectName = project->GetName();
// Project has parent project -> touch dirty file there
if (!settings->parentProject.IsEmpty()) {
projectName = settings->parentProject;
}
// Move to project directory
wxFileName dirtyFile = m_plugin->GetProjectDirectory(projectName);
dirtyFile.SetFullName(".cmake_dirty");
// Update file time
dirtyFile.Touch();
}
//------------------------------------------------------------
void SnipWiz::OnClassWizard(wxCommandEvent& e)
{
TemplateClassDlg dlg(m_mgr->GetTheApp()->GetTopWindow(), this, m_mgr);
wxString errMsg, projectPath, projectName;
TreeItemInfo item = m_mgr->GetSelectedTreeItemInfo(TreeFileView);
projectName = m_mgr->GetWorkspace()->GetActiveProjectName();
if(m_mgr->GetWorkspace()) {
if(item.m_item.IsOk() && item.m_itemType == ProjectItem::TypeVirtualDirectory) {
projectPath = item.m_fileName.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
} else {
ProjectPtr proj = m_mgr->GetWorkspace()->FindProjectByName(projectName, errMsg);
if(proj) projectPath = proj->GetFileName().GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
}
}
dlg.SetCurEol(GetEOLByOS());
dlg.SetPluginPath(m_pluginPath);
dlg.SetProjectPath(projectPath);
dlg.ShowModal();
if(dlg.GetModified()) {
m_modified = true;
}
}
wxString CppCheckPlugin::DoGetCommand(ProjectPtr proj)
{
// Linux / Mac way: spawn the process and execute the command
wxString cmd, path;
path = clStandardPaths::Get().GetBinaryFullPath("codelite_cppcheck");
::WrapWithQuotes(path);
wxString fileList = DoGenerateFileList();
if(fileList.IsEmpty()) return wxT("");
// build the command
cmd << path << " ";
cmd << m_settings.GetOptions();
// Append here project specifc search paths
if(proj) {
wxArrayString projectSearchPaths = proj->GetIncludePaths();
for(size_t i = 0; i < projectSearchPaths.GetCount(); ++i) {
wxFileName fnIncPath(projectSearchPaths.Item(i), "");
wxString includePath = fnIncPath.GetPath(true);
::WrapWithQuotes(includePath);
cmd << " -I" << includePath;
}
wxArrayString projMacros = proj->GetPreProcessors();
for(size_t i = 0; i < projMacros.GetCount(); ++i) {
cmd << " -D" << projMacros.Item(i);
}
}
cmd << wxT(" --file-list=");
cmd << wxT("\"") << fileList << wxT("\"");
CL_DEBUG("cppcheck command: %s", cmd);
return cmd;
}
void PSCustomBuildPage::OnBrowseCustomBuildWD(wxCommandEvent& event)
{
DirSaver ds;
// Since all paths are relative to the project, set the working directory to the
// current project path
ProjectPtr p = ManagerST::Get()->GetProject(m_projectName);
if(p) {
wxSetWorkingDirectory(p->GetFileName().GetPath());
}
wxFileName fn(m_textCtrlCustomBuildWD->GetValue());
wxString initPath(wxEmptyString);
if(fn.DirExists()) {
fn.MakeAbsolute();
initPath = fn.GetFullPath();
}
wxString new_path =
wxDirSelector(_("Select working directory:"), initPath, wxDD_DEFAULT_STYLE, wxDefaultPosition, this);
if(new_path.IsEmpty() == false) {
m_textCtrlCustomBuildWD->SetValue(new_path);
}
}
void CppCheckPlugin::DoSettingsItem(ProjectPtr project/*= NULL*/)
{
// Find the default path for the CppCheckSettingsDialog's wxFileDialog
wxString defaultpath;
IEditor* ed = m_mgr->GetActiveEditor();
if (ed && ed->GetFileName().IsOk()) {
defaultpath = ed->GetFileName().GetPath();
}
// If there's an active project, first load any project-specific settings: definitions and undefines
// (We couldn't do that with the rest of the settings as the workspace hadn't yet been loaded)
m_settings.LoadProjectSpecificSettings(project); // NB we still do this if !project, as that will clear any stale settings
CppCheckSettingsDialog dlg(m_mgr->GetTheApp()->GetTopWindow(), &m_settings, m_mgr->GetConfigTool(), defaultpath, project.Get() != NULL);
if (dlg.ShowModal() == wxID_OK) {
m_mgr->GetConfigTool()->WriteObject(wxT("CppCheck"), &m_settings);
if (project) {
// Also save any project-specific settings: definitions and undefines
wxString definitions = wxJoin(m_settings.GetDefinitions(), ',');
wxString undefines = wxJoin(m_settings.GetUndefines(), ',');
if (!(definitions.empty() && undefines.empty())) {
project->SetPluginData("CppCheck", definitions + ';' + undefines);
} else {
project->SetPluginData("CppCheck", "");
}
}
}
}
void CppCheckPlugin::OnCheckProjectItem(wxCommandEvent& e)
{
if ( m_cppcheckProcess ) {
wxLogMessage(_("CppCheckPlugin: CppCheck is currently busy please wait for it to complete the current check"));
return;
}
ProjectPtr proj = FindSelectedProject();
if ( !proj ) {
return;
}
// retrieve complete list of source files of the workspace
std::vector< wxFileName > tmpfiles;
proj->GetFiles(tmpfiles, true);
// only C/C++ files
for (size_t i=0; i< tmpfiles.size(); i++) {
if (FileExtManager::GetType(tmpfiles.at(i).GetFullPath()) == FileExtManager::TypeSourceC ||
FileExtManager::GetType(tmpfiles.at(i).GetFullPath()) == FileExtManager::TypeSourceCpp) {
m_filelist.Add(tmpfiles.at(i).GetFullPath());
}
}
DoStartTest(proj);
}
void LLDBDebuggerPlugin::OnDebugStart(clDebugEvent& event)
{
event.Skip();
return;
if ( ::PromptForYesNoDialogWithCheckbox(_("Would you like to use LLDB debugger as your primary debugger?"), "UseLLDB") != wxID_YES ) {
event.Skip();
return;
}
// Get the executable to debug
wxString errMsg;
ProjectPtr pProject = WorkspaceST::Get()->FindProjectByName(event.GetProjectName(), errMsg);
if ( !pProject ) {
event.Skip();
return;
}
wxSetWorkingDirectory ( pProject->GetFileName().GetPath() );
BuildConfigPtr bldConf = WorkspaceST::Get()->GetProjBuildConf ( pProject->GetName(), wxEmptyString );
if ( !bldConf ) {
event.Skip();
return;
}
// Show the terminal
ShowTerminal("LLDB Console Window");
if ( m_debugger.Start("/home/eran/devl/TestArea/TestHang/Debug/TestHang") ) {
m_debugger.AddBreakpoint("main");
m_debugger.ApplyBreakpoints();
m_debugger.Run("/tmp/in", "/tmp/out", "/tmp/err", wxArrayString(), wxArrayString(), ::wxGetCwd());
}
}
void CppCheckPlugin::OnCheckWorkspaceItem(wxCommandEvent& e)
{
if(m_cppcheckProcess) {
clLogMessage(_("CppCheckPlugin: CppCheck is currently busy please wait for it to complete the current check"));
return;
}
if(!m_mgr->GetWorkspace() || !m_mgr->IsWorkspaceOpen()) { return; }
TreeItemInfo item = m_mgr->GetSelectedTreeItemInfo(TreeFileView);
if(item.m_itemType == ProjectItem::TypeWorkspace) {
// retrieve complete list of source files of the workspace
wxArrayString projects;
wxString err_msg;
std::vector<wxFileName> tmpfiles;
m_mgr->GetWorkspace()->GetProjectList(projects);
for(size_t i = 0; i < projects.GetCount(); i++) {
ProjectPtr proj = m_mgr->GetWorkspace()->FindProjectByName(projects.Item(i), err_msg);
if(proj) { proj->GetFilesAsVectorOfFileName(tmpfiles); }
}
// only C/C++ files
for(size_t i = 0; i < tmpfiles.size(); i++) {
if(FileExtManager::GetType(tmpfiles.at(i).GetFullPath()) == FileExtManager::TypeSourceC ||
FileExtManager::GetType(tmpfiles.at(i).GetFullPath()) == FileExtManager::TypeSourceCpp) {
m_filelist.Add(tmpfiles.at(i).GetFullPath());
}
}
}
DoStartTest();
}
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;
}
bool clCxxWorkspace::RemoveFile(const wxString& vdFullPath, const wxString& fileName, wxString& errMsg)
{
wxStringTokenizer tkz(vdFullPath, wxT(":"));
wxString projName = tkz.GetNextToken();
wxString fixedPath;
// Construct new path excluding the first token
size_t count = tkz.CountTokens();
if(!count) {
errMsg = _("Malformed project name");
return false;
}
for(size_t i = 0; i < count - 1; i++) {
fixedPath += tkz.GetNextToken();
fixedPath += wxT(":");
}
fixedPath += tkz.GetNextToken();
ProjectPtr proj = FindProjectByName(projName, errMsg);
if(!proj) {
errMsg = _("No such project");
return false;
}
bool result = proj->RemoveFile(fileName, fixedPath);
if(!result) {
errMsg = _("File removal failed");
}
return result;
}
void VirtualDirectoryTree::BuildTree(const wxString& projName)
{
ProjectPtr proj = ManagerST::Get()->GetProject(projName);
wxCHECK_RET(proj, "Can't find a Project with the supplied name");
ProjectTreePtr tree = proj->AsTree();
TreeWalker<wxString, ProjectItem> walker(tree->GetRoot());
for ( ; !walker.End(); walker++ ) {
ProjectTreeNode* node = walker.GetNode();
wxString displayname(node->GetData().GetDisplayName());
if (node->GetData().GetKind() == ProjectItem::TypeVirtualDirectory) {
wxString vdPath = displayname;
ProjectTreeNode* tempnode = node->GetParent();
while (tempnode) {
vdPath = tempnode->GetData().GetDisplayName() + ':' + vdPath;
tempnode = tempnode->GetParent();
}
VirtualDirectoryTree* parent = FindParent(vdPath.BeforeLast(':'));
if (parent) {
parent->StoreChild(displayname, vdPath);
} else {
// Any orphans must be root's top-level children, and we're root
StoreChild(displayname, vdPath);
}
}
}
}
void ReconcileProjectFiletypesDlg::SetData()
{
ProjectPtr proj = ManagerST::Get()->GetProject(m_projname);
wxCHECK_RET(proj, "Can't find a Project with the supplied name");
wxString topleveldir, types;
wxArrayString ignorefiles, excludes, regexes;
proj->GetReconciliationData(topleveldir, types, ignorefiles, excludes, regexes);
if (topleveldir.empty()) {
topleveldir = proj->GetFileName().GetPath();
}
wxFileName tld(topleveldir);
if ( tld.IsRelative() ) {
tld.MakeAbsolute( proj->GetFileName().GetPath() );
}
m_dirPickerToplevel->SetPath(tld.GetFullPath());
if (types.empty()) {
types << "cpp;c;h;hpp;xrc;wxcp;fbp";
}
m_textExtensions->ChangeValue(types);
m_listIgnoreFiles->Clear();
m_listIgnoreFiles->Append(ignorefiles);
m_listExclude->Clear();
m_listExclude->Append(excludes);
m_listCtrlRegexes->DeleteAllItems();
for (size_t n = 0; n < regexes.GetCount(); ++n) {
SetRegex(regexes[n]);
}
}
void ReconcileProjectFiletypesDlg::OnIgnoreBrowse(wxCommandEvent& WXUNUSED(event))
{
ProjectPtr proj = ManagerST::Get()->GetProject(m_projname);
wxCHECK_RET(proj, "Can't find a Project with the supplied name");
wxString topleveldir, types;
wxArrayString ignorefiles, excludes, regexes;
proj->GetReconciliationData(topleveldir, types, ignorefiles, excludes, regexes);
if (topleveldir.empty()) {
topleveldir = proj->GetFileName().GetPath();
}
wxFileName tld(topleveldir);
if ( tld.IsRelative() ) {
tld.MakeAbsolute( proj->GetFileName().GetPath() );
}
wxString new_exclude = wxDirSelector(_("Select a directory to ignore:"), tld.GetFullPath(), wxDD_DEFAULT_STYLE, wxDefaultPosition, this);
if (!new_exclude.empty()) {
wxFileName fn = wxFileName::DirName(new_exclude);
fn.MakeRelativeTo(topleveldir);
new_exclude = fn.GetFullPath();
if (m_listExclude->FindString(new_exclude) == wxNOT_FOUND) {
m_listExclude->Append(new_exclude);
}
}
}
wxArrayString ReconcileProjectDlg::AddMissingFiles(const wxArrayString& files, const wxString& vdPath)
{
wxArrayString additions;
ProjectPtr proj = ManagerST::Get()->GetProject(m_projname);
wxCHECK_MSG(proj, additions, "Can't find a Project with the supplied name");
wxString VD = vdPath;
if (VD.empty()) {
// If we were called from the root panel (so the user is trying to add unallocated files, or all files at once) we need to know which VD to use
VirtualDirectorySelectorDlg selector(this, WorkspaceST::Get(), "", m_projname);
selector.SetText("Please choose the Virtual Directory to which to add the files");
if (selector.ShowModal() == wxID_OK) {
VD = selector.GetVirtualDirectoryPath();
} else {
return additions;
}
}
VD = VD.AfterFirst(':'); // Remove the projectname
for (size_t n = 0; n < files.GetCount(); ++n) {
if (proj->FastAddFile(files[n], VD)) {
additions.Add(files[n]);
}
}
return additions;
}
void ReconcileProjectDlg::DoFindFiles()
{
m_stalefiles.clear();
m_newfiles.clear();
ProjectPtr proj = ManagerST::Get()->GetProject(m_projname);
wxCHECK_RET(proj, "Can't find a Project with the supplied name");
// get list of files from the project
Project::FileInfoVector_t projectfiles;
proj->GetFilesMetadata(projectfiles);
wxStringSet_t projectfilesSet;
Project::FileInfoVector_t::const_iterator it = projectfiles.begin();
for( ; it != projectfiles.end(); ++it ) {
projectfilesSet.insert( it->GetFilename() );
}
std::vector<wxString> result;
std::set_difference(m_allfiles.begin(), m_allfiles.end(), projectfilesSet.begin(), projectfilesSet.end(), std::back_inserter(result));
m_newfiles.insert(result.begin(), result.end());
// now run the diff reverse to get list of stale files
m_stalefiles.clear();
Project::FileInfoVector_t::const_iterator iter = projectfiles.begin();
for(; iter != projectfiles.end(); ++iter ) {
if ( !wxFileName::Exists( iter->GetFilename() ) ) {
m_stalefiles.push_back( *iter );
}
}
}
void BatchBuildDlg::DoInitialize()
{
// load the previously saved batch build file
wxFileName fn(WorkspaceST::Get()->GetWorkspaceFileName());
fn.SetExt(wxT("batch_build"));
wxString content;
wxArrayString arr;
if (ReadFileWithConversion(fn.GetFullPath(), content)) {
arr = wxStringTokenize(content, wxT("\n"), wxTOKEN_STRTOK);
for (size_t i=0; i<arr.GetCount(); i++) {
int idx = m_checkListConfigurations->Append(arr.Item(i));
m_checkListConfigurations->Check((unsigned int)idx);
}
}
// loop over all projects, for each project collect all available
// build configurations and add them to the check list control
wxArrayString projects;
WorkspaceST::Get()->GetProjectList(projects);
for (size_t i=0; i<projects.GetCount(); i++) {
ProjectPtr p = ManagerST::Get()->GetProject(projects.Item(i));
if (p) {
ProjectSettingsPtr settings = p->GetSettings();
if (settings) {
ProjectSettingsCookie cookie;
BuildConfigPtr bldConf = settings->GetFirstBuildConfiguration(cookie);
while (bldConf) {
wxString item(p->GetName() + wxT(" | ") + bldConf->GetName());
int where = arr.Index(item);
if (where == wxNOT_FOUND) {
// append this item
m_checkListConfigurations->Append(item);
} else {
// this item already been added,
// remove it from the arr and continue
arr.RemoveAt((size_t)where);
}
bldConf = settings->GetNextBuildConfiguration(cookie);
}
}
}
}
// check to see which configuration was left in 'arr'
// and remove them from the checklistbox
for (size_t i=0; i<arr.GetCount(); i++) {
int where = m_checkListConfigurations->FindString(arr.Item(i));
if (where != wxNOT_FOUND) {
m_checkListConfigurations->Delete((unsigned int)where);
}
}
arr.clear();
if (m_checkListConfigurations->GetCount()>0) {
m_checkListConfigurations->Select(0);
}
}
wxString QMakePlugin::DoGetBuildCommand(const wxString &project, const wxString &config, bool projectOnly)
{
wxUnusedVar ( config );
wxString errMsg;
ProjectPtr p = m_mgr->GetWorkspace()->FindProjectByName(project, errMsg);
if ( !p ) {
return wxEmptyString;
}
BuildConfigPtr bldConf = WorkspaceST::Get()->GetProjBuildConf(project, config);
wxString cmd;
if ( !projectOnly ) {
cmd << wxT("@cd \"") << p->GetFileName().GetPath() << wxT("\" && ");
}
// fix: replace all Windows like slashes to POSIX
wxString command = bldConf->GetCompiler()->GetTool("MAKE");
command.Replace(wxT("\\"), wxT("/"));
cmd << command << wxT(" \"") << p->GetName() << wxT(".mk\"");
return cmd;
}
void VcImporter::CreateFiles(wxXmlNode* parent, wxString vdPath, ProjectPtr proj)
{
if(!parent) {
return;
}
wxXmlNode* child = parent->GetChildren();
while(child) {
if(child->GetName() == wxT("Filter")) {
// add new virtual directory
wxString name = XmlUtils::ReadString(child, wxT("Name"));
wxString tmpPath = vdPath;
if(tmpPath.IsEmpty() == false) {
tmpPath << wxT(":");
}
tmpPath << name;
proj->CreateVirtualDir(tmpPath);
CreateFiles(child, tmpPath, proj);
} else if(child->GetName() == wxT("File")) {
// found a file
wxString fileName = XmlUtils::ReadString(child, wxT("RelativePath"));
wxString path = vdPath;
if(path.IsEmpty()) {
path = wxT("src");
}
fileName.Replace(wxT("\\"), wxT("/"));
proj->AddFile(fileName, path);
}
child = child->GetNext();
}
}
void ShellCommand::DoSetWorkingDirectory(ProjectPtr proj, bool isCustom, bool isFileOnly)
{
//when using custom build, user can select different working directory
if (proj) {
if (isCustom) {
//first set the path to the project working directory
::wxSetWorkingDirectory(proj->GetFileName().GetPath());
BuildConfigPtr buildConf = WorkspaceST::Get()->GetProjBuildConf(m_info.GetProject(), m_info.GetConfiguration());
if (buildConf) {
wxString wd = buildConf->GetCustomBuildWorkingDir();
if (wd.IsEmpty()) {
// use the project path
wd = proj->GetFileName().GetPath();
} else {
// expand macros from path
wd = ExpandAllVariables(wd, WorkspaceST::Get(), proj->GetName(), buildConf->GetName(), wxEmptyString);
}
::wxSetWorkingDirectory(wd);
}
} else {
if(m_info.GetProjectOnly() || isFileOnly) {
//first set the path to the project working directory
::wxSetWorkingDirectory(proj->GetFileName().GetPath());
}
}
}
}
bool
Gui::saveProject()
{
ProjectPtr project = getApp()->getProject();
if ( project->hasProjectBeenSavedByUser() ) {
QString projectFilename = project->getProjectFilename();
QString projectPath = project->getProjectPath();
if ( !_imp->checkProjectLockAndWarn(projectPath, projectFilename) ) {
return false;
}
bool ret = project->saveProject(projectPath, projectFilename, 0);
///update the open recents
if ( !projectPath.endsWith( QLatin1Char('/') ) ) {
projectPath.append( QLatin1Char('/') );
}
if (ret) {
QString file = projectPath + projectFilename;
updateRecentFiles(file);
}
return ret;
} else {
return saveProjectAs();
}
}
void
CMakeProjectMenu::OnFileExists(wxUpdateUIEvent& event)
{
ProjectPtr project = m_plugin->GetSelectedProject();
if (project)
event.Enable(m_plugin->ExistsCMakeLists(m_plugin->GetProjectDirectory(project->GetName())));
}
void MemCheckPlugin::OnCheckPopupProject(wxCommandEvent& event)
{
CHECK_CL_SHUTDOWN()
ProjectPtr project = m_mgr->GetSelectedProject();
if(project) {
CheckProject(project->GetName());
}
}
void QMakePlugin::OnExportMakefile(wxCommandEvent& event)
{
if(m_qmakeProcess) return;
QmakePluginData::BuildConfPluginData bcpd;
ProjectPtr pProj = m_mgr->GetSelectedProject();
CHECK_PTR_RET(pProj);
BuildConfigPtr bldConf = pProj->GetBuildConfiguration();
CHECK_PTR_RET(bldConf);
wxString project = pProj->GetName();
wxString config = bldConf->GetName();
if(!DoGetData(project, config, bcpd)) {
event.Skip();
return;
}
if(bcpd.m_enabled) {
// This project/configuration is qmake project
QMakeProFileGenerator generator(m_mgr, project, config);
// Regenerate the .pro file
generator.Generate();
// run qmake
wxString qmake_exe = m_conf->Read(wxString::Format(wxT("%s/qmake"), bcpd.m_qmakeConfig.c_str()));
wxString qmakespec = m_conf->Read(wxString::Format(wxT("%s/qmakespec"), bcpd.m_qmakeConfig.c_str()));
wxString qtdir = m_conf->Read(wxString::Format(wxT("%s/qtdir"), bcpd.m_qmakeConfig.c_str()));
// Create qmake comand
wxString qmake_exe_line;
qmake_exe.Trim().Trim(false);
qmakespec.Trim().Trim(false);
// Set QTDIR
DirSaver ds;
{
wxString errMsg;
ProjectPtr p = m_mgr->GetWorkspace()->FindProjectByName(project, errMsg);
if(!p) { return; }
qmake_exe_line << wxT("\"") << qmake_exe << wxT("\" -spec ") << qmakespec << wxT(" ")
<< generator.GetProFileName();
wxStringMap_t om;
om.insert(std::make_pair("QTDIR", qtdir));
EnvSetter envGuard(NULL, &om, project, config);
m_mgr->ClearOutputTab(kOutputTab_Build);
m_mgr->AppendOutputTabText(kOutputTab_Build, wxString() << "-- " << qmake_exe_line << "\n");
m_qmakeProcess =
::CreateAsyncProcess(this, qmake_exe_line, IProcessCreateDefault, p->GetFileName().GetPath());
}
}
event.Skip();
}
void CMakePlugin::DoRunCMake(ProjectPtr p)
{
CHECK_PTR_RET(p);
BuildConfigPtr buildConf = p->GetBuildConfiguration();
CHECK_COND_RET(buildConf);
// Apply the environment variables before we do anything here
#ifdef __WXMSW__
// On Windows, we need to set the bin folder of the selected compiler
wxFileName fnCxx(buildConf->GetCompiler()->GetTool("CXX"));
wxStringMap_t om;
wxString pathvar;
pathvar << fnCxx.GetPath() << clPATH_SEPARATOR << "$PATH";
om["PATH"] = pathvar;
EnvSetter es(NULL, &om, p->GetName(), buildConf->GetName());
#else
EnvSetter es(p);
#endif
CMakeGenerator generator;
if(generator.CanGenerate(p)) {
generator.Generate(p);
}
const wxString& args = buildConf->GetBuildSystemArguments();
wxString cmakeExe = GetCMake()->GetPath().GetFullPath();
// Did the user provide a generator to use?
bool hasGeneratorInArgs = (args.Find(" -G") != wxNOT_FOUND);
// Build the working directory
wxFileName fnWorkingDirectory(CMakeBuilder::GetWorkspaceBuildFolder(false), "");
wxString workingDirectory = fnWorkingDirectory.GetPath();
// Ensure that the build directory exists
fnWorkingDirectory.Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
::WrapWithQuotes(cmakeExe);
wxString command;
command << cmakeExe << " .. " << args;
if(!hasGeneratorInArgs) {
#ifdef __WXMSW__
// On Windows, generate MinGW makefiles
command << " -G\"MinGW Makefiles\"";
#endif
}
// Execute it
IProcess* proc = ::CreateAsyncProcess(this, command, IProcessCreateDefault, fnWorkingDirectory.GetPath());
if(!proc) {
::wxMessageBox(_("Failed to execute:\n") + command, "CodeLite", wxICON_ERROR | wxOK | wxCENTER,
EventNotifier::Get()->TopFrame());
return;
}
m_mgr->ShowOutputPane(_("Build"));
m_mgr->ClearOutputTab(kOutputTab_Build);
m_mgr->AppendOutputTabText(kOutputTab_Build, command + "\n");
}
AppInstancePtr
Gui::openProjectInternal(const std::string & absoluteFileName,
bool attemptToLoadAutosave)
{
QFileInfo file( QString::fromUtf8( absoluteFileName.c_str() ) );
if ( !file.exists() ) {
return AppInstancePtr();
}
QString fileUnPathed = file.fileName();
QString path = file.path() + QLatin1Char('/');
int openedProject = appPTR->isProjectAlreadyOpened(absoluteFileName);
if (openedProject != -1) {
AppInstancePtr instance = appPTR->getAppInstance(openedProject);
if (instance) {
GuiAppInstancePtr guiApp = toGuiAppInstance(instance);
if (guiApp) {
guiApp->getGui()->activateWindow();
return instance;
}
}
}
AppInstancePtr ret;
ProjectPtr project = getApp()->getProject();
///if the current graph has no value, just load the project in the same window
if ( project->isGraphWorthLess() ) {
bool ok = project->loadProject( path, fileUnPathed, false, attemptToLoadAutosave);
if (ok) {
ret = _imp->_appInstance.lock();
}
} else {
CLArgs cl;
AppInstancePtr newApp = appPTR->newAppInstance(cl, false);
bool ok = newApp->getProject()->loadProject( path, fileUnPathed, false, attemptToLoadAutosave);
if (ok) {
ret = newApp;
}
}
QSettings settings;
QStringList recentFiles = settings.value( QString::fromUtf8("recentFileList") ).toStringList();
recentFiles.removeAll( QString::fromUtf8( absoluteFileName.c_str() ) );
recentFiles.prepend( QString::fromUtf8( absoluteFileName.c_str() ) );
while (recentFiles.size() > NATRON_MAX_RECENT_FILES) {
recentFiles.removeLast();
}
settings.setValue(QString::fromUtf8("recentFileList"), recentFiles);
appPTR->updateAllRecentFileMenus();
return ret;
} // Gui::openProjectInternal
