public TMFolderListViewItem(TMFolder folder)
{
_folder = folder;
this.ImageKey = TMFileSystemControl.IMG_FOLDER;
this.Text = folder is TMRootFolder ? (folder as TMRootFolder).ToString() : folder.Name;
this.SubItems.Add("Folder");
}
public TMFile(FileInfo file, TMFolder folder)
{
_folder = folder;
_file = file;
_luFileInfo = LUFileInfoManager.GetLUFileInfo(_file);
_fullName = folder.FullName + "\\" + _file.Name;
}
public TMFolder(string name, TMFolder parent)
{
_folders = new TMFolderCollection(this);
_files = new TMFileCollection(this);
_name = name;
_parent = parent;
_rootFolder = this.GetRootFolder() as TMRootFolder;
_fullName = this.GetPath();
}
public TMFolderNode(TMFolder tmFolder) : base(tmFolder.Name)
{
_tmFolder = tmFolder;
foreach (TMFolder folder in tmFolder.Folders)
{
this.Nodes.Add(new TMFolderNode(folder));
}
this.SetDirectoryState(false);
}
public TMFile Clone(TMFolder folder)
{
TMFile file = new TMFile(_file, folder);
file._length = _length;
file._luFileInfo = _luFileInfo;
file._modifyTime = _modifyTime;
file._version = _version;
return(file);
}
private static void LoadFolders(EasyPropertiesNode node, TMFolder folder)
{
EasyPropertiesNode[] childProps = node.GetChildProperties();
foreach (EasyPropertiesNode childProp in childProps)
{
TMFolder tmFolder = new TMFolder(childProp.Name, folder);
LoadFolders(childProp, tmFolder);
LoadFiles(childProp, tmFolder);
folder.Folders.Add(tmFolder);
}
}
public TMFolder Clone(TMFolder parent)
{
TMFolder folder = new TMFolder(this.Name, parent);
foreach (TMFolder childFolder in _folders)
{
folder.Folders.Add(childFolder.Clone(folder));
}
foreach (TMFile file in _files)
{
folder.Files.Add(file.Clone(folder));
}
return(folder);
}
public new TMRootFolder Clone(TMFolder parent)
{
TMRootFolder rootFolder = new TMRootFolder(_rootFolderType);
foreach (TMFolder childFolder in this.Folders)
{
rootFolder.Folders.Add(childFolder.Clone(rootFolder));
}
foreach (TMFile file in this.Files)
{
rootFolder.Files.Add(file.Clone(rootFolder));
}
return(rootFolder);
}
protected TMFolder FindFolder(string path)
{
if (this.FullName.Equals(path))
{
return(this);
}
foreach (TMFolder childFolder in this.Folders)
{
TMFolder retFolder = childFolder.FindFolder(path);
if (retFolder != null)
{
return(retFolder);
}
}
return(null);
}
private void JoinDirectory(TMFolder folder, DirectoryInfo dir)
{
foreach (DirectoryInfo d in dir.GetDirectories())
{
TMFolder childTMFolder = new TMFolder(d.Name, folder);
folder.Folders.Add(childTMFolder);
this.JoinDirectory(childTMFolder, d);
}
foreach (FileInfo file in dir.GetFiles())
{
TMFile tmFile = new TMFile(file, folder);
tmFile.ModifyTime = file.LastWriteTime;
tmFile.Length = file.Length;
folder.Files.Add(tmFile);
}
}
private static void LoadFiles(EasyPropertiesNode node, TMFolder folder)
{
int count = node.GetValue <int>("Count", 0);
for (int i = 0; i < count; i++)
{
string pname = "File" + i.ToString();
string fileName = node.GetValue <string>(pname + "_fullname", "");
TMFile tmFile = new TMFile(new FileInfo(fileName), folder);
tmFile.Version = node.GetValue <int>(pname + "_version", 1);
tmFile.ModifyTime = node.GetValue <DateTime>(pname + "_time", DateTime.Now);
tmFile.Length = node.GetValue <long>(pname + "_length", 0);
folder.Files.Add(tmFile);
}
}
public bool Remove(TMFolder folder)
{
if (folder is TMRootFolder)
{
return(this.Remove((folder as TMRootFolder).RootFolderType));
}
else
{
foreach (TMRootFolder rootFolder in this)
{
if (rootFolder.Remove(folder))
{
return(true);
}
}
}
return(false);
}
public bool Remove(TMFolder folder)
{
foreach (TMFolder item in _folders)
{
if (item == folder)
{
_folders.Remove(folder);
return(true);
}
else
{
if (item.Remove(folder))
{
return(true);
}
}
}
return(false);
}
private void AddFile(TMFolder folder)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.InitialDirectory = this.Convert(folder).FullName;
ofd.Multiselect = true;
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
foreach (string fileName in ofd.FileNames)
{
TMFile tmFile = new TMFile(new FileInfo(fileName), folder);
folder.Files.Add(tmFile);
}
this.UpdateFileListView();
this.OnDataChanged();
}
private static void SaveFolder(EasyPropertiesNode node, TMFolder folder)
{
foreach (TMFolder tmFolder in folder.Folders)
{
EasyPropertiesNode childNode = node[tmFolder.Name];
SaveFolder(childNode, tmFolder);
}
node.SetValue <int>("Count", folder.Files.Count);
for (int i = 0; i < folder.Files.Count; i++)
{
TMFile tmFile = folder.Files[i];
string pname = "File" + i.ToString();
string[] sa = new string[] { };
node.SetValue <int>(pname + "_version", tmFile.Version);
node.SetValue <string>(pname + "_fullname", tmFile.File.FullName);
node.SetValue <DateTime>(pname + "_time", tmFile.ModifyTime);
node.SetValue <long>(pname + "_length", tmFile.Length);
}
}
private TMFolderNode GetNode(TreeNodeCollection nodes, TMFolder folder)
{
foreach (TreeNode node in nodes)
{
TMFolderNode folderNode = node as TMFolderNode;
if (folderNode != null)
{
if (folder.FullName == folderNode.Folder.FullName)
{
return(folderNode);
}
}
folderNode = this.GetNode(node.Nodes, folder);
if (folderNode != null)
{
return(folderNode);
}
}
return(null);
}
private DirectoryInfo Convert(TMFolder folder)
{
DirectoryInfo dir = null;
if (folder.Root.RootFolderType == LURootFolderType.Application)
{
dir = _project.AppDirectory;
}
else
{
dir = LURootFolder.Convert(folder.Root.RootFolderType);
}
string[] sa = folder.FullName.Split('\\');
for (int i = 1; i < sa.Length; i++)
{
dir = new DirectoryInfo(Path.Combine(dir.FullName, sa[i]));
}
return(dir);
}
private void Compile(List <TMZipFile> zipFiles, TMFolder rootFolder, DirectoryInfo dir, List <string> errors)
{
foreach (TMFolder folder in rootFolder.Folders)
{
DirectoryInfo rootDir = new DirectoryInfo(Path.Combine(dir.FullName, folder.Name));
rootDir.Create();
this.Compile(zipFiles, folder, rootDir, errors);
}
foreach (TMFile tmFile in rootFolder.Files)
{
FileInfo file = tmFile.File;
if (!file.Exists)
{
errors.Add(string.Format("File not found: {0}", file.FullName));
continue;
}
FileInfo zipFile = new FileInfo(Path.Combine(dir.FullName, file.Name + ".zip"));
zipFiles.Add(new TMZipFile(zipFile, tmFile));
OnCompressFile(new ZipEventArgs(file, zipFile, 0, file.Length));
string message = string.Format("Compression: {0}", file.FullName);
Console.Write(message);
try {
using (ZipOutputStream s = new ZipOutputStream(File.Create(zipFile.FullName))) {
s.SetLevel(9);
byte[] buffer = new byte[4096];
ZipEntry entry = new ZipEntry(file.Name);
entry.DateTime = file.LastWriteTime;
entry.Size = file.Length;
s.PutNextEntry(entry);
DateTime limitTime = DateTime.Now;
using (FileStream fs = File.OpenRead(file.FullName)) {
int sourceBytes;
do
{
sourceBytes = fs.Read(buffer, 0, buffer.Length);
s.Write(buffer, 0, sourceBytes);
if (DateTime.Now.Ticks - limitTime.Ticks > 10000000L)
{
limitTime = DateTime.Now;
OnCompressFile(new ZipEventArgs(file, zipFile, fs.Position, file.Length));
}
} while (sourceBytes > 0);
}
s.Finish();
s.Close();
}
Console.WriteLine(" - ok");
} catch (Exception ex) {
string error = string.Format(" - error: {0}", ex.Message);
errors.Add(message + error);
Console.WriteLine(error);
} finally {
OnCompressFile(new ZipEventArgs(file, zipFile, 0, file.Length));
OnProgress(new BuilderProgressEventArgs(_project, ++_current, _total));
}
}
}
public TMFileCollection(TMFolder owner)
{
_owner = owner;
}
