void WorkspaceWork::RemovePackage(String from_package)
{
String active = UnixPath(GetActivePackage());
if(IsNull(from_package) && !PromptYesNo(NFormat(
"Remove package [* \1%s\1] from uses sections of all current packages ?", active)))
return;
PackageOp(GetActivePackage(), from_package, Null);
}
void WorkspaceWork::DnDInsert(int line, PasteClip& d)
{
if(GetActivePackage() == METAPACKAGE)
return;
if(GetInternalPtr<UppList>(d, "package-file") == &filelist && d.Accept())
DoMove(line < fileindex.GetCount() ? fileindex[line] : actual.file.GetCount(), true);
}
void WorkspaceWork::RemoveFile()
{
int i = filelist.GetCursor();
int s = filelist.GetSbPos();
bool separator = false;
if(i >= 0 && i < fileindex.GetCount()) {
int fx = fileindex[i];
separator = actual.file[fx].separator;
if(separator && closed.Find(GetActiveSepfo()) >= 0) {
int px = fx;
while(--px >= 0 && !actual.file[fx].separator)
;
if(px >= 0) {
int c = closed.Find(Sepfo(GetActivePackage(), actual.file[px]));
if(c >= 0)
closed.Unlink(c);
}
}
actual.file.Remove(fx);
}
if(separator || IsAux())
SaveLoadPackageNS(false);
else
SaveLoadPackage(false);
if (separator || FileRemove()) {
filelist.SetSbPos(s);
filelist.SetCursor(i);
}
}
void WorkspaceWork::CloseAllGroups()
{
for(int i = 0; i < actual.file.GetCount(); i++)
if(actual.file[i].separator)
closed.FindPut(Sepfo(GetActivePackage(), actual.file[i]));
SaveLoadPackage();
}
void WorkspaceWork::PackageCursor()
{
InvalidatePackageCache();
filelist.WhenBar.Clear();
actualpackage = GetActivePackage();
svn_dirs = false;
if(actualpackage.IsEmpty()) return;
if(actualpackage == METAPACKAGE) {
actual.file.Clear();
actual.file.AddPick(Package::File(String(HELPNAME)));
Vector<String> d = GetUppDirs();
for(int i = 0; i < d.GetCount(); i++)
actual.file.AddPick(Package::File(AppendFileName(d[i], "$.tpp")));
actual.file.AddPick(Package::File(ConfigFile("global.defs")));
}
else {
String pp = PackagePathA(actualpackage);
RealizePath(pp);
actual.Load(pp);
}
LoadActualPackage();
filelist.Enable();
if(actualpackage != METAPACKAGE)
filelist.WhenBar = THISBACK(FileMenu);
svn_dirs = SvnDirs(true).GetCount();
}
void WorkspaceWork::AddFile(ADDFILE af)
{
String active = GetActivePackage();
if(active.IsEmpty()) return;
FileSel *fs = &OutputFs();
RealizeDirectory(GetLocalDir());
switch(af)
{
case PACKAGE_FILE: fs = &BasedSourceFs(); fs->BaseDir(GetFileFolder(PackagePathA(active))); break;
case ANY_FILE: fs = &AnySourceFs(); break;
case OUTPUT_FILE: fs->ActiveDir(GetOutputDir()); break;
case CONFIG_FILE: fs->ActiveDir(GetConfigDir()); break;
case HOME_FILE: fs->ActiveDir(GetHomeDirectory()); break;
case LOCAL_FILE: fs->ActiveDir(GetLocalDir()); break;
default: ; // GCC warns otherwise
}
if(!fs->ExecuteOpen("Add files to package..")) return;
int fci = filelist.GetCursor();
int cs = filelist.GetSbPos();
int ci = fci >= 0 && fci < fileindex.GetCount() ? fileindex[fci] : -1;
for(int i = 0; i < fs->GetCount(); i++) {
Package::File& f = ci >= 0 ? actual.file.Insert(ci++) : actual.file.Add();
f = (*fs)[i];
f.readonly = fs->GetReadOnly();
}
SaveLoadPackage(false);
filelist.SetSbPos(cs);
filelist.SetCursor(fci >= 0 ? fci : filelist.GetCount() - 1);
FileSelected();
}
void WorkspaceWork::RenamePackage()
{
if(IsAux() || !package.IsCursor())
return;
WithRenamePackageLayout<TopWindow> dlg;
CtrlLayoutOKCancel(dlg, "Rename package");
dlg.name.SetFilter(FilterPackageName);
dlg.name <<= package.Get(package.GetCursor()).name;
dlg.name.SelectAll();
again:
if(dlg.Execute() != IDOK)
return;
String pn = ~dlg.name;
if(!RenamePackageFs(GetActivePackage(), pn))
goto again;
PackageOp(GetActivePackage(), Null, pn);
}
void WorkspaceWork::AddSeparator()
{
String active = GetActivePackage();
if(active.IsEmpty()) return;
String name;
if(!EditText(name, "Insert separator", "Name"))
return;
AddItem(~name, true, true);
}
void WorkspaceWork::TouchFile(const String& path)
{
if(!showtime)
return;
String n = GetFileName(path);
for(int i = 0; i < filelist.GetCount(); i++) {
FileList::File f = filelist[i];
if(f.name == n && path == SourcePath(GetActivePackage(), f.name))
filelist.Set(i, f.name, f.icon, f.font, f.ink, false, 0,
Null, SColorMark, Null, Null, Null, SColorMark);
}
}
void WorkspaceWork::LoadActualPackage()
{
Time utime = FileGetTime(ConfigFile("version"));
filelist.Clear();
fileindex.Clear();
bool open = true;
Time tm = GetSysTime();
for(int i = 0; i < actual.file.GetCount(); i++) {
Package::File& f = actual.file[i];
if(f.separator) {
open = closed.Find(Sepfo(actualpackage, f)) < 0;
filelist.Add(f, open ? IdeImg::SeparatorClose() : IdeImg::SeparatorOpen(),
ListFont().Bold(), open ? SColorMark : SColorText, true, 0, Null);
fileindex.Add(i);
}
else
if(open) {
Color uln = Null;
String p = SourcePath(GetActivePackage(), f);
if(showtime) {
FindFile ff(p);
if(ff) {
Time ftm = Time(ff.GetLastWriteTime());
if(ftm > utime) {
int64 t = tm - ftm;
if(t < 24 * 3600)
uln = SColorMark;
else
if(t < 32 * 24 * 3600)
uln = SColorDisabled;
}
}
}
Image m = IdeFileImage(f, f.optimize_speed, false, f.pch);
if(GetFileExt(p) == ".tpp" && IsFolder(p)) {
if(FileExists(AppendFileName(p, "all.i")))
m = TopicImg::IGroup();
else
m = TopicImg::Group();
}
#ifdef PLATFORM_WIN32
p = ToLower(p);
#endif
if(errorfiles.Find(p) >= 0) {
m = ImageOverRed(m);
uln = LtRed;
}
filelist.Add(f, m, ListFont(), SColorText, false, 0,
Null, SColorMark, Null, Null, Null, uln);
fileindex.Add(i);
}
}
}
void Ide::PackageCursor()
{
WorkspaceWork::PackageCursor();
String p = GetActivePackage();
if(p.IsEmpty()) return;
String ef = ToLower(NormalizePath(editfile));
for(int i = 0; i < filelist.GetCount(); i++)
if(ToLower(NormalizePath(SourcePath(p, filelist[i]))) == ef) {
filelist.SetCursor(i);
break;
}
SetBar();
}
void WorkspaceWork::AddTopicGroup()
{
String package = GetActivePackage();
if(IsNull(package)) return;
Tpp dlg;
dlg.Load(PackageDirectory(package));
if(dlg.Run() != IDOK) return;
String g = dlg.GetName();
if(g == "app.tpp") {
String h = SourcePath(package, g);
RealizeDirectory(h);
SaveFile(AppendFileName(h, "all.i"), "");
}
if(g.GetCount())
AddItem(g, false, false);
}
void WorkspaceWork::PackageMenu(Bar& menu)
{
if(!menu.IsScanKeys()) {
bool cando = !IsAux() && package.IsCursor();
String act = UnixPath(GetActivePackage());
menu.Add(cando, ~NFormat("Add package to '%s'", act), IdeImg::package_add(), THISBACK(AddNormalUses));
RemovePackageMenu(menu);
if(menu.IsMenuBar()) {
menu.Add(cando, "Rename package..", THISBACK(RenamePackage));
menu.Add(cando, "Delete package", THISBACK(DeletePackage));
menu.Separator();
menu.Add(cando, "Optimize for speed", THISBACK(TogglePackageSpeed))
.Check(actual.optimize_speed);
menu.Separator();
BuildPackageMenu(menu);
menu.Add("Open Package Directory",THISBACK(OpenPackageFolder));
}
}
}
void WorkspaceWork::DeletePackage()
{
String active = GetActivePackage();
if(package.GetCursor() == 0) {
Exclamation("Cannot delete the main package!");
return;
}
if(IsAux() || !package.IsCursor() ||
!PromptYesNo("Do you really want to delete package [* \1" + active + "\1]?&&"
"[/ Warning:] [* Package will only be removed&"
"from packages of current workspace!]"))
return;
if(!PromptYesNo("This operation is irreversible.&Do you really want to proceed?"))
return;
if(!DeleteFolderDeep(GetFileFolder(GetActivePackagePath()))) {
Exclamation("Deleting directory has failed.");
return;
}
PackageOp(active, Null, Null);
}
void WorkspaceWork::DoImportTree(const String& dir, const String& mask, bool sep, Progress& pi, int from)
{
String active = GetActivePackage();
if(active.IsEmpty()) return;
FindFile ff(AppendFileName(dir, "*.*"));
Vector<String> dirs, files;
while(ff) {
String p = AppendFileName(dir, ff.GetName());
if(ff.IsFile() && PatternMatchMulti(mask, ff.GetName()))
files.Add(p);
if(ff.IsFolder())
dirs.Add(p);
ff.Next();
}
String relPath(dir.Mid(from)),
absPath = SourcePath(active, relPath);
if(sep && files.GetCount()) {
if(!DirectoryExists(absPath))
if(!RealizeDirectory(absPath))
throw Format("An error occurred while creating the directory:&\1%s", absPath);
Package::File& f = actual.file.Add();
f = relPath;
f.separator = f.readonly = true;
}
Sort(files, &FileOrder_);
Sort(dirs, &FileOrder_);
for(int i = 0; i < files.GetCount(); i++) {
if(pi.StepCanceled())
throw String();
String name = GetFileName(files[i]);
if(FileCopy(files[i], AppendFileName(absPath, name))) {
Package::File& f = actual.file.Add();
f = AppendFileName(relPath, name);
f.separator = f.readonly = false;
}
else
throw Format("An error occurred while copying the file:&\1%s", files[i]);
}
for(int i = 0; i < dirs.GetCount(); i++)
DoImportTree(dirs[i], mask, true, pi, from);
}
void WorkspaceWork::RenameFile()
{
if(!filelist.IsCursor()) return;
String n = GetActiveFileName();
int i = filelist.GetCursor();
if(i < 0 || i >= fileindex.GetCount())
return;
int ii = fileindex[i];
WithEditStringLayout<TopWindow> dlg;
CtrlLayoutOKCancel(dlg, "Rename file");
dlg.lbl = "New name";
dlg.text <<= n;
dlg.Open();
dlg.text.SetFocus();
int l = int(GetFileNamePos(n) - ~n);
int h = int(GetFileExtPos(n) - ~n);
if(l >= h)
l = 0;
dlg.text.SetSelection(l, h);
if(dlg.Run() != IDOK)
return;
n = ~dlg.text;
String spath = GetActiveFilePath();
String dpath = SourcePath(GetActivePackage(), n);
if(!filelist[i].isdir && GetFileLength(spath) >= 0) {
if(!::MoveFile(spath, dpath)) {
Exclamation("Failed to rename the file.&&" + GetErrorMessage(GetLastError()));
return;
}
}
FileRename(dpath);
int s = filelist.GetSbPos();
(String &)actual.file[ii] = n;
SaveLoadPackage(false);
filelist.SetSbPos(s);
filelist.SetCursor(i);
if(GetFileExt(spath) == ".iml" || GetFileExt(dpath) == ".iml")
SyncWorkspace();
}
void WorkspaceWork::Import()
{
String active = GetActivePackage();
if(active.IsEmpty()) return;
ImportDlg dlg;
if(dlg.Execute() != IDOK)
return;
Progress pi("Importing file %d");
int fci = filelist.GetCursor();
int cs = filelist.GetSbPos();
try {
DoImport(~dlg.folder, ~dlg.files, false, pi, ~dlg.tree);
}
catch(String msg) {
if(!msg.IsEmpty())
Exclamation(msg);
}
SaveLoadPackage(false);
filelist.SetSbPos(cs);
filelist.SetCursor(fci >= 0 ? fci : filelist.GetCount() - 1);
FileSelected();
}
void WorkspaceWork::ShowFile(int pi)
{
bool open = true;
Sepfo sf;
for(int i = 0; i < actual.file.GetCount(); i++) {
if(actual.file[i].separator) {
sf = Sepfo(GetActivePackage(), actual.file[i]);
open = closed.Find(sf) < 0;
}
else
if(i == pi) {
if(!open) {
int i = filelist.GetCursor();
int s = filelist.GetSbPos();
closed.UnlinkKey(sf);
SaveLoadPackage(false);
filelist.SetSbPos(s);
filelist.SetCursor(i);
}
return;
}
}
}
void WorkspaceWork::RemovePackageMenu(Bar& bar)
{
if(bar.IsScanKeys() || bar.IsScanHelp() || !bar.IsMenuBar())
return;
String active = UnixPath(GetActivePackage());
int usecnt = 0;
for(int i = 0; i < package.GetCount(); i++) {
String pn = UnixPath(package[i].name);
Package prj;
String pp = PackagePath(pn);
prj.Load(pp);
for(int i = 0; i < prj.uses.GetCount(); i++)
if(UnixPath(prj.uses[i].text) == active) {
usecnt++;
bar.Add("Remove from '" + pn + '\'', THISBACK1(RemovePackage, pn))
.Help(NFormat("Remove package '%s' from uses section in '%s'", active, pp));
}
}
if(usecnt > 1) {
bar.MenuSeparator();
bar.Add("Remove all uses", THISBACK1(RemovePackage, String(Null)))
.Help(NFormat("Remove package '%s' from all uses in active project and its submodules", active));
}
}
void WorkspaceWork::DoImport(const String& dir, const String& mask, bool sep, Progress& pi)
{
String active = GetActivePackage();
if(active.IsEmpty()) return;
FindFile ff(AppendFileName(dir, "*.*"));
Vector<String> dirs, files;
while(ff) {
String p = AppendFileName(dir, ff.GetName());
if(ff.IsFile() && PatternMatchMulti(mask, ff.GetName()))
files.Add(p);
if(ff.IsFolder())
dirs.Add(p);
ff.Next();
}
if(sep && files.GetCount()) {
Package::File& f = actual.file.Add();
f = GetFileTitle(dir);
f.separator = f.readonly = true;
}
Sort(files, &FileOrder_);
Sort(dirs, &FileOrder_);
for(int i = 0; i < files.GetCount(); i++) {
if(pi.StepCanceled())
throw String();
String name = GetFileName(files[i]);
if(FileCopy(files[i], SourcePath(active, name))) {
Package::File& f = actual.file.Add();
f = name;
f.separator = f.readonly = false;
}
else
throw Format("An error occurred while copying the file:&\1%s", files[i]);
}
for(int i = 0; i < dirs.GetCount(); i++)
DoImport(dirs[i], mask, true, pi);
}
void Ide::SerializeWorkspace(Stream& s) {
int i;
int version = 14;
s / version;
s.Magic(0x12354);
if(s.IsStoring()) {
for(i = 0; i < filedata.GetCount(); i++) {
String fn = filedata.GetKey(i);
if(!fn.IsEmpty() && FileExists(fn)) {
s % fn;
s % filedata[i].editpos;
if(version >= 1)
s % filedata[i].columnline;
}
}
String h;
s % h;
}
else {
String fn;
filedata.Clear();
for(;;) {
s % fn;
if(fn.IsEmpty()) break;
FileData& fd = filedata.GetAdd(fn);
fd.Clear();
s % fd.editpos;
if(version >= 1)
s % fd.columnline;
}
}
String pk = GetActivePackage();
s % pk;
package.FindSetCursor(pk);
s % tablru;
s % mainconfigname;
s % mainconfigparam;
s % console.verbosebuild;
s % stoponerrors;
byte dummy;
s % dummy;
s % runarg;
s % recent_runarg;
s % rundir;
s % stdout_file % recent_stdout_file / runmode;
if(version >= 1)
s % runexternal;
if(version >= 11) {
bool dummy;
s % dummy;
}
if(version >= 13)
s % consolemode;
if(version >= 14)
s % console_utf8;
s % editfile;
for(i = 0; i < 10; i++)
s % bookmark[i];
editor.Serialize(s);
if(version >= 5)
s % editorsplit;
if(version == 6) {
String n;
int v;
s / v;
for(int i = 0; i < 10; i++) {
s % n;
s / v;
}
}
if(version >= 8) {
bool dummyb;
String dummy;
s % dummyb;
s % dummy;
}
SerializeFindInFiles(s);
String om;
s % om;
s % recentoutput;
s % recentflags;
s / editortabsize / indent_amount % indent_spaces;
for(int j = 0; j < GetIdeModuleCount(); j++)
GetIdeModule(j).Serialize(s); // -> Workspace
SerializeWorkspaceConfigs(s);
SerializeOutputMode(s);
SerializeClosed(s);
if(version >= 10) {
if(tabs_serialize) {
s % tabs;
}
}
if(version >= 11) {
s % find_file_search_string;
}
if(version >= 12)
SerializePlacement(s);
}
WorkspaceWork::Sepfo WorkspaceWork::GetActiveSepfo()
{
return Sepfo(GetActivePackage(), GetActiveFileName());
}
void Ide::EditWorkspace()
{
EditPackages(main, GetActivePackage(), pocfg);
ScanWorkspace();
SyncWorkspace();
}
String WorkspaceWork::GetActiveFilePath() const
{
return SourcePath(GetActivePackage(), GetActiveFileName());
}
