public void AddNull()
{
SPSTreeNode <string> rootNode = new SPSTreeNode <string>("root");
ISPSTreeNode <string> child1 = rootNode.Add(null);
Assert.IsNull(child1.Node);
}
///// <summary>
///// Visits the web.
///// </summary>
///// <param name="rootNode">The root node.</param>
///// <param name="web">The web.</param>
//private void VisitWeb(ISPSTreeNode<ISPSHierarchyNode> rootNode, SPWeb web)
//{
// SPSTreeNode<ISPSHierarchyNode> newNode = rootNode.Add(NodeFactory.MakeWebNode(web));
// if (newNode.Deep < Filter.MaxDeepth)
// {
// if (Filter.IncludeLists)
// {
// VisitList(newNode, web);
// }
// }
// VisitSubWebs(newNode,web);
//}
private void VisitWeb(ISPSTreeNode <ISPSHierarchyNode> rootNode, SPWeb web)
{
if (rootNode.Deep < Filter.MaxDeepth)
{
if (Filter.IncludeLists)
{
VisitList(rootNode, web);
}
}
foreach (SPWeb subWeb in web.GetSubwebsForCurrentUser())
{
ISPSTreeNode <ISPSHierarchyNode> newNode = rootNode.Add(NodeFactory.MakeWebNode(subWeb));
if (newNode.Deep < Filter.MaxDeepth)
{
if (Filter.Apply(web))
{
VisitWeb(newNode, subWeb);
}
}
subWeb.Dispose();
}
if (Filter.SortHierarchy)
{
rootNode.Sort();
}
}
/// <summary>
/// Makes the tree view.
/// </summary>
/// <param name="spsRoot">The SPS root.</param>
/// <param name="delegateBound">The delegate bound.</param>
/// <returns></returns>
public static TreeView MakeTreeView(ISPSTreeNode <ISPSHierarchyNode> spsRoot, TreeBound delegateBound)
{
TreeView tree = new TreeView();
tree.Nodes.Add(MakeTreeViewInternal(spsRoot, delegateBound));
DecorateTree(tree);
return(tree);
}
public void Add()
{
SPSTreeNode <string> rootNode = new SPSTreeNode <string>("root");
ISPSTreeNode <string> child1 = rootNode.Add("child1");
ISPSTreeNode <string> child2 = rootNode.Add("child2");
Assert.AreSame(rootNode, child1.Parent);
Assert.AreSame(rootNode, child2.Parent);
Assert.IsTrue(rootNode.Children.Count == 2);
}
public void Deep()
{
SPSTreeNode <string> rootNode = new SPSTreeNode <string>("root");
ISPSTreeNode <string> child1 = rootNode.Add("child1");
ISPSTreeNode <string> child2 = child1.Add("child2");
ISPSTreeNode <string> child11 = rootNode.Add("child11");
Assert.IsTrue(rootNode.Deep == 0);
Assert.IsTrue(child1.Deep == 1);
Assert.IsTrue(child11.Deep == 1);
Assert.IsTrue(child2.Deep == 2);
}
/// <summary>
/// Iterate over childs of root node.
/// </summary>
/// <param name="root">The root.</param>
/// <param name="iteratorFunc">The iterator func.</param>
public void Iterator(ISPSTreeNode <ISPSHierarchyNode> root, SPSHierarchyIteratorFunc iteratorFunc)
{
if (root != null)
{
foreach (ISPSTreeNode <ISPSHierarchyNode> node in root.Children)
{
if (iteratorFunc != null)
{
iteratorFunc(node.Node, node.Children.Count);
}
}
}
}
private void IteratorRecursiveInternal(ISPSTreeNode <ISPSHierarchyNode> root, SPSHierarchyIteratorFunc iteratorFunc)
{
if (iteratorFunc != null)
{
iteratorFunc(root.Node, _deep);
}
_deep++;
foreach (ISPSTreeNode <ISPSHierarchyNode> node in root.Children)
{
IteratorRecursiveInternal(node, iteratorFunc);
}
_deep--;
}
/// <summary>
/// Visits the folder.
/// </summary>
/// <param name="rootNode">The root node.</param>
/// <param name="list">The list.</param>
/// <param name="rootFolder">The root folder.</param>
private void VisitFolder(ISPSTreeNode <ISPSHierarchyNode> rootNode, SPList list, SPFolder rootFolder)
{
foreach (SPFolder folder in rootFolder.SubFolders)
{
if (Filter.Apply(folder))
{
ISPSTreeNode <ISPSHierarchyNode> newNode = rootNode.Add(NodeFactory.MakeFolderNode(list, folder));
if (newNode.Deep < Filter.MaxDeepth)
{
VisitFolder(newNode, list, folder);
}
}
}
}
/// <summary>
/// Visits the list.
/// </summary>
/// <param name="rootNode">The root node.</param>
/// <param name="web">The web.</param>
private void VisitList(ISPSTreeNode <ISPSHierarchyNode> rootNode, SPWeb web)
{
foreach (SPList list in web.Lists)
{
if (Filter.Apply(list))
{
ISPSTreeNode <ISPSHierarchyNode> newNode = rootNode.Add(NodeFactory.MakeListNode(list));
if (newNode.Deep < Filter.MaxDeepth && Filter.IncludeFolders)
{
VisitFolder(newNode, list, list.RootFolder);
}
}
}
}
private void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
if (_root != null)
{
_root = null;
}
}
disposed = true;
}
}
/// <summary>
/// Gets the tree.
/// </summary>
/// <param name="spsRoot">The SPS root.</param>
/// <param name="delegateBound">The delegate bound.</param>
/// <returns></returns>
private static TreeNode MakeTreeViewInternal(ISPSTreeNode <ISPSHierarchyNode> spsRoot, TreeBound delegateBound)
{
ISPSHierarchyNode node = spsRoot.Node;
TreeNode treeNode = new TreeNode(node.Name, node.UrlSegment, node.ImageUrl, node.NavigateUrl, "");
if (delegateBound != null)
{
delegateBound(treeNode, node);
}
foreach (ISPSTreeNode <ISPSHierarchyNode> child in spsRoot.Children)
{
treeNode.ChildNodes.Add(MakeTreeViewInternal(child, delegateBound));
}
return(treeNode);
}
/// <summary>
/// Gets all.
/// </summary>
/// <exception cref="ArgumentException"><c>ArgumentException</c>.</exception>
public ISPSTreeNode <ISPSHierarchyNode> GetAll()
{
SPSHierarchyODFactory factory = new SPSHierarchyODFactory(Filter);
string webUrl = _webUrl.TrimEnd('|');
string listUrl = string.Empty;
string folderUrl = string.Empty;
if (!string.IsNullOrEmpty(_url))
{
webUrl = _url.Split('|')[0];
listUrl = _url.Split('|')[1];
folderUrl = _url.Split('|')[2];
}
using (SPWeb web = TryGetWebToUse(webUrl))
{
try
{
if (!string.IsNullOrEmpty(listUrl) && !string.IsNullOrEmpty(folderUrl))
{
SPFolder folder = web.GetFolder(webUrl + folderUrl);
_root = factory.MakeFolderNodes(folder);
}
else if (!string.IsNullOrEmpty(listUrl))
{
SPList list = web.Lists[listUrl];
_root = factory.MakeFolderNodes(list.RootFolder);
}
else
{
_root = factory.MakeWebAndListNodes(web);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
throw new ArgumentException(string.Format(
string.Format("<br/>{0} {1}",
ex.Message,
SPSLocalization.GetResourceString("SPSFW_Err_Open_Url")), _url));
}
}
return(_root);
}
private ISPSTreeNode <ISPSHierarchyNode> FindRecursive(ISPSTreeNode <ISPSHierarchyNode> parent, string path)
{
foreach (ISPSTreeNode <ISPSHierarchyNode> node in parent.Children)
{
ISPSTreeNode <ISPSHierarchyNode> foundNode;
if (node.Node.NavigateUrl == path)
{
foundNode = node;
}
else
{
foundNode = FindRecursive(node, path);
}
if (foundNode != null)
{
return(foundNode);
}
}
return(null);
}
/// <summary>
/// Iterators the recursive.
/// </summary>
/// <param name="root">The root.</param>
/// <param name="iteratorFunc">The iterator func.</param>
public void IteratorRecursive(ISPSTreeNode <ISPSHierarchyNode> root, SPSHierarchyIteratorFunc iteratorFunc)
{
_deep = 0;
IteratorRecursiveInternal(root, iteratorFunc);
}
/// <summary>
/// Fill the tree view.
/// </summary>
/// <param name="treeView">The tree view.</param>
/// <param name="spsRoot">The SPS root.</param>
/// <param name="delegateBound">The delegate bound.</param>
public static void FillTreeView(TreeView treeView, ISPSTreeNode <ISPSHierarchyNode> spsRoot, TreeBound delegateBound)
{
treeView.Nodes.Add(MakeTreeViewInternal(spsRoot, delegateBound));
DecorateTree(treeView);
}
