Split into smaller projects, now uses plugins.

RainmeterStudio.Core/Utils/DirectoryHelper.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using RainmeterStudio.Core.Model;
+
+namespace RainmeterStudio.Core.Utils
+{
+    public static class DirectoryHelper
+    {
+        /// <summary>
+        /// Gets a tree of the folder structure
+        /// </summary>
+        /// <param name="folder">Folder</param>
+        /// <returns>A tree</returns>
+        public static Tree<Reference> GetFolderTree(string folder)
+        {
+            // Build tree object
+            Reference reference = new Reference(Path.GetFileName(folder), folder);
+            Tree<Reference> tree = new Tree<Reference>(reference);
+
+            // Navigate folder structure
+            if (Directory.Exists(folder))
+            {
+                foreach (var item in Directory.EnumerateDirectories(folder)
+                    .Concat(Directory.EnumerateFiles(folder)))
+                {
+                    tree.Add(GetFolderTree(item));
+                }
+            }
+
+            // Return tree
+            return tree;
+        }
+
+        /// <summary>
+        /// Returns true if two paths are equal
+        /// </summary>
+        /// <param name="path1">First path</param>
+        /// <param name="path2">Second path</param>
+        /// <returns>True if the paths are equal</returns>
+        public static bool PathsEqual(string path1, string path2)
+        {
+            path1 = System.IO.Path.GetFullPath(path1);
+            path2 = System.IO.Path.GetFullPath(path2);
+
+            return String.Equals(path1, path2, StringComparison.InvariantCultureIgnoreCase);
+        }
+    }
+}

RainmeterStudio.Core/Utils/LinqExtension.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace RainmeterStudio.Core.Utils
+{
+    /// <summary>
+    /// Linq extensions
+    /// </summary>
+    public static class LinqExtensions
+    {
+        /// <summary>
+        /// Applies action on every item from the container
+        /// </summary>
+        /// <typeparam name="T">Enumerable type</typeparam>
+        /// <param name="container">Container</param>
+        /// <param name="action">Action</param>
+        public static void ForEach<T> (this IEnumerable<T> container, Action<T> action)
+        {
+            foreach (var obj in container)
+                action(obj);
+        }
+    }
+}

RainmeterStudio.Core/Utils/TreeExtensions.cs

@@ -0,0 +1,162 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using RainmeterStudio.Core.Model;
+
+namespace RainmeterStudio.Core.Utils
+{
+    /// <summary>
+    /// Extension methods for trees
+    /// </summary>
+    public static class TreeExtensions
+    {
+        /// <summary>
+        /// Tree traversal orders
+        /// </summary>
+        public enum TreeTraversalOrder
+        {
+            BreadthFirst,
+            DepthFirst,
+            DepthFirstPreOrder = DepthFirst,
+            DepthFirstPostOrder
+        }
+
+        /// <summary>
+        /// Traverses a tree
+        /// </summary>
+        /// <typeparam name="T">Tree data type</typeparam>
+        /// <param name="root">Root node of tree</param>
+        /// <param name="order">Traversal order</param>
+        /// <returns>An enumeration of the nodes in the specified traverse order</returns>
+        public static IEnumerable<Tree<T>> Traverse<T>(this Tree<T> root, TreeTraversalOrder order = TreeTraversalOrder.BreadthFirst)
+        {
+            if (order == TreeTraversalOrder.BreadthFirst)
+                return TraverseBF(root);
+
+            else return TraverseDF(root, order);
+        }
+
+        private static IEnumerable<Tree<T>> TraverseDF<T>(this Tree<T> root, TreeTraversalOrder order)
+        {
+            // Preorder - return root first
+            if (order == TreeTraversalOrder.DepthFirstPreOrder)
+                yield return root;
+
+            // Return children
+            foreach (var child in root.Children)
+                foreach (var node in TraverseDF(child, order))
+                    yield return node;
+
+            // Postorder - return root last
+            if (order == TreeTraversalOrder.DepthFirstPostOrder)
+                yield return root;
+        }
+
+        private static IEnumerable<Tree<T>> TraverseBF<T>(this Tree<T> root)
+        {
+            // Create a queue containing the root
+            Queue<Tree<T>> queue = new Queue<Tree<T>>();
+            queue.Enqueue(root);
+
+            // While there are elements in the queue
+            while (queue.Count > 0)
+            {
+                // Return next node in tree
+                var node = queue.Dequeue();
+                yield return node;
+
+                // Enqueue node's children
+                foreach (var child in node.Children)
+                    queue.Enqueue(child);
+            }
+        }
+
+        /// <summary>
+        /// Applies an action to every node of the tree
+        /// </summary>
+        /// <typeparam name="T">Tree data type</typeparam>
+        /// <param name="root">Root node of tree</param>
+        /// <param name="action">Action to apply</param>
+        /// <param name="order">Traversal order</param>
+        public static void Apply<T>(this Tree<T> root, Action<Tree<T>> action, TreeTraversalOrder order = TreeTraversalOrder.BreadthFirst)
+        {
+            // Safety check
+            if (action == null)
+                return;
+
+            // Apply action
+            foreach (var node in Traverse(root, order))
+                action(node);
+        }
+
+        /// <summary>
+        /// Applies an action to every node of the tree
+        /// </summary>
+        /// <typeparam name="T">Tree data type</typeparam>
+        /// <param name="root">Root node of tree</param>
+        /// <param name="action">Action to apply</param>
+        /// <param name="order">Traversal order</param>
+        public static void ApplyToData<T>(this Tree<T> root, Action<T> action, TreeTraversalOrder order = TreeTraversalOrder.BreadthFirst)
+            where T : class
+        {
+            // Safety check
+            if (action == null)
+                return;
+
+            // Apply action
+            foreach (var node in Traverse(root, order))
+                action(node.Data);
+        }
+
+        /// <summary>
+        /// Rebuilds the tree by applying the specified transform function
+        /// </summary>
+        /// <typeparam name="T">Data type of tree</typeparam>
+        /// <typeparam name="TResult">Data type of rebuilt tree</typeparam>
+        /// <param name="root">The root node</param>
+        /// <param name="transformFunction">The transform function</param>
+        /// <returns>The transformed tree</returns>
+        public static Tree<TResult> Transform<T,TResult>(this Tree<T> root, Func<Tree<T>, Tree<TResult>> transformFunction)
+        {
+            // Safety check
+            if (transformFunction == null)
+                throw new ArgumentNullException("Transform function cannot be null.");
+
+            // Build root
+            Tree<TResult> resRoot = transformFunction(root);
+
+            // Add children
+            foreach (var node in root.Children)
+                resRoot.Children.Add(Transform(node, transformFunction));
+
+            // Return
+            return resRoot;
+        }
+
+        /// <summary>
+        /// Rebuilds the tree by applying the specified transform function
+        /// </summary>
+        /// <typeparam name="T">Data type of tree</typeparam>
+        /// <typeparam name="TResult">Data type of rebuilt tree</typeparam>
+        /// <param name="root">The root node</param>
+        /// <param name="transformFunction">The transform function</param>
+        /// <returns>The transformed tree</returns>
+        public static Tree<TResult> TransformData<T, TResult>(this Tree<T> root, Func<T, TResult> transformFunction)
+        {
+            // Safety check
+            if (transformFunction == null)
+                throw new ArgumentNullException("Transform function cannot be null.");
+
+            // Build root
+            Tree<TResult> resRoot = new Tree<TResult>(transformFunction(root.Data));
+
+            // Add children
+            foreach (var node in root.Children)
+                resRoot.Children.Add(TransformData(node, transformFunction));
+
+            // Return
+            return resRoot;
+        }
+    }
+}