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);
}
}
bool Copyright::Validate(wxString& content)
{
CopyrightsConfigData data;
m_mgr->GetConfigTool()->ReadObject(wxT("CopyrightsConfig"), &data);
// make sure that the template file exists
if(!wxFileName::FileExists(data.GetTemplateFilename())) {
wxMessageBox(
wxString::Format(_("Template file name '%s', does not exist!"), data.GetTemplateFilename().GetData()),
_("CodeLite"), wxICON_WARNING | wxOK);
return false;
}
// read the copyrights file
if(!ReadFileWithConversion(data.GetTemplateFilename(), content)) {
wxMessageBox(wxString::Format(_("Failed to read template file '%s'"), data.GetTemplateFilename().c_str()),
_("CodeLite"), wxICON_WARNING | wxOK);
return false;
}
// verify that the file consist only with comment code
CppWordScanner scanner(data.GetTemplateFilename().mb_str().data());
CppTokensMap l;
scanner.FindAll(l);
if(!l.is_empty()) {
if(wxMessageBox(_("Template file contains text which is not comment, continue anyways?"), _("CodeLite"),
wxICON_QUESTION | wxYES_NO) == wxNO) {
return false;
}
}
content.Replace(wxT("`"), wxT("'"));
return true;
}
void Copyright::OnInsertCopyrights(wxCommandEvent& e)
{
wxUnusedVar(e);
// read configuration
CopyrightsConfigData data;
m_mgr->GetConfigTool()->ReadObject(wxT("CopyrightsConfig"), &data);
// make sure that the template file exists
if(!wxFileName::FileExists(data.GetTemplateFilename())) {
wxMessageBox(
wxString::Format(_("Template file name '%s', does not exist!"), data.GetTemplateFilename().GetData()),
_("CodeLite"), wxICON_WARNING | wxOK);
return;
}
// read the copyrights file
wxString content;
if(!ReadFileWithConversion(data.GetTemplateFilename(), content)) {
wxMessageBox(wxString::Format(_("Failed to read template file '%s'"), data.GetTemplateFilename().c_str()),
_("CodeLite"), wxICON_WARNING | wxOK);
return;
}
IEditor* editor = m_mgr->GetActiveEditor();
if(!editor) {
wxMessageBox(wxString::Format(_("There is no active editor\n")), _("CodeLite"), wxICON_WARNING | wxOK);
return;
}
// verify that the file consist only with comment code
CppWordScanner scanner(data.GetTemplateFilename().mb_str().data());
CppTokensMap l;
scanner.FindAll(l);
if(!l.is_empty()) {
if(wxMessageBox(_("Template file contains text which is not comment, continue anyway?"), _("CodeLite"),
wxICON_QUESTION | wxYES_NO) == wxNO) {
return;
}
}
// expand constants
wxString _content = ExpandAllVariables(content, m_mgr->GetWorkspace(), wxEmptyString, wxEmptyString,
editor->GetFileName().GetFullPath());
// we are good to go :)
wxString ignoreString = data.GetIgnoreString();
ignoreString = ignoreString.Trim().Trim(false);
if(ignoreString.IsEmpty() == false) {
if(editor->GetEditorText().Find(data.GetIgnoreString()) != wxNOT_FOUND) {
clLogMessage(_("File contains ignore string, skipping it"));
return;
}
}
editor->InsertText(0, _content);
}
void Copyright::MassUpdate(const std::vector<wxFileName>& filtered_files, const wxString& content)
{
// last confirmation from the user
if(wxMessageBox(
wxString::Format(_("You are about to modify %u files. Continue?"), (unsigned int)filtered_files.size()),
_("CodeLite"),
wxYES_NO | wxICON_QUESTION) == wxNO) {
return;
}
clProgressDlg* prgDlg = NULL;
prgDlg = new clProgressDlg(NULL, _("Processing file ..."), wxT(""), (int)filtered_files.size());
CopyrightsConfigData data;
m_mgr->GetConfigTool()->ReadObject(wxT("CopyrightsConfig"), &data);
// now loop over the files and add copyrights block
for(size_t i = 0; i < filtered_files.size(); i++) {
wxFileName fn = filtered_files.at(i);
wxString file_content;
wxString _content =
ExpandAllVariables(content, m_mgr->GetWorkspace(), wxEmptyString, wxEmptyString, fn.GetFullPath());
if(ReadFileWithConversion(fn.GetFullPath(), file_content)) {
wxString msg;
// if the file contains the ignore string, skip this file
wxString ignoreString = data.GetIgnoreString();
ignoreString = ignoreString.Trim().Trim(false);
if(ignoreString.IsEmpty() == false && file_content.Find(data.GetIgnoreString()) != wxNOT_FOUND) {
msg << _("File contains ignore string, skipping it: ") << fn.GetFullName();
if(!prgDlg->Update(i, msg)) {
prgDlg->Destroy();
return;
}
} else {
msg << _("Inserting comment to file: ") << fn.GetFullName();
if(!prgDlg->Update(i, msg)) {
prgDlg->Destroy();
return;
}
file_content.Prepend(_content);
WriteFileWithBackup(fn.GetFullPath(), file_content, data.GetBackupFiles());
}
}
}
prgDlg->Destroy();
}
void CodeFormatter::OnFormatOptions(wxCommandEvent& e)
{
wxUnusedVar(e);
// load options from settings file
FormatOptions fmtroptions;
m_mgr->GetConfigTool()->ReadObject(wxT("FormatterOptions"), &fmtroptions);
wxString sampleFile;
wxString content;
sampleFile << m_mgr->GetStartupDirectory() << wxT("/astyle.sample");
ReadFileWithConversion(sampleFile, content);
CodeFormatterDlg dlg(NULL, m_mgr, this, fmtroptions, content);
dlg.ShowModal();
}
wxString CodeBeautifier::ExecuteUncrustify(const wxString &input, const wxString &ext)
{
wxString pathToBuffer = m_mgr->GetStartupDirectory() + wxT("/uncrustify.buffer");
WriteFileUTF8(pathToBuffer, input);
wxCharBuffer configFile = (m_mgr->GetStartupDirectory() + wxT("/uncrustify.cfg")).mb_str();
const int argumentsCount = 8;
char ** arguments = new char *[argumentsCount];
arguments[0] = new char[4];
strcpy(arguments[0], "-c");
arguments[1] = new char[configFile.length()];
strcpy(arguments[1], configFile.data());
arguments[2] = new char[4];
strcpy(arguments[2], "-f");
arguments[3] = new char[pathToBuffer.mb_str().length()];
strcpy(arguments[3], pathToBuffer.mb_str());
arguments[4] = new char[4];
strcpy(arguments[4], "-o");
arguments[5] = new char[pathToBuffer.mb_str().length()];
strcpy(arguments[5], pathToBuffer.mb_str());
arguments[6] = new char[4];
strcpy(arguments[6], "-l");
arguments[7] = new char[ext.mb_str().length()];
strcpy(arguments[7], ext.mb_str());
UncrustifyExecute(argumentsCount, arguments, UncrustifyErrorHandler);
wxString output;
ReadFileWithConversion(pathToBuffer, output);
for (int i = 0; i < argumentsCount; i++) {
delete [] arguments[i];
}
delete [] arguments;
return output;
}
wxStyledTextCtrl* ReplaceInFilesPanel::DoGetEditor(const wxString& fileName)
{
// look for open editor first
wxStyledTextCtrl* sci = clMainFrame::Get()->GetMainBook()->FindEditor(fileName);
if(sci) {
// FIXME: if editor is already modified, the found locations may not be accurate
return sci;
}
// not open for editing, so make our own temp editor
wxString content;
if(!ReadFileWithConversion(fileName, content)) {
wxMessageBox(_("Failed to open file:\n") + fileName, _("CodeLite - Replace"), wxICON_ERROR | wxOK);
wxLogMessage(wxT("Replace: Failed to read file ") + fileName);
return NULL;
}
sci = new wxStyledTextCtrl(this);
sci->Hide();
sci->SetText(content);
return sci;
}
void
CMakePlugin::OnExportMakefile(clBuildEvent& event)
{
const wxString project = event.GetProjectName();
const wxString config = event.GetConfigurationName();
// Get settings
const CMakeProjectSettings* settings = GetSettingsManager()->GetProjectSettings(project, config);
// Doesn't exists or not enabled
if (!settings || !settings->enabled) {
// Unable to export makefile
event.Skip();
return;
}
// Get project directory - this is directory where the makefile is stored
const wxFileName projectDir = GetProjectDirectory(project);
// Targets forward inspired by
// https://gist.github.com/doitian/4978329
// Content of the generated makefile
wxString content = wxString() <<
"# Generated by CMakePlugin\n"
".PHONY: all clean $(MAKECMDGOALS)\n"
"\n"
;
// Parent project is set
if (!settings->parentProject.IsEmpty()) {
// Configure parent project instead
const wxString& parentProject = settings->parentProject;
settings = GetSettingsManager()->GetProjectSettings(parentProject, config);
// Parent project not found
if (!settings || !settings->enabled) {
CL_ERROR("Unable to find or not enabled parent project "
"'" + parentProject + "' for project '" + project + "'");
return;
}
// Get parent project directory
wxFileName parentProjectDir = GetProjectDirectory(parentProject);
parentProjectDir.MakeRelativeTo(projectDir.GetFullPath());
// Path is relative so UNIX path system can be used
const wxString parentProjectDirEsc = parentProjectDir.GetPath(wxPATH_NO_SEPARATOR, wxPATH_UNIX);
// Redirect make to the parent project
content <<
"# Parent project\n"
"PARENT := " << parentProjectDirEsc << "\n"
"PARENT_MAKEFILE := " << parentProject << ".mk\n"
"\n"
"all:\n"
"\t$(MAKE) -C \"$(PARENT)\" -f \"$(PARENT_MAKEFILE)\" " << project << "\n"
"\n"
"clean:\n"
"\t$(MAKE) -C \"$(PARENT)\" -f \"$(PARENT_MAKEFILE)\" " << project << " clean\n"
"\n"
;
} else {
// Macro expander
// FIXME use IMacroManager (unable to find it yet)
MacroManager* macro = MacroManager::Instance();
wxASSERT(macro);
// Get variables
// Expand variables for final project
const wxString cmake = GetConfiguration()->GetProgramPath();
wxFileName sourceDir = wxFileName::DirName(macro->Expand(settings->sourceDirectory, GetManager(), project, config));
wxFileName buildDir = wxFileName::DirName(macro->Expand(settings->buildDirectory, GetManager(), project, config));
// Source dir must be relative to build directory (here is cmake called)
sourceDir.MakeRelativeTo(buildDir.GetFullPath());
// Build dir must be relative to project directory
buildDir.MakeRelativeTo(projectDir.GetFullPath());
// Relative paths
const wxString sourceDirEsc = sourceDir.GetPath(wxPATH_NO_SEPARATOR, wxPATH_UNIX);
const wxString buildDirEsc = buildDir.GetPath(wxPATH_NO_SEPARATOR, wxPATH_UNIX);
// Generated makefile
content <<
"CMAKE := \"" << cmake << "\"\n"
"BUILD_DIR := " << buildDirEsc << "\n"
"SOURCE_DIR := " << sourceDirEsc << "\n"
"CMAKE_ARGS := " << CreateArguments(*settings, *m_configuration.get()) << "\n"
"\n"
"# Building project(s)\n"
"$(or $(lastword $(MAKECMDGOALS)), all): $(BUILD_DIR)/Makefile\n"
"\t$(MAKE) -C \"$(BUILD_DIR)\" $(MAKECMDGOALS)\n"
"\n"
"# Building directory\n"
"$(BUILD_DIR):\n"
"\t$(CMAKE) -E make_directory \"$(BUILD_DIR)\"\n"
"\n"
"# Rule that detects if cmake is called\n"
"$(BUILD_DIR)/Makefile: .cmake_dirty | $(BUILD_DIR)\n"
"\tcd \"$(BUILD_DIR)\" && $(CMAKE) $(CMAKE_ARGS) \"$(SOURCE_DIR)\"\n"
"\n"
"# This rule / file allows force cmake run\n"
".cmake_dirty:\n"
"\t@echo '' > .cmake_dirty\n"
"\n"
;
}
// Path to makefile - called project directory required
wxFileName makefile = projectDir;
makefile.SetName(project);
makefile.SetExt("mk");
// Read old content from disk
wxString oldContent;
bool ok = ReadFileWithConversion(makefile.GetFullPath(), oldContent);
// Write only if there are some changes
if (!ok || content != oldContent) {
// Write make file content
wxFile file(makefile.GetFullPath(), wxFile::write);
if (!file.Write(content)) {
CL_ERROR("Unable to write custom makefile (CMakePlugin): " + makefile.GetFullPath());
}
}
}
void QMakePlugin::OnNewQmakeBasedProject(wxCommandEvent& event)
{
wxUnusedVar ( event );
if (m_conf->GetAllConfigurations().IsEmpty()) {
wxMessageBox(_("There is no qmake defined, please define one from 'Plugins -> Qmake -> Settings'"), _("CodeLite"), wxOK|wxICON_WARNING|wxCENTER, m_mgr->GetTheApp()->GetTopWindow());
return;
}
NewQtProjDlg dlg(m_mgr->GetTheApp()->GetTopWindow(), m_conf, m_mgr);
if (dlg.ShowModal() == wxID_OK) {
wxString kind = dlg.GetProjectKind();
wxString name = dlg.GetProjectName();
wxString path = dlg.GetProjectPath();
wxString configRelease= wxT("0000");
wxString config = wxT("0000");
wxString templateFile = m_mgr->GetStartupDirectory();
wxString type = wxEmptyString;
wxString qmakeSettings= dlg.GetQmake();
wxString qmake;
wxString content;
if ( kind == wxT("Static Library") ) {
type = Project::STATIC_LIBRARY;
} else if ( kind == wxT("Dynamic Library") ) {
type = Project::DYNAMIC_LIBRARY;
} else if ( kind == wxT("Console") ) {
type = Project::EXECUTABLE;
configRelease = wxT("0017CONFIG += console");
config = wxT("0023CONFIG += console debug");
} else {
type = Project::EXECUTABLE;
config = wxT("0015CONFIG += debug");
configRelease = wxT("0000");
}
wxString filename(m_mgr->GetStartupDirectory() + wxT("/templates/qmake/qmake.project"));
if (!ReadFileWithConversion(filename, content)) {
return;
}
// prepend the string lenght
qmake = wxString::Format(wxT("%04d%s"), qmakeSettings.Length(), qmakeSettings.c_str());
content.Replace(wxT("$(TYPE)") , type);
content.Replace(wxT("$(NAME)") , name);
content.Replace(wxT("$(CONFIG)"), config);
content.Replace(wxT("$(RELEASE_CONFIG)"), configRelease);
content.Replace(wxT("$(QMAKE)"), qmake);
//save the file to the disk
{
DirSaver ds;
if ( !wxSetWorkingDirectory(path) ) {
wxMessageBox(_("Invalid project path!"), _("CodeLite"), wxOK|wxCENTER|wxICON_WARNING);
return;
}
if ( dlg.GetCreateDirectory() ) {
wxMkdir(name);
wxSetWorkingDirectory(name);
}
if ( !WriteFileWithBackup(name + wxT(".project"), content, false) ) {
wxMessageBox(wxString::Format(_("Failed to create .project file '%s'"), wxString(name + wxT(".project")).c_str()),
_("CodeLite"), wxOK|wxCENTER|wxICON_WARNING);
return;
}
path = wxGetCwd();
path << wxFileName::GetPathSeparator() << name << wxT(".project");
m_mgr->AddProject(path);
}
}
}
void wxFormBuilder::DoCreateWxFormBuilderProject(const wxFBItemInfo& data)
{
// add new virtual folder to the selected virtual directory
wxString formbuilderVD;
formbuilderVD = data.virtualFolder.BeforeFirst(wxT(':'));
m_mgr->CreateGroupFolder(formbuilderVD, wxT("formbuilder"));
wxString templateFile(m_mgr->GetInstallDirectory() + wxT("/templates/formbuilder/")); //todo,todo
switch (data.kind) {
default:
case wxFBItemKind_Dialog:
templateFile << wxT("DialogTemplate.fbp");
break;
case wxFBItemKind_Frame:
templateFile << wxT("FrameTemplate.fbp");
break;
case wxFBItemKind_Panel:
templateFile << wxT("PanelTemplate.fbp");
break;
case wxFBItemKind_Dialog_With_Buttons:
templateFile << wxT("DialogTemplateWithButtons.fbp");
break;
}
wxFileName tmplFile(templateFile);
if (!tmplFile.FileExists()) {
wxMessageBox(wxString::Format(wxT("Cant find wxFormBuilder template file '%s'"), tmplFile.GetFullPath().c_str()), wxT("EmbeddedLite"), wxOK|wxCENTER|wxICON_WARNING);
return;
}
// place the files under the VD's project owner
wxString err_msg;
wxString project = data.virtualFolder.BeforeFirst(wxT(':'));
ProjectPtr proj = m_mgr->GetSolution()->FindProjectByName(project, err_msg);
if (proj) {
wxString files_path = proj->GetFileName().GetPath(wxPATH_GET_SEPARATOR|wxPATH_GET_VOLUME);
// copy the file to here
wxFileName fbpFile(files_path, data.file + wxT(".fbp"));
if (!wxCopyFile(tmplFile.GetFullPath(), fbpFile.GetFullPath())) {
wxMessageBox(wxString::Format(wxT("Failed to copy tempalte file to '%s'"), fbpFile.GetFullPath().c_str()), wxT("EmbeddedLite"), wxOK|wxCENTER|wxICON_WARNING);
return;
}
// open the file, and replace expand its macros
wxString content;
if (!ReadFileWithConversion(fbpFile.GetFullPath().c_str(), content)) {
wxMessageBox(wxString::Format(wxT("Failed to read file '%s'"), fbpFile.GetFullPath().c_str()), wxT("EmbeddedLite"), wxOK|wxCENTER|wxICON_WARNING);
return;
}
content.Replace(wxT("$(BaseFileName)"), data.file);
content.Replace(wxT("$(ProjectName)"), data.className);
content.Replace(wxT("$(Title)"), data.title);
content.Replace(wxT("$(ClassName)"), data.className);
if (!WriteFileWithBackup(fbpFile.GetFullPath().c_str(), content, false)) {
wxMessageBox(wxString::Format(wxT("Failed to write file '%s'"), fbpFile.GetFullPath().c_str()), wxT("EmbeddedLite"), wxOK|wxCENTER|wxICON_WARNING);
return;
}
// add the file to the project
wxArrayString paths;
paths.Add(fbpFile.GetFullPath());
m_mgr->AddFilesToGroupFolder(project + wxT(":formbuilder"), paths);
// // first we launch wxFB with the -g flag set
wxString genFileCmd;
genFileCmd << GetWxFBPath() << wxT(" -g ") << fbpFile.GetFullPath();
wxArrayString dummy, filesToAdd;
ProcUtils::SafeExecuteCommand(genFileCmd, dummy);
wxFileName cppFile(fbpFile.GetPath(), data.file + wxT(".cpp"));
wxFileName headerFile(fbpFile.GetPath(), data.file + wxT(".h"));
if (cppFile.FileExists()) {
filesToAdd.Add(cppFile.GetFullPath());
}
if (headerFile.FileExists()) {
filesToAdd.Add(headerFile.GetFullPath());
}
if (filesToAdd.GetCount()) {
m_mgr->AddFilesToGroupFolder(data.virtualFolder, filesToAdd);
}
DoLaunchWxFB(fbpFile.GetFullPath());
}
}
void WizardsPlugin::CreateWxProject(NewWxProjectInfo &info)
{
//TODO:: Implement this ...
wxString basedir = m_mgr->GetStartupDirectory();
//we first create the project files
if (info.GetType() == wxProjectTypeGUI) {
//we are creating a project of type GUI
wxString projectConent;
wxString mainFrameCppContent;
wxString mainFrameHContent;
wxString appCppConent;
wxString apphConent;
wxString rcContent;
wxString pchContent;
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/wxproject.project.wizard"), projectConent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/mainframe.cpp.wizard"), mainFrameCppContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/mainframe.h.wizard"), mainFrameHContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/app.h.wizard"), apphConent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/app.cpp.wizard"), appCppConent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/resources.rc.wizard"), rcContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/wx_pch.h.wizard"), pchContent)) {
return;
}
ExpandVariables(projectConent, info);
ExpandVariables(mainFrameCppContent, info);
ExpandVariables(mainFrameHContent, info);
ExpandVariables(apphConent, info);
ExpandVariables(appCppConent, info);
//Write the files content into the project directory
DirSaver ds;
wxSetWorkingDirectory(info.GetPath());
wxString projname = info.GetName();
projname.MakeLower();
wxString appfilename = projname + wxT("_app");
wxString framefilename = projname + wxT("_frame");
WriteFile(framefilename + wxT(".cpp"), mainFrameCppContent);
WriteFile(framefilename + wxT(".h"), mainFrameHContent);
WriteFile(appfilename + wxT(".h"), apphConent);
WriteFile(appfilename+ wxT(".cpp"), appCppConent);
if( info.GetFlags() & wxWidgetsWinRes ) WriteFile(wxT("resources.rc"), rcContent);
if( info.GetFlags() & wxWidgetsPCH ) WriteFile(wxT("wx_pch.h"), pchContent);
WriteFile(info.GetName() + wxT(".project"), projectConent);
//If every this is OK, add the project as well
m_mgr->AddProject(info.GetName() + wxT(".project"));
} else if (info.GetType() == wxProjectTypeGUIFBDialog) {
//we are creating a project of type GUI (dialog generated by wxFormBuilder)
wxString projectContent;
wxString mainFrameCppContent;
wxString mainFrameHContent;
wxString appCppContent;
wxString apphContent;
wxString fbContent;
wxString rcContent;
wxString pchContent;
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/wxproject-fb.project.wizard"), projectContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/gui-dialog.cpp.wizard"), mainFrameCppContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/gui-dialog.h.wizard"), mainFrameHContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/main-dialog.h.wizard"), apphContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/main-dialog.cpp.wizard"), appCppContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/gui-dialog.fbp.wizard"), fbContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/resources.rc.wizard"), rcContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/wx_pch.h.wizard"), pchContent)) {
return;
}
ExpandVariables(projectContent, info);
ExpandVariables(mainFrameCppContent, info);
ExpandVariables(mainFrameHContent, info);
ExpandVariables(apphContent, info);
ExpandVariables(appCppContent, info);
//Write the files content into the project directory
DirSaver ds;
wxSetWorkingDirectory(info.GetPath());
wxString projname = info.GetName();
projname.MakeLower();
wxString appfilename = projname + wxT("_app");
WriteFile(wxT("gui.cpp"), mainFrameCppContent);
WriteFile(wxT("gui.h"), mainFrameHContent);
WriteFile(appfilename + wxT(".h"), apphContent);
WriteFile(appfilename+ wxT(".cpp"), appCppContent);
WriteFile(wxT("gui.fbp"), fbContent);
if( info.GetFlags() & wxWidgetsWinRes ) WriteFile(wxT("resources.rc"), rcContent);
if( info.GetFlags() & wxWidgetsPCH ) WriteFile(wxT("wx_pch.h"), pchContent);
WriteFile(info.GetName() + wxT(".project"), projectContent);
//If every this is OK, add the project as well
m_mgr->AddProject(info.GetName() + wxT(".project"));
} else if (info.GetType() == wxProjectTypeGUIFBFrame) {
//we are creating a project of type GUI (dialog generated by wxFormBuilder)
wxString projectContent;
wxString mainFrameCppContent;
wxString mainFrameHContent;
wxString appCppContent;
wxString apphContent;
wxString fbContent;
wxString pchContent;
wxString rcContent;
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/wxproject-fb.project.wizard"), projectContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/gui-frame.cpp.wizard"), mainFrameCppContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/gui-frame.h.wizard"), mainFrameHContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/main-frame.h.wizard"), apphContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/main-frame.cpp.wizard"), appCppContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/gui-frame.fbp.wizard"), fbContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/resources.rc.wizard"), rcContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/wx_pch.h.wizard"), pchContent)) {
return;
}
ExpandVariables(projectContent, info);
ExpandVariables(mainFrameCppContent, info);
ExpandVariables(mainFrameHContent, info);
ExpandVariables(apphContent, info);
ExpandVariables(appCppContent, info);
//Write the files content into the project directory
DirSaver ds;
wxSetWorkingDirectory(info.GetPath());
wxString projname = info.GetName();
projname.MakeLower();
wxString appfilename = projname + wxT("_app");
WriteFile(wxT("gui.cpp"), mainFrameCppContent);
WriteFile(wxT("gui.h"), mainFrameHContent);
WriteFile(appfilename + wxT(".h"), apphContent);
WriteFile(appfilename+ wxT(".cpp"), appCppContent);
WriteFile(wxT("gui.fbp"), fbContent);
if( info.GetFlags() & wxWidgetsWinRes ) WriteFile(wxT("resources.rc"), rcContent);
if( info.GetFlags() & wxWidgetsPCH ) WriteFile(wxT("wx_pch.h"), pchContent);
WriteFile(info.GetName() + wxT(".project"), projectContent);
//If every this is OK, add the project as well
m_mgr->AddProject(info.GetName() + wxT(".project"));
} else if (info.GetType() == wxProjectTypeSimpleMain) {
//we are creating a project of type console app
wxString projectConent;
wxString appCppConent;
wxString pchContent;
wxString rcContent;
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/wxmain.project.wizard"), projectConent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/main.cpp.wizard"), appCppConent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/resources.rc.wizard"), rcContent)) {
return;
}
if (!ReadFileWithConversion(basedir + wxT("/templates/gizmos/wx_pch.h.wizard"), pchContent)) {
return;
}
ExpandVariables(projectConent, info);
ExpandVariables(appCppConent, info);
//Write the files content into the project directory
DirSaver ds;
wxSetWorkingDirectory(info.GetPath());
wxString projname = info.GetName();
projname.MakeLower();
wxString appfilename = projname;
WriteFile(appfilename+ wxT(".cpp"), appCppConent);
if( info.GetFlags() & wxWidgetsWinRes ) WriteFile(wxT("resources.rc"), rcContent);
if( info.GetFlags() & wxWidgetsPCH ) WriteFile(wxT("wx_pch.h"), pchContent);
WriteFile(info.GetName() + wxT(".project"), projectConent);
//If every this is OK, add the project as well
m_mgr->AddProject(info.GetName() + wxT(".project"));
}
}
void WizardsPlugin::DoCreateNewPlugin()
{
//Load the wizard
PluginWizard wiz(wxTheApp->GetTopWindow());
NewPluginData data;
if (wiz.Run(data)) {
//load the template file and replace all variables with the
//actual values provided by user
wxString filename(m_mgr->GetStartupDirectory() + wxT("/templates/gizmos/liteeditor-plugin.project.wizard"));
wxString content;
if (!ReadFileWithConversion(filename, content)) {
return;
}
// Convert the paths provided by user to relative paths
wxFileName fn(data.GetCodelitePath(), "");
if ( !fn.MakeRelativeTo( wxFileName(data.GetProjectPath()).GetPath()) ) {
wxLogMessage(wxT("Warning: Failed to convert paths to relative path."));
}
#ifdef __WXMSW__
wxString dllExt(wxT("dll"));
#else
wxString dllExt(wxT("so"));
#endif
wxString clpath = fn.GetFullPath();
fn.Normalize(); // Remove all .. and . from the path
if ( clpath.EndsWith("/") || clpath.EndsWith("\\") ) {
clpath.RemoveLast();
}
content.Replace(wxT("$(CodeLitePath)"), clpath);
content.Replace(wxT("$(DllExt)"), dllExt);
content.Replace(wxT("$(PluginName)"), data.GetPluginName());
wxString baseFileName = data.GetPluginName();
baseFileName.MakeLower();
content.Replace(wxT("$(BaseFileName)"), baseFileName);
content.Replace(wxT("$(ProjectName)"), data.GetPluginName());
//save the file to the disk
wxString projectFileName;
projectFileName << data.GetProjectPath();
{
wxLogNull noLog;
::wxMkdir( wxFileName(data.GetProjectPath()).GetPath() );
}
wxFFile file;
if (!file.Open(projectFileName, wxT("w+b"))) {
return;
}
file.Write(content);
file.Close();
//Create the plugin source and header files
wxFileName srcFile(wxFileName(data.GetProjectPath()).GetPath(), baseFileName);
srcFile.SetExt("cpp");
wxFileName headerFile(wxFileName(data.GetProjectPath()).GetPath(), baseFileName);
headerFile.SetExt("h");
//---------------------------------------------------------------
//write the content of the file based on the file template
//---------------------------------------------------------------
//Generate the source files
filename = m_mgr->GetStartupDirectory() + wxT("/templates/gizmos/plugin.cpp.wizard");
content.Clear();
if (!ReadFileWithConversion(filename, content)) {
wxMessageBox(_("Failed to load wizard's file 'plugin.cpp.wizard'"), _("CodeLite"), wxICON_WARNING | wxOK);
return;
}
// Expand macros
content.Replace(wxT("$(PluginName)"), data.GetPluginName());
content.Replace(wxT("$(BaseFileName)"), baseFileName);
content.Replace(wxT("$(PluginShortName)"), data.GetPluginName());
content.Replace(wxT("$(PluginLongName)"), data.GetPluginDescription());
content.Replace(wxT("$(UserName)"), wxGetUserName().c_str());
// Notify the formatter plugin to format the plugin source files
clSourceFormatEvent evtFormat(wxEVT_FORMAT_STRING);
evtFormat.SetInputString( content );
EventNotifier::Get()->ProcessEvent( evtFormat );
content = evtFormat.GetFormattedString();
// Write it down
file.Open(srcFile.GetFullPath(), wxT("w+b"));
file.Write(content);
file.Close();
//create the header file
filename = m_mgr->GetStartupDirectory() + wxT("/templates/gizmos/plugin.h.wizard");
content.Clear();
if (!ReadFileWithConversion(filename, content)) {
wxMessageBox(_("Failed to load wizard's file 'plugin.h.wizard'"), _("CodeLite"), wxICON_WARNING | wxOK);
return;
}
// Expand macros
content.Replace(wxT("$(PluginName)"), data.GetPluginName());
content.Replace(wxT("$(BaseFileName)"), baseFileName);
content.Replace(wxT("$(PluginShortName)"), data.GetPluginName());
content.Replace(wxT("$(PluginLongName)"), data.GetPluginDescription());
content.Replace(wxT("$(UserName)"), wxGetUserName().c_str());
// format the content
evtFormat.SetString(content);
EventNotifier::Get()->ProcessEvent( evtFormat );
content = evtFormat.GetString();
// Write it down
file.Open(headerFile.GetFullPath(), wxT("w+b"));
file.Write(content);
file.Close();
//add the new project to the workspace
wxString errMsg;
//convert the path to be full path as required by the
//workspace manager
m_mgr->AddProject(projectFileName);
}
}
