/// <summary>
/// Sets the contents of the package from the given experiment, types and components.
/// </summary>
/// <param name="pInfo">Experiment info.</param>
/// <param name="pTypes">Collection of type assembly files.</param>
/// <param name="pComponents">Collection of component assembly files.</param>
/// <returns></returns>
private PackageSourceInfo SetPackageContent(ExperimentInfo pInfo, ISet <string> pTypes, ISet <string> pComponents)
{
var info = new PackageSourceInfo();
// Adding components
if (pComponents.Count > 0)
{
PackageHeirarchyItem componentsFolder = CreateFolder(info.Root, "Components");
componentsFolder.HasComponents = true;
foreach (string component in pComponents)
{
AddFile(componentsFolder, component);
}
}
// Adding experiment
PackageHeirarchyItem experimentFolder = CreateFolder(info.Root, "Experiment");
AddFile(experimentFolder, pInfo.FilePath);
info.Name = pInfo.Name + " Package";
// Adding types
if (pTypes.Count > 0)
{
PackageHeirarchyItem typesFolder = CreateFolder(info.Root, "Types");
typesFolder.HasTypes = true;
foreach (string type in pTypes)
{
AddFile(typesFolder, type);
}
}
return(info);
}
private void TreeView_Drop(object sender, DragEventArgs e)
{
var pkgInfo = (PackageSourceInfo)DataContext;
var target = (FrameworkElement)e.Source;
PackageHeirarchyItem parent = target.DataContext as PackageHeirarchyItem;
PackageFileSourceInfo file = target.DataContext as PackageFileSourceInfo;
if (parent == null && file != null)
{
parent = file.Parent;
}
if (parent == null)
{
parent = pkgInfo.Root;
}
if (e.Data is System.Windows.DataObject && ((System.Windows.DataObject)e.Data).ContainsFileDropList())
{
foreach (string filePath in ((System.Windows.DataObject)e.Data).GetFileDropList())
{
Add(parent, filePath);
}
}
// Enabling/Disabling the Build button depending if the package is empty or not
BuildButton.IsEnabled = (pkgInfo.Root.Children.Count > 0);
e.Handled = true;
}
private void TreeView_Drop(object sender, DragEventArgs e)
{
var viewModel = (PackageBuilderViewModel)DataContext;
var pkgInfo = viewModel.PackageSourceInfo;
var target = (FrameworkElement)e.Source;
PackageHeirarchyItem parent = target.DataContext as PackageHeirarchyItem;
PackageFileSourceInfo file = target.DataContext as PackageFileSourceInfo;
if (parent == null && file != null)
{
parent = file.Parent;
}
if (parent == null)
{
parent = pkgInfo.Root;
}
if (e.Data is System.Windows.DataObject && ((System.Windows.DataObject)e.Data).ContainsFileDropList())
{
foreach (string filePath in ((System.Windows.DataObject)e.Data).GetFileDropList())
{
Add(parent, filePath);
}
}
e.Handled = true;
}
/// <summary>
/// Creates an empty folder inside the PackageHeirarchyItem provided.
/// </summary>
/// <param name="pParent">Parent node of the new folder.</param>
/// <param name="pFolderName">Name of the folder.</param>
/// <returns></returns>
private PackageHeirarchyItem CreateFolder(PackageHeirarchyItem pParent, string pFolderName)
{
PackageHeirarchyItem newFolder = new PackageHeirarchyItem("");
newFolder.Name = pFolderName;
newFolder.Parent = pParent;
pParent.Children.Add(newFolder);
return(newFolder);
}
private void BuildTree()
{
PackageHeirarchyItem root = m_viewModel.PackageSourceInfo.Root;
TreeIter treeParentNode = m_packageContentStore.AppendValues(root);
foreach (PackageFileSourceInfo childNode in root.Children)
{
AddNodeToTreeModel(childNode, treeParentNode);
}
}
/// <summary>
/// Sets the contents of the package from the given experiment, types and components.
/// </summary>
/// <param name="pInfo">Experiment info.</param>
/// <param name="pTypes">Collection of type assembly files.</param>
/// <param name="pComponents">Collection of component assembly files.</param>
/// <returns></returns>
private PackageSourceInfo SetPackageContent(ExperimentPackagingResults pResults)
{
var info = new PackageSourceInfo();
// Adding components
if (pResults.ComponentAssemblies.Count > 0)
{
PackageHeirarchyItem componentsFolder = CreateFolder(info.Root, "Components");
componentsFolder.HasComponents = true;
foreach (string component in pResults.ComponentAssemblies)
{
AddFile(componentsFolder, component);
}
}
// Adding experiment
PackageHeirarchyItem experimentFolder = CreateFolder(info.Root, "Experiment");
AddFile(experimentFolder, pResults.Experiment.ExperimentInfo.FilePath);
info.Name = pResults.Experiment.ExperimentInfo.Name + " Package";
// Adding refered types into subfolder of Experiment
if (pResults.Files.Count > 0)
{
foreach (PackageFileInfo file in pResults.Files)
{
PackageHeirarchyItem lastFolder = CreateRelativeFolders(experimentFolder, file);
AddFile(lastFolder, file.AbsoluteLocation);
}
}
//Adding refered directories into subfolder of Experiment
if (pResults.Directories.Count > 0)
{
foreach (PackageFileInfo dir in pResults.Directories)
{
PackageHeirarchyItem lastFolder = CreateRelativeFolders(experimentFolder, dir);
AddFolder(lastFolder, dir.AbsoluteLocation);
}
}
// Adding types
if (pResults.TypeAssemblies.Count > 0)
{
PackageHeirarchyItem typesFolder = CreateFolder(info.Root, "Types");
typesFolder.HasTypes = true;
foreach (string type in pResults.TypeAssemblies)
{
AddFile(typesFolder, type);
}
}
return(info);
}
private void Add(PackageHeirarchyItem parent, string filePath)
{
if (System.IO.File.Exists(filePath))
{
AddFile(parent, filePath);
}
else
{
AddFolder(parent, filePath);
}
}
private void AddFile(PackageHeirarchyItem parent, string filePath)
{
var name = System.IO.Path.GetFileName(filePath);
if (parent != null && !Contains(parent, name))
{
var newItem = new PackageFileSourceInfo(filePath);
newItem.Name = name;
newItem.Parent = parent;
parent.Children.Add(newItem);
}
}
private void HasTypesCheckBoxToggled(object o, ToggledArgs args)
{
TreeIter iter;
if (m_packageContentStore.GetIterFromString(out iter, args.Path))
{
PackageHeirarchyItem hierarchyItem = m_packageContentStore.GetValue(iter, 0) as PackageHeirarchyItem;
if (hierarchyItem != null)
{
hierarchyItem.HasTypes = !hierarchyItem.HasTypes;
}
}
}
static bool Contains(PackageHeirarchyItem info, string name)
{
bool contains = false;
foreach (PackageFileSourceInfo item in info.Children)
{
if (string.Equals(name, item.Name))
{
contains = true;
break;
}
}
return(contains);
}
private void AddNodeToTreeModel(PackageFileSourceInfo node, TreeIter parentNode)
{
parentNode = m_packageContentStore.AppendValues(parentNode, node);
PackageHeirarchyItem hierarchyItem = node as PackageHeirarchyItem;
if (hierarchyItem != null)
{
foreach (PackageFileSourceInfo childNode in hierarchyItem.Children)
{
AddNodeToTreeModel(childNode, parentNode);
}
}
}
private void RenderHasTypesCheckBox(TreeViewColumn layout, CellRenderer cell, TreeModel model, TreeIter iter)
{
PackageHeirarchyItem hierarchyItem = model.GetValue(iter, 0) as PackageHeirarchyItem;
if (hierarchyItem != null)
{
(cell as CellRendererToggle).Active = hierarchyItem.HasTypes;
cell.Visible = true;
}
else
{
//if it is just a file not directory hide the checkbox
cell.Visible = false;
}
}
private PackageHeirarchyItem CreateRelativeFolders(PackageHeirarchyItem experimentFolder, PackageFileInfo file)
{
PackageHeirarchyItem lastFolder = experimentFolder;
foreach (string folder in file.FoldersPath)
{
PackageHeirarchyItem folderInfo;
if (ContainsFolder(lastFolder, folder, out folderInfo))
{
lastFolder = folderInfo;
}
else
{
lastFolder = CreateFolder(lastFolder, folder);
}
}
return(lastFolder);
}
/// <summary>
/// Adds item and its content (file or folder) to package.
/// </summary>
/// <param name="pPkg">Package being created.</param>
/// <param name="item">Item to be added.</param>
/// <returns>True is there was no error during the operation, false otherwise.</returns>
private bool AddItemToPackage(TraceLab.Core.PackageSystem.Package pkg, PackageFileSourceInfo item)
{
bool noError = true;
string targetPath = System.IO.Path.Combine(pkg.Location, item.GetPath());
PackageHeirarchyItem dir = item as PackageHeirarchyItem;
if (dir != null)
{
if (item.Parent != null)
{
System.IO.Directory.CreateDirectory(targetPath);
}
foreach (PackageFileSourceInfo child in dir.Children)
{
noError = noError && AddItemToPackage(pkg, child);
}
if (dir.HasComponents)
{
pkg.SetDirectoryHasComponents(dir.GetPath(), true);
}
if (dir.HasTypes)
{
pkg.SetDirectoryHasTypes(dir.GetPath(), true);
}
}
else
{
System.IO.File.Copy(item.SourceFilePath, targetPath);
//Add reference to this created package to all experiments and composite components
if (this.isExperimentPackage && targetPath.EndsWith(".teml") || targetPath.EndsWith(".tcml"))
{
noError = noError && AddPkgRefToExperiment(pkg, targetPath);
}
System.IO.File.SetAttributes(targetPath, System.IO.File.GetAttributes(targetPath) & ~System.IO.FileAttributes.ReadOnly);
pkg.AddFile(targetPath);
}
return(noError);
}
static bool ContainsFolder(PackageHeirarchyItem info, string name, out PackageHeirarchyItem resultFolder)
{
resultFolder = null;
bool contains = false;
foreach (PackageFileSourceInfo item in info.Children)
{
if (string.Equals(name, item.Name))
{
resultFolder = item as PackageHeirarchyItem;
//if resultFolder now is different than null it means there is such folder in hierarchy,
//otherwise there is file of same name - so return false
if (resultFolder != null)
{
contains = true;
}
break;
}
}
return(contains);
}
private void AddFolder(PackageHeirarchyItem parent, string filePath)
{
System.IO.DirectoryInfo dir = new System.IO.DirectoryInfo(filePath);
if (parent != null && !Contains(parent, dir.Name))
{
var newItem = new PackageHeirarchyItem(filePath);
newItem.Name = dir.Name;
newItem.Parent = parent;
parent.Children.Add(newItem);
foreach (System.IO.FileInfo file in dir.EnumerateFiles())
{
AddFile(newItem, file.FullName);
}
foreach (System.IO.DirectoryInfo subDir in dir.EnumerateDirectories())
{
AddFolder(newItem, subDir.FullName);
}
}
}
private void HandleDragDataReceived(object o, DragDataReceivedArgs args)
{
TreeView treeView = (TreeView)o;
bool success = false;
//1. check if we can drop at the given position
TreePath path;
TreeViewDropPosition pos;
if (!treeView.GetDestRowAtPos(args.X, args.Y, out path, out pos))
{
args.RetVal = false;
Gtk.Drag.Finish(args.Context, success, false, args.Time);
return;
}
//2. check if given position can find corresponding iter (iter holds value with PackageSourceInfo)
Gtk.TreeIter folderIter;
if (!m_packageContentStore.GetIter(out folderIter, path))
{
args.RetVal = false;
Gtk.Drag.Finish(args.Context, success, false, args.Time);
return;
}
//if user drop the item not on the folder then return false
PackageHeirarchyItem folder = this.treeView.Model.GetValue(folderIter, 0) as PackageHeirarchyItem;
if (folder == null)
{
args.RetVal = false;
Gtk.Drag.Finish(args.Context, success, false, args.Time);
return;
}
if (pos == TreeViewDropPosition.Before)
{
treeView.SetDragDestRow(path, TreeViewDropPosition.IntoOrBefore);
}
else if (pos == TreeViewDropPosition.After)
{
treeView.SetDragDestRow(path, TreeViewDropPosition.IntoOrAfter);
}
Gdk.Drag.Status(args.Context, args.Context.SuggestedAction, args.Time);
string data = System.Text.Encoding.UTF8.GetString(args.SelectionData.Data);
List <string> paths = new List <string>(System.Text.RegularExpressions.Regex.Split(data, "\r\n"));
paths.RemoveAll(string.IsNullOrEmpty);
paths.RemoveAt(paths.Count - 1); // I don't know what last object is, but I tested and noticed that it is not a path
foreach (string uriPath in paths)
{
string localPath = new Uri(uriPath).LocalPath;
System.Console.WriteLine("Got Path {0}", localPath);
PackageFileSourceInfo newItem = m_viewModel.Add(folder, localPath);
//update also a view
if (newItem != null)
{
AddNodeToTreeModel(newItem, folderIter);
}
}
success = true;
Gtk.Drag.Finish(args.Context, success, false, args.Time);
}
