public FileItem(StorageView view, FolderNode parent, StorageFile file, bool temp)
{
View = view;
Folder = parent;
SubItems.Add("");
SubItems.Add("");
Details = file;
Temp = temp;
UpdateInterface();
}
public DetailsForm(StorageView view, FolderNode folder)
{
InitializeComponent();
View = view;
Trust = View.Trust;
TargetFolder = folder;
EnableControls(View.Working != null);
NameBox.Text = folder.Text;
SizeLabel.Text = "Contains " + Utilities.CommaIze(CalculateFolderSize(folder, 0)) + " Bytes";
LoadVis(folder.Details.Scope);
}
public FileItem(StorageView view, FolderNode folder)
{
View = view;
Folder = folder;
SubItems.Add("");
SubItems.Add("");
IsFolder = true;
ImageIndex = folder.Details.IsFlagged(StorageFlags.Archived) ? 3 : 2;
Details = folder.Details;
Changes = folder.Changes;
Temp = folder.Temp;
UpdateInterface();
}
public DetailsForm(StorageView view, FolderNode folder, FileItem file)
{
InitializeComponent();
View = view;
Core = View.Core;
Trust = View.Trust;
TargetFolder = folder;
TargetFile = file;
EnableControls(View.Working != null);
NameBox.Text = file.Text;
SizeLabel.Text = Utilities.CommaIze(((StorageFile)file.Details).InternalSize) + " Bytes";
LoadVis(file.Details.Scope);
}
private void ApplyDiff(ulong id)
{
// change log - who / not
// read file uid
// if exists locally
// if integrated mark as so
// else mark as changed, run history diff, and use last note
// if doesnt exist
// add file as a temp
// user does - add to storage, to add it
// if remote doesnt have any record of local file, ignore
ChangeCount[id] = 0;
OpStorage storage = Storages.GetStorage(id);
if (storage == null)
{
FailedDiffs.Add(id);
return;
}
string path = Storages.GetFilePath(storage);
if (!File.Exists(path))
{
FailedDiffs.Add(id);
return;
}
try
{
using (TaggedStream filex = new TaggedStream(path, Core.GuiProtocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(filex, storage.File.Header.FileKey))
{
PacketStream stream = new PacketStream(crypto, Storages.Protocol, FileAccess.Read);
ulong remoteUID = 0;
FolderNode currentFolder = RootFolder;
bool readingProject = false;
G2Header header = null;
while (stream.ReadPacket(ref header))
{
if (header.Name == StoragePacket.Root)
{
StorageRoot root = StorageRoot.Decode(header);
readingProject = (root.ProjectID == ProjectID);
}
if (readingProject)
{
if (header.Name == StoragePacket.Folder)
{
StorageFolder folder = StorageFolder.Decode(header);
// if new UID
if (remoteUID == folder.UID)
continue;
remoteUID = folder.UID;
// check scope
bool ignore = false;
if (folder.Scope.Count > 0 && !Trust.IsInScope(folder.Scope, UserID, ProjectID))
ignore = true;
bool added = false;
while (!added)
{
if (currentFolder.Details.UID == folder.ParentUID)
{
// if folder exists with UID
if (currentFolder.Folders.ContainsKey(remoteUID))
currentFolder = currentFolder.Folders[remoteUID];
// else add folder as temp, mark as changed
else
{
if (ignore) // temp so traverse works, but not saved in structure
{
currentFolder = new FolderNode(this, folder, currentFolder, false);
break;
}
else
currentFolder = currentFolder.AddFolderInfo(folder, true);
}
bool found = false;
currentFolder.Archived.LockReading(delegate()
{
foreach (StorageFolder archive in currentFolder.Archived)
if (Storages.ItemDiff(archive, folder) == StorageActions.None)
if (archive.Date == folder.Date)
{
found = true;
break;
}
});
if (!found)
{
currentFolder.Changes[id] = folder;
currentFolder.UpdateOverlay();
}
// diff file properties, if different, add as change
/*if (currentFolder.Temp || Storages.ItemDiff(currentFolder.Details, folder) != StorageActions.None)
{
currentFolder.Changes[id] = folder;
currentFolder.UpdateOverlay();
}*/
added = true;
}
else if (currentFolder.Parent.GetType() == typeof(FolderNode))
currentFolder = (FolderNode)currentFolder.Parent;
else
break;
}
}
if (header.Name == StoragePacket.File)
{
StorageFile file = StorageFile.Decode(header);
// if new UID
if (remoteUID == file.UID)
continue;
remoteUID = file.UID;
// check scope
if (file.Scope.Count > 0 && !Trust.IsInScope(file.Scope, UserID, ProjectID))
continue;
FileItem currentFile = null;
// if file exists with UID
if (currentFolder.Files.ContainsKey(remoteUID))
currentFile = currentFolder.Files[remoteUID];
// else add file as temp, mark as changed
else
currentFile = currentFolder.AddFileInfo(file, true);
// if file is integrated, still add, so that reject functions
// true if file doesnt exist in local file history
// if it does exist and file is newer than latest, true
bool found = false;
currentFile.Archived.LockReading(delegate()
{
foreach (StorageFile archive in currentFile.Archived)
if (Storages.ItemDiff(archive, file) == StorageActions.None)
if (archive.Date == file.Date)
{
found = true;
break;
}
});
if (!found)
currentFile.Changes[id] = file;
}
}
}
}
}
catch
{
FailedDiffs.Add(id);
}
}
private void AnalyzeChanges(FolderNode folder, bool expand, ref bool showHigher, ref bool showLower)
{
// look at files for changes
foreach (FileItem file in folder.Files.Values)
foreach (ulong id in file.GetRealChanges().Keys)
{
ChangeCount[id]++;
if (HigherIDs.Contains(id))
showHigher = true;
else
showLower = true;
}
// look at folders for changes
foreach (FolderNode sub in folder.Folders.Values)
{
foreach (ulong id in sub.GetRealChanges().Keys)
{
ChangeCount[id]++;
if (HigherIDs.Contains(id))
showHigher = true;
else
showLower = true;
}
// recurse
bool subChangesHigh = false, subChangesLow = false;
AnalyzeChanges(sub, expand, ref subChangesHigh, ref subChangesLow);
if(subChangesHigh)
showHigher = true;
if(subChangesLow)
showLower = true;
}
folder.ContainsHigherChanges = showHigher;
folder.ContainsLowerChanges = showLower;
if (showHigher || showLower)
{
folder.UpdateOverlay();
if (expand)
folder.EnsureVisible();
}
}
void AddNewFolder(FolderNode folder)
{
// if no changes then temp local, add path
if (folder.Changes.Count == 0)
Working.TrackFolder(folder.GetPath()); // add through working path
// if 1 change, then file is remote, add item
else if (folder.Changes.Count == 1)
Working.TrackFolder(folder.GetPath(), (StorageFolder)GetFirstItem(folder.Changes));
// if more than 1 change, them multiple remotes
else if (folder.Changes.Count > 1)
MessageBox.Show("Select specific folder from changes below to add");
}
public void UnlockFolder(FolderNode folder, bool subs, List<LockError> errors)
{
string path = folder.GetPath();
string root = Storages.GetRootPath(UserID, ProjectID);
if(!Storages.CreateFolder(root + path, errors, subs))
return;
if (Directory.Exists(root + path))
{
// set flag
folder.Details.SetFlag(StorageFlags.Unlocked);
folder.Update();
// unlock files
foreach (FileItem file in folder.Files.Values)
if (!file.Temp && !file.Details.IsFlagged(StorageFlags.Archived))
Storages.UnlockFile(UserID, ProjectID, path, (StorageFile)file.Details, false, errors);
// unlock subfolders
if (subs)
foreach (FolderNode subfolder in folder.Folders.Values)
if (!subfolder.Details.IsFlagged(StorageFlags.Archived))
UnlockFolder(subfolder, subs, errors);
}
}
public void LockFolder(FolderNode folder, bool subs, List<LockError> errors)
{
string path = folder.GetPath();
string wholepath = Storages.GetRootPath(UserID, ProjectID) + path;
List<string> stillLocked = new List<string>();
foreach (FileItem file in folder.Files.Values)
if (!file.Temp)
{
Storages.LockFileCompletely(UserID, ProjectID, path, file.Archived, errors);
string filepath = wholepath + Path.DirectorySeparatorChar + file.Details.Name;
if (File.Exists(filepath))
stillLocked.Add(filepath);
}
folder.Details.RemoveFlag(StorageFlags.Unlocked);
folder.Update();
if (subs)
foreach (FolderNode subfolder in folder.Folders.Values)
if (!subfolder.Temp)
LockFolder(subfolder, subs, errors);
Storages.DeleteFolder(wholepath, errors, stillLocked);
}
private FolderNode LoadWorking(TreeListNode parent, LocalFolder folder)
{
FolderNode node = new FolderNode(this, folder.Info, parent, false);
node.Archived = folder.Archived;
node.Integrated = folder.Integrated;
if (SelectedFolder != null && node.Details.UID == SelectedFolder.Details.UID)
{
node.Selected = true;
SelectedFolder = node;
}
if (!folder.Info.IsFlagged(StorageFlags.Archived) || GhostsButton.Checked)
GuiUtils.InsertSubNode(parent, node);
if (parent.GetType() == typeof(FolderNode))
{
FolderNode parentNode = (FolderNode)parent;
parentNode.Folders[folder.Info.UID] = node;
}
if (node.Details.IsFlagged(StorageFlags.Modified))
node.EnsureVisible();
folder.Folders.LockReading(delegate()
{
foreach (LocalFolder sub in folder.Folders.Values)
LoadWorking(node, sub);
});
folder.Files.LockReading(delegate()
{
foreach (LocalFile file in folder.Files.Values)
{
FileItem item = new FileItem(this, node, file.Info, false);
item.Archived = file.Archived;
item.Integrated = file.Integrated;
node.Files[file.Info.UID] = item;
}
});
return node;
}
public RescanFolder(string path, FolderNode node, bool recurse)
{
Path = path;
Node = node;
Recurse = recurse;
}
private void UnloadWorking(FolderNode parent, FolderNode folder)
{
// need to leave ghosts of removed working files because we dont know what diffs applied
// had the same hash has the file being unloaded (exists but never added to change log)
// to be safe, we remove most everything and set everything as temp
folder.Details = folder.Details.Clone();
folder.Details.RemoveFlag(StorageFlags.Modified);
folder.Archived.SafeClear();
folder.Temp = true;
if (parent.Nodes.Contains(folder))
if (folder.Details.IsFlagged(StorageFlags.Archived) && !GhostsButton.Checked)
parent.Nodes.Remove(folder);
else
folder.Update();
foreach (FolderNode sub in folder.Folders.Values)
UnloadWorking(folder, sub);
foreach (FileItem file in folder.Files.Values)
{
file.Details = ((StorageFile)file.Details).Clone();
file.Details.RemoveFlag(StorageFlags.Modified);
file.Archived.SafeClear();
file.Temp = true;
}
}
private void SelectFolder(FolderNode folder)
{
if (folder == null)
return;
/*
*
* if (!SelectedInfo.IsFile && SelectedInfo.CurrentFolder != null)
{
if (SelectedInfo.CurrentFolder.Details.UID == SelectedFolder.Details.UID)
SelectedInfo.ShowItem(SelectedFolder, null);
else
SelectedInfo.ShowDefault();
}
* */
bool infoSet = false;
string infoPath = SelectedInfo.CurrentPath;
SelectedFolder = folder;
folder.Selected = true;
string dirpath = null;
if (Working != null)
dirpath = Working.RootPath + folder.GetPath();
ulong selectedUID = 0;
if (SelectedInfo.CurrentItem != null)
selectedUID = SelectedInfo.CurrentItem.UID;
FileListView.Items.Clear();
FileListView.SmallImageList = FileIcons;
// add sub folders
if (!FoldersButton.Checked && folder.Parent.GetType() == typeof(FolderNode))
{
FileItem dots = new FileItem(this, new FolderNode(this, new StorageFolder(), folder.Parent, false));
dots.Folder.Details.Name = "..";
dots.Text = "..";
if (string.Compare("..", infoPath, true) == 0)
{
infoSet = true;
dots.Selected = true;
SelectedInfo.ShowDots();
}
FileListView.Items.Add(dots);
}
foreach (FolderNode sub in folder.Nodes)
{
FileItem subItem = new FileItem(this, sub);
if (string.Compare(sub.GetPath(), infoPath, true) == 0)
{
infoSet = true;
subItem.Selected = true;
SelectedInfo.ShowItem(sub, null);
}
FileListView.Items.Add(subItem);
}
// if folder unlocked, add untracked folders, mark temp
if(folder.Details.IsFlagged(StorageFlags.Unlocked) && Directory.Exists(dirpath))
try
{
foreach (string dir in Directory.GetDirectories(dirpath))
{
string name = Path.GetFileName(dir);
if (name.CompareTo(".history") == 0)
continue;
if (folder.GetFolder(name) != null)
continue;
StorageFolder details = new StorageFolder();
details.Name = name;
FileItem tempFolder = new FileItem(this, new FolderNode(this, details, folder, true));
if (string.Compare(tempFolder.GetPath(), infoPath, true) == 0)
{
infoSet = true;
tempFolder.Selected = true;
SelectedInfo.ShowItem(tempFolder.Folder, null);
}
FileListView.Items.Add(tempFolder);
}
}
catch { }
// add tracked files
foreach (FileItem file in folder.Files.Values)
if (!file.Details.IsFlagged(StorageFlags.Archived) || GhostsButton.Checked)
{
if (string.Compare(file.GetPath(), infoPath, true) == 0)
{
infoSet = true;
file.Selected = true;
SelectedInfo.ShowItem(folder, file);
}
else
file.Selected = false;
FileListView.Items.Add(file);
}
// if folder unlocked, add untracked files, mark temp
if (folder.Details.IsFlagged(StorageFlags.Unlocked) && Directory.Exists(dirpath))
try
{
foreach (string filepath in Directory.GetFiles(dirpath))
{
string name = Path.GetFileName(filepath);
if (folder.GetFile(name) != null)
continue;
StorageFile details = new StorageFile();
details.Name = name;
details.InternalSize = new FileInfo(filepath).Length;
FileItem tempFile = new FileItem(this, folder, details, true);
if (string.Compare(tempFile.GetPath(), infoPath, true) == 0)
{
infoSet = true;
tempFile.Selected = true;
SelectedInfo.ShowItem(folder, tempFile);
}
FileListView.Items.Add(tempFile);
}
}
catch { }
UpdateListItems();
if (!infoSet && SelectedFolder.GetPath() == infoPath)
{
infoSet = true;
SelectedInfo.ShowItem(SelectedFolder, null);
}
if (!infoSet)
SelectedInfo.ShowDiffs();
}
private void RemoveDiff(ulong id, FolderNode folder)
{
if (FailedDiffs.Contains(id))
FailedDiffs.Remove(id);
// remove changes from files
List<ulong> removeUIDs = new List<ulong>();
foreach (FileItem file in folder.Files.Values)
{
if (file.Changes.ContainsKey(id))
file.Changes.Remove(id);
// remove entirely if temp etc..
if (file.Temp && file.Changes.Count == 0)
removeUIDs.Add(file.Details.UID);
}
foreach (ulong uid in removeUIDs)
folder.Files.Remove(uid);
removeUIDs.Clear();
// remove changes from folders
foreach (FolderNode sub in folder.Folders.Values)
{
if (sub.Changes.ContainsKey(id))
{
sub.Changes.Remove(id);
sub.UpdateOverlay();
}
// remove entirely if temp etc..
if (sub.Temp && sub.Changes.Count == 0)
{
removeUIDs.Add(sub.Details.UID);
if (folder.Nodes.Contains(sub))
folder.Nodes.Remove(sub);
if (SelectedFolder == sub)
SelectFolder(folder);
}
}
foreach (ulong uid in removeUIDs)
folder.Folders.Remove(uid);
// recurse
foreach (FolderNode sub in folder.Folders.Values)
RemoveDiff(id, sub);
}
private void RefreshView()
{
FolderNode prevSelected = SelectedFolder;
RootFolder = null;
FolderTreeView.Nodes.Clear();
FileListView.Items.Clear();
FolderTreeView.Nodes.Add(new TreeListNode());
// if local
if (IsLocal)
RootFolder = LoadWorking(FolderTreeView.virtualParent, Working.RootFolder);
// else load from file
else
{
StorageFolder root = new StorageFolder();
root.Name = Trust.GetProjectName(ProjectID) + " Files";
RootFolder = new FolderNode(this, root, FolderTreeView.virtualParent, false);
FolderTreeView.Nodes.Add(RootFolder);
OpStorage storage = Storages.GetStorage(UserID);
if (storage != null)
LoadHeader(Storages.GetFilePath(storage), storage.File.Header.FileKey);
}
// re-diff
foreach (ulong id in CurrentDiffs)
ApplyDiff(id);
if (RootFolder != null)
{
RootFolder.Expand();
bool high = false, low = false;
AnalyzeChanges(RootFolder, true, ref high, ref low);
}
bool showDiffs = SelectedInfo.DiffsView; // save diffs view mode here because selectFolder resets it
// if prev == selected, this means selected wasnt updated in refresh
if (SelectedFolder == null || prevSelected == SelectedFolder)
SelectFolder(RootFolder);
else
{
SelectedFolder.EnsureVisible();
RefreshFileList();
}
if (showDiffs)
SelectedInfo.ShowDiffs();
}
private void MarkRescanFolder(ulong uid, string path, FolderNode node, bool recurse)
{
RescanFolderMap[uid] = new RescanFolder(path, node, recurse);
NextRescan = 2;
RescanLabel.Text = "Rescanning...";
}
private long CalculateFolderSize(FolderNode folder, long total)
{
foreach (FileItem item in folder.Files.Values)
if (!item.Details.IsFlagged(StorageFlags.Archived))
total += ((StorageFile)item.Details).InternalSize;
foreach (FolderNode node in folder.Folders.Values)
if (!node.Details.IsFlagged(StorageFlags.Archived))
total += CalculateFolderSize(node, total);
return total;
}
private void LoadHeader(string path, byte[] key)
{
try
{
using (TaggedStream filex = new TaggedStream(path, Core.GuiProtocol))
using (IVCryptoStream crypto = IVCryptoStream.Load(filex, key))
{
PacketStream stream = new PacketStream(crypto, Storages.Protocol, FileAccess.Read);
FolderNode currentFolder = RootFolder;
bool readingProject = false;
G2Header header = null;
while (stream.ReadPacket(ref header))
{
if (header.Name == StoragePacket.Root)
{
StorageRoot root = StorageRoot.Decode(header);
readingProject = (root.ProjectID == ProjectID);
}
// show archived if selected, only add top uid, not copies
if (readingProject)
{
if (header.Name == StoragePacket.Folder)
{
StorageFolder folder = StorageFolder.Decode(header);
bool added = false;
while (!added)
{
if (currentFolder.Details.UID == folder.ParentUID)
{
currentFolder = currentFolder.AddFolderInfo(folder, false);
// re-select on re-load
if (SelectedFolder != null && currentFolder.Details.UID == SelectedFolder.Details.UID)
{
currentFolder.Selected = true;
SelectedFolder = currentFolder;
}
added = true;
}
else if (currentFolder.Parent.GetType() == typeof(FolderNode))
currentFolder = (FolderNode)currentFolder.Parent;
else
break;
}
if (!added)
{
Debug.Assert(false);
throw new Exception("Error loading CFS");
}
}
if (header.Name == StoragePacket.File)
{
StorageFile file = StorageFile.Decode(header);
currentFolder.AddFileInfo(file, false);
}
}
}
}
}
catch (Exception ex)
{
Core.Network.UpdateLog("Storage", "Error loading files " + ex.Message);
}
}
