Changeset 15627 for branches/HiveProjectManagement/HeuristicLab.Clients.Hive.JobManager/3.3/Views/HiveResourceSelector.cs

Timestamp:

01/17/18 15:20:29 (6 years ago)

Author:

jzenisek

Message:

#2839 worked on Hive Job Manager: improved project/resource selector to show existent assignments and preserve selections

File:

• branches/HiveProjectManagement/HeuristicLab.Clients.Hive.JobManager/3.3/Views/HiveResourceSelector.cs (modified) (10 diffs)

branches/HiveProjectManagement/HeuristicLab.Clients.Hive.JobManager/3.3/Views/HiveResourceSelector.cs

@@ -40 +40 @@
     private const int slaveImageIndex = 0;
     private const int slaveGroupImageIndex = 1;
-
-    private readonly ISet<TreeNode> mainTreeNodes = new HashSet<TreeNode>();
-    private readonly ISet<TreeNode> filteredTreeNodes = new HashSet<TreeNode>();
-    private readonly ISet<TreeNode> nodeStore = new HashSet<TreeNode>();
-    private readonly ISet<Resource> resources = new HashSet<Resource>();
+    public const string additionalSlavesGroupName = "Additional Slaves";
+    public const string additionalSlavesGroupDescription = "Contains additional slaves which are either ungrouped or the parenting slave group is not assigned to the selected project.";
+
+
+    private readonly HashSet<TreeNode> mainTreeNodes = new HashSet<TreeNode>();
+    private readonly HashSet<TreeNode> filteredTreeNodes = new HashSet<TreeNode>();
+    private readonly HashSet<TreeNode> nodeStore = new HashSet<TreeNode>();
+
+    private readonly HashSet<Resource> availableResources = new HashSet<Resource>();
+    private readonly HashSet<Resource> assignedResources = new HashSet<Resource>();
+    private readonly HashSet<Resource> includedResources = new HashSet<Resource>();
+    private readonly HashSet<Resource> newAssignedResources = new HashSet<Resource>();
+    private readonly HashSet<Resource> newIncludedResources = new HashSet<Resource>();
+
+    private readonly Dictionary<Guid, HashSet<Project>> projectAncestors = new Dictionary<Guid, HashSet<Project>>();
+    private readonly Dictionary<Guid, HashSet<Project>> projectDescendants = new Dictionary<Guid, HashSet<Project>>();
+    private readonly Dictionary<Guid, HashSet<Resource>> resourceAncestors = new Dictionary<Guid, HashSet<Resource>>();
+    private readonly Dictionary<Guid, HashSet<Resource>> resourceDescendants = new Dictionary<Guid, HashSet<Resource>>();
+
+    private IEnumerable<Resource> addedResources;
+    private IEnumerable<Resource> removedResources;
+    private IEnumerable<Resource> addedIncludes;
+    private IEnumerable<Resource> removedIncludes;
+
+    private readonly Color addedAssignmentColor = Color.FromArgb(255, 87, 191, 193); // #57bfc1
+    private readonly Color removedAssignmentColor = Color.FromArgb(255, 236, 159, 72); // #ec9f48
+    private readonly Color addedIncludeColor = Color.FromArgb(25, 169, 221, 221); // #a9dddd
+    private readonly Color removedIncludeColor = Color.FromArgb(25, 249, 210, 145); // #f9d291
+    private readonly Color selectedColor = Color.FromArgb(255, 240, 194, 59); // #f0c23b
 
     private string currentSearchString;
 
+    private Guid jobId;
+    public Guid JobId {
+      get { return jobId; }
+      set {
+        if (jobId == value) return;
+        jobId = value;
+      }
+    }
+
+    private Guid? projectId;
+    public Guid? ProjectId {
+      get { return projectId; }
+      set {
+        if (projectId == value) return;
+        projectId = value;
+      }
+    }
+
+    private Guid? selectedProjectId;
+    public Guid? SelectedProjectId {
+      get { return selectedProjectId; }
+      set {
+        if (selectedProjectId == value) return;
+        selectedProjectId = value;
+      }
+    }
+
+    public bool ChangedProject {
+      get {
+        return (selectedProject == null || selectedProject.Id == projectId) ? false : true;
+      }
+    }
+
+    public bool ChangedProjectSelection {
+      get {
+        if ((lastSelectedProject == null && selectedProject != null) 
+          || (lastSelectedProject != null && selectedProject == null)
+          || (lastSelectedProject != null && selectedProject != null && lastSelectedProject.Id != selectedProject.Id))
+          return true;
+        else return false;
+      }
+    }
+
+    public bool ChangedResources {
+      get { return !assignedResources.SetEquals(newAssignedResources); }
+    }
+
+    private Project lastSelectedProject;
     private Project selectedProject;
     public Project SelectedProject {
       get { return selectedProject; }
       set {
+        lastSelectedProject = selectedProject;
         if (selectedProject == value) return;
         selectedProject = value;
-        UpdateResources();
+        UpdateResourceTree();
         OnSelectedProjectChanged();
       }
     }
-
-    private readonly IObservableSet<Resource> selectedResources = new ObservableSet<Resource>();
-    public IEnumerable<Resource> SelectedResources { get { return selectedResources; } }
+    public IEnumerable<Resource> AssignedResources {
+      get { return newAssignedResources; }
+      set {
+        if (newAssignedResources == value) return;
+        newAssignedResources.Clear();
+        foreach(var resource in value) {
+          newAssignedResources.Add(resource);
+        }
+      }
+    }
 
     public new IItemList<Project> Content {
@@ -80 +160 @@
       base.OnContentChanged();
 
-      if (Content != null) {
-        UpdateMainTree();
-        ExtractStatistics();
+      if (Content != null) {       
+        UpdateProjectGenealogy();
+        UpdateResourceGenealogy();
+        
+        if (SelectedProjectId.HasValue) {
+          SelectedProject = GetSelectedProjectById(SelectedProjectId.Value);
+        } else {
+          SelectedProject = null;
+        }
+        UpdateProjectTree();
+
       } else {
-        mainTreeNodes.Clear();
-        UpdateFilteredTree();
-      }
-
-      SelectedProject = null;
-    }
+        projectsTreeView.Nodes.Clear();
+        resourcesTreeView.Nodes.Clear();
+      }
+    }
+
     #endregion
 
@@ -96 +183 @@
       projectsTreeView.Nodes.Clear();
       resourcesTreeView.Nodes.Clear();
-      SelectedProject = null;
+      //SelectedProject = null;
     }
 
     private void searchTextBox_TextChanged(object sender, EventArgs e) {
       currentSearchString = searchTextBox.Text.ToLower();
-      UpdateFilteredTree();
+      //UpdateFilteredTree();
+      UpdateProjectTree();
     }
 
@@ -108 +196 @@
     }
 
-    private void projectsTreeView_MouseDown(object sender, MouseEventArgs e) {
-      var node = projectsTreeView.GetNodeAt(new Point(e.X, e.Y));
-
-      SelectedProject = (Project)node?.Tag;
-
+    private void projectsTreeView_AfterSelect(object sender, TreeViewEventArgs e) {
+      var node = (Project)e.Node.Tag;
+      
       if (node == null) {
         projectsTreeView.SelectedNode = null;
+      } else {
+        ReColorTreeNodes(projectsTreeView.Nodes, selectedColor, Color.Transparent, true);
+        e.Node.BackColor = selectedColor;
+        
+        if(node.Id == projectId) {
+          e.Node.Text += " [current selection]";
+        } else if(projectId == null || projectId == Guid.Empty) {
+          e.Node.Text += " [new selection]";
+        } else {
+          e.Node.Text += " [changed selection]";
+        }
+
+        SelectedProject = node;
       }
 
@@ -130 +229 @@
     }
 
+    private void resourcesTreeView_BeforeCheck(object sender, TreeViewCancelEventArgs e) {
+      var checkedResource = (Resource)e.Node.Tag;
+      if (newIncludedResources.Contains(checkedResource) || checkedResource.Id == Guid.Empty) e.Cancel = true;
+    }
+
     private void resourcesTreeView_AfterCheck(object sender, TreeViewEventArgs e) {
-      var resource = (Resource)e.Node.Tag;
-
-      if (e.Node.Checked)
-        selectedResources.Add(resource);
-      else
-        selectedResources.Remove(resource);
-
-      ExtractStatistics((Resource)resourcesTreeView.SelectedNode?.Tag);
-      OnSelectedResourcesChanged();
+      var checkedResource = (Resource)e.Node.Tag;
+      if (e.Node.Checked) {
+        newAssignedResources.Add(checkedResource);
+      } else {
+        newAssignedResources.Remove(checkedResource);
+      }
+
+      UpdateNewResourceTree();
+      //ExtractStatistics((Resource)resourcesTreeView.SelectedNode?.Tag);
+      OnAssignedResourcesChanged();
+    }
+
+    private void resourcesTreeView_NodeMouseDoubleClick(object sender, TreeNodeMouseClickEventArgs e) {
+      return;
     }
     #endregion
 
     #region Helpers
+
+
+    #region old
     private void UpdateMainTree() {
       mainTreeNodes.Clear();
@@ -155 +267 @@
           tn.Tag = g;
           tn.Text = g.Name;
-          tn.Checked = selectedResources.Any(x => x.Id == g.Id);
+          tn.Checked = assignedResources.Any(x => x.Id == g.Id);
 
           BuildMainTree(tn);
@@ -170 +282 @@
         stn.SelectedImageIndex = stn.ImageIndex;
         stn.Tag = r;
-        stn.Checked = selectedResources.Any(x => x.Id == r.Id);
+        stn.Checked = assignedResources.Any(x => x.Id == r.Id);
         tn.Nodes.Add(stn);
         mainTreeNodes.Add(stn);
@@ -224 +336 @@
       }
     }
-
-    private void UpdateResources() {
-      selectedResources.Clear();
-
+    #endregion
+
+    private Project GetSelectedProjectById(Guid projectId) {
+      return Content.Where(x => x.Id == projectId).SingleOrDefault();
+    }
+
+    private void UpdateProjectTree() {
+
+      if (string.IsNullOrEmpty(currentSearchString)) {
+        BuildProjectTree(Content);
+      } else {
+        HashSet<Project> filteredProjects = new HashSet<Project>();
+        foreach(var project in Content) {
+          if(project.Name.ToLower().Contains(currentSearchString.ToLower())) {
+            filteredProjects.Add(project);
+            filteredProjects.UnionWith(projectAncestors[project.Id]);
+          }
+        }
+        BuildProjectTree(filteredProjects);
+      }
+    }
+
+    private void BuildProjectTree(IEnumerable<Project> projects) {
+      projectsTreeView.Nodes.Clear();
+      if (!projects.Any()) return;
+
+      // select all top level projects (withouth parent, or without parent within current project collection)
+      var mainProjects = new HashSet<Project>(projects.Where(x => x.ParentProjectId == null));
+      var parentedMainProjects = new HashSet<Project>(projects
+        .Where(x => x.ParentProjectId.HasValue
+        && !projects.Select(y => y.Id).Contains(x.ParentProjectId.Value)));
+      mainProjects.UnionWith(parentedMainProjects);
+      var subProbjects = new HashSet<Project>(projects.Except(mainProjects));
+
+      var stack = new Stack<Project>(mainProjects.OrderByDescending(x => x.Name));
+
+      TreeNode currentNode = null;
+      Project currentProject = null;
+
+      while(stack.Any()) {
+        var newProject = stack.Pop();
+        var newNode = new TreeNode(newProject.Name) { Tag = newProject };
+
+        while (currentNode != null && newProject.ParentProjectId != currentProject.Id) {
+          currentNode = currentNode.Parent;
+          currentProject = currentNode == null ? null : (Project)currentNode.Tag;
+        }
+
+        if (currentNode == null) {
+          projectsTreeView.Nodes.Add(newNode);
+          newNode.ImageIndex = greenFlagImageIndex;
+        } else {
+          currentNode.Nodes.Add(newNode);
+          newNode.ImageIndex = redFlagImageIndex;
+        }
+
+        newNode.SelectedImageIndex = newNode.ImageIndex;
+
+        if (SelectedProject != null && SelectedProject.Id.Equals(newProject.Id)) {
+          newNode.BackColor = selectedColor;
+          if(SelectedProject.Id == projectId) {
+            newNode.Text += " [current selection]";
+          } else if (projectId == null || projectId == Guid.Empty) {
+            newNode.Text += " [new selection]";
+          } else {
+            newNode.Text += " [changed selection]";
+          }
+        }
+
+        if (!string.IsNullOrEmpty(currentSearchString) && newProject.Name.ToLower().Contains(currentSearchString.ToLower())) {
+          newNode.BackColor = Color.LightBlue;
+        }
+
+        var childProjects = subProbjects.Where(x => x.ParentProjectId == newProject.Id);
+        if (childProjects.Any()) {
+          foreach (var project in childProjects.OrderByDescending(x => x.Name)) {
+            subProbjects.Remove(project);
+            stack.Push(project);
+          }
+          currentNode = newNode;
+          currentProject = newProject;
+        }
+      }
+
+      projectsTreeView.ExpandAll();
+    }
+
+    private void UpdateProjectGenealogy() {
+      projectAncestors.Clear();
+      projectDescendants.Clear();
+      var projects = Content;
+
+      foreach (var p in projects) {
+        projectAncestors.Add(p.Id, new HashSet<Project>());
+        projectDescendants.Add(p.Id, new HashSet<Project>());
+      }
+
+      foreach (var p in projects) {
+        var parentProjectId = p.ParentProjectId;
+        while (parentProjectId != null) {
+          var parent = projects.SingleOrDefault(x => x.Id == parentProjectId);
+          if (parent != null) {
+            projectAncestors[p.Id].Add(parent);
+            projectDescendants[parent.Id].Add(p);
+            parentProjectId = parent.ParentProjectId;
+          } else {
+            parentProjectId = null;
+          }
+        }
+      }
+    }
+
+
+    private static IEnumerable<Resource> GetAssignedResourcesForProject(Guid projectId) {
+      var assignedProjectResources = HiveServiceLocator.Instance.CallHiveService(s => s.GetAssignedResourcesForProject(projectId));
+      return HiveAdminClient.Instance.Resources.Where(x => assignedProjectResources.Select(y => y.ResourceId).Contains(x.Id));
+    }
+
+    private static IEnumerable<Resource> GetAssignedResourcesForJob(Guid jobId) {
+      var assignedJobResources = HiveServiceLocator.Instance.CallHiveService(s => s.GetAssignedResourcesForJob(jobId));
+      return HiveAdminClient.Instance.Resources.Where(x => assignedJobResources.Select(y => y.ResourceId).Contains(x.Id));
+    }
+
+    private void UpdateResourceTree() {
+      UpdateAvailableResources();
+      UpdateAssignedResources();
+      UpdateIncludedResources();
+      BuildResourceTree(availableResources);
+    }
+
+    private void UpdateNewResourceTree() {
+      UpdateNewAssignedResources();
+      UpdateNewIncludedResources();
+      BuildResourceTree(availableResources);
+    }
+
+    private void UpdateAvailableResources() {
+      availableResources.Clear();
       if (selectedProject != null) {
-        var assignedResources = HiveServiceLocator.Instance.CallHiveService(s => s.GetAssignedResourcesForProject(selectedProject.Id));
-        var assignedResourceIds = new HashSet<Guid>(assignedResources.Select(x => x.ResourceId));
-
-        foreach (var resource in HiveAdminClient.Instance.Resources) {
-          if (assignedResourceIds.Contains(resource.Id)) {
-            resources.Add(resource);
-            selectedResources.Add(resource);
-          }
-        }
-      }
-
-      BuildResourceTree(selectedResources);
+        var assignedProjectResources = GetAssignedResourcesForProject(selectedProject.Id);
+        foreach (var resource in assignedProjectResources) {
+          availableResources.Add(resource);
+          foreach(var descendant in resourceDescendants[resource.Id]) {
+            availableResources.Add(descendant);
+          }
+        }
+      }
       ExtractStatistics();
-      OnSelectedResourcesChanged();
-    }
-
-    private Resource BuildResourceTree(IEnumerable<Resource> resources) {
+      //OnAssignedResourcesChanged();
+    }
+
+    private void UpdateAssignedResources() {
+
+      if (JobId == Guid.Empty && ChangedProjectSelection) { // new, unchanged jobs get all avaialable resources
+        // update new assigned resources
+        assignedResources.Clear();
+        newAssignedResources.Clear();
+        foreach (var resource in availableResources
+          .Where(x => !x.ParentResourceId.HasValue
+          || !availableResources.Select(y => y.Id).Contains(x.ParentResourceId.Value))) {
+          newAssignedResources.Add(resource);
+        }
+
+      } else if(JobId != Guid.Empty) { // existent, unchanged jobs get all assigned resources
+        // update assigned resources
+        var assignedJobResources = GetAssignedResourcesForJob(JobId);
+        foreach (var resource in assignedJobResources) {
+          assignedResources.Add(resource);
+        }
+
+        if(ChangedProjectSelection) {
+          newAssignedResources.Clear();
+          foreach (var resource in assignedJobResources) {
+            newAssignedResources.Add(resource);
+          }
+        }
+      } else {
+        var newAssignedResourceIds = newAssignedResources.Select(x => x.Id).ToList();
+        newAssignedResources.Clear();
+        foreach(var r in availableResources.Where(x => newAssignedResourceIds.Contains(x.Id))) {
+          newAssignedResources.Add(r);
+        }
+      }
+
+      ExtractStatistics();
+      OnAssignedResourcesChanged();
+    }
+
+    private void UpdateNewAssignedResources() {
+      for(int i = newAssignedResources.Count-1; i>=0; i--) {
+        if(newAssignedResources.Intersect(resourceAncestors[newAssignedResources.ElementAt(i).Id]).Any()) {
+          newAssignedResources.Remove(newAssignedResources.ElementAt(i));
+        }
+      }
+    }
+
+    private void UpdateIncludedResources() {
+      includedResources.Clear();
+      newIncludedResources.Clear();
+      if (JobId != Guid.Empty) {
+        foreach (var item in assignedResources) {
+          foreach (var descendant in resourceDescendants[item.Id]) {
+            includedResources.Add(descendant);
+            newIncludedResources.Add(descendant);
+          }
+        }
+      } else {
+        foreach (var item in newAssignedResources) {
+          foreach (var descendant in resourceDescendants[item.Id]) {
+            newIncludedResources.Add(descendant);
+          }
+        }
+      }
+    }
+
+    private void UpdateNewIncludedResources() {
+      newIncludedResources.Clear();
+      foreach (var item in newAssignedResources) {
+        foreach (var descendant in resourceDescendants[item.Id]) {
+          newIncludedResources.Add(descendant);
+        }
+      }
+    }
+
+    private void UpdateResourceGenealogy() {
+      resourceAncestors.Clear();
+      resourceDescendants.Clear();
+      var resources = HiveAdminClient.Instance.Resources;
+
+      foreach (var r in resources) {
+        resourceAncestors.Add(r.Id, new HashSet<Resource>());
+        resourceDescendants.Add(r.Id, new HashSet<Resource>());
+      }
+
+      foreach (var r in resources) {
+        var parentResourceId = r.ParentResourceId;
+        while (parentResourceId != null) {
+          var parent = resources.SingleOrDefault(x => x.Id == parentResourceId);
+          if (parent != null) {
+            resourceAncestors[r.Id].Add(parent);
+            resourceDescendants[parent.Id].Add(r);
+            parentResourceId = parent.ParentResourceId;
+          } else {
+            parentResourceId = null;
+          }
+        }
+      }
+    }
+
+    private void BuildResourceTree(IEnumerable<Resource> resources) {
+      resourcesTreeView.Nodes.Clear();
+      if (!resources.Any()) return;
+
+      resourcesTreeView.BeforeCheck -= resourcesTreeView_BeforeCheck;
+      resourcesTreeView.AfterCheck -= resourcesTreeView_AfterCheck;
+
+      var mainResources = new HashSet<Resource>(resources.OfType<SlaveGroup>().Where(x => x.ParentResourceId == null));
+      var parentedMainResources = new HashSet<Resource>(resources.OfType<SlaveGroup>()
+        .Where(x => x.ParentResourceId.HasValue && !resources.Select(y => y.Id).Contains(x.ParentResourceId.Value)));
+      mainResources.UnionWith(parentedMainResources);
+      var subResources = new HashSet<Resource>(resources.Except(mainResources));
+
+      var addedAssignments = newAssignedResources.Except(assignedResources);
+      var removedAssignments = assignedResources.Except(newAssignedResources);
+      var addedIncludes = newIncludedResources.Except(includedResources);
+      var removedIncludes = includedResources.Except(newIncludedResources);
+
+      HashSet<TreeNode> expandedNodes = new HashSet<TreeNode>();
+      TreeNode currentNode = null;
+      Resource currentResource = null;
+
+      var stack = new Stack<Resource>(mainResources.OrderByDescending(x => x.Name));
+
+      while (stack.Any()) {
+        var newResource = stack.Pop();
+        var newNode = new TreeNode(newResource.Name) { Tag = newResource };
+
+        // search for parent node of newNode and save in currentNode
+        // necessary since newNodes (stack top items) might be siblings
+        // or grand..grandparents of previous node (currentNode)
+        while (currentNode != null && newResource.ParentResourceId != currentResource.Id) {
+          currentNode = currentNode.Parent;
+          currentResource = currentNode == null ? null : (Resource)currentNode.Tag;
+        }
+
+        if (currentNode == null) {
+          resourcesTreeView.Nodes.Add(newNode);
+        } else {
+          currentNode.Nodes.Add(newNode);
+        }
+
+        if(newAssignedResources.Select(x => x.Id).Contains(newResource.Id)
+          || assignedResources.Select(x => x.Id).Contains(newResource.Id)
+          || newIncludedResources.Select(x => x.Id).Contains(newResource.Id)
+          || includedResources.Select(x => x.Id).Contains(newResource.Id)) {
+          expandedNodes.Add(newNode);
+        }
+
+        if (newAssignedResources.Select(x => x.Id).Contains(newResource.Id)) {
+          newNode.Checked = true;
+        } else if (newIncludedResources.Select(x => x.Id).Contains(newResource.Id)) {
+          newNode.Checked = true;
+          newNode.ForeColor = SystemColors.GrayText;
+        }
+
+        if (includedResources.Select(x => x.Id).Contains(newResource.Id) && newIncludedResources.Select(x => x.Id).Contains(newResource.Id)) {
+          newNode.Text += " [included]";
+        } else if (addedIncludes.Select(x => x.Id).Contains(newResource.Id)) {
+          newNode.BackColor = addedIncludeColor;
+          newNode.ForeColor = SystemColors.GrayText;
+          newNode.Text += " [added include]";
+        } else if (removedIncludes.Select(x => x.Id).Contains(newResource.Id)) {
+          newNode.BackColor = removedIncludeColor;
+          newNode.Text += " [removed include]";
+        }
+
+        if (addedAssignments.Select(x => x.Id).Contains(newResource.Id)) {
+          newNode.BackColor = addedAssignmentColor;
+          newNode.ForeColor = SystemColors.ControlText;
+          newNode.Text += " [added selection]";
+        } else if (removedAssignments.Select(x => x.Id).Contains(newResource.Id)) {
+          newNode.BackColor = removedAssignmentColor;
+          newNode.ForeColor = SystemColors.ControlText;
+          newNode.Text += " [removed selection]";
+        }
+
+        if (newResource is Slave) {
+          newNode.ImageIndex = slaveImageIndex;
+        } else {
+          newNode.ImageIndex = slaveGroupImageIndex;
+
+          var childResources = subResources.Where(x => x.ParentResourceId == newResource.Id);
+          if (childResources.Any()) {
+            foreach (var resource in childResources.OrderByDescending(x => x.Name)) {
+              subResources.Remove(resource);
+              stack.Push(resource);
+            }
+            currentNode = newNode;
+            currentResource = newResource;
+          }
+        }
+        newNode.SelectedImageIndex = newNode.ImageIndex;
+      }
+
+      var singleSlaves = subResources.OfType<Slave>();
+      if (singleSlaves.Any()) {
+
+        var additionalNode = new TreeNode(additionalSlavesGroupName) {
+          ForeColor = SystemColors.GrayText,
+          Tag = new SlaveGroup() {
+            Name = additionalSlavesGroupName,
+            Description = additionalSlavesGroupDescription
+          }
+        };
+
+        foreach (var slave in singleSlaves.OrderBy(x => x.Name)) {
+          var slaveNode = new TreeNode(slave.Name) { Tag = slave };
+          additionalNode.Nodes.Add(slaveNode);
+        }
+
+        resourcesTreeView.Nodes.Add(additionalNode);
+      }
+
+      
+      foreach (var node in expandedNodes) {
+        node.Expand();
+        var parent = node.Parent;
+        while(parent != null) {
+          parent.Expand();
+          parent = parent.Parent;
+        }
+      }
+
+      resourcesTreeView.BeforeCheck += resourcesTreeView_BeforeCheck;
+      resourcesTreeView.AfterCheck += resourcesTreeView_AfterCheck;
+      //resourcesTreeView.ExpandAll();
+    }
+
+    private void ExpandSlaveGroupNodes() {
+      foreach (TreeNode n in nodeStore.Where(x => x.Tag is SlaveGroup)) {
+        TreeNode[] children = new TreeNode[n.Nodes.Count];
+        n.Nodes.CopyTo(children, 0);
+        if (children.Any(x => x.Tag is SlaveGroup)) n.Expand();
+      }
+    }
+
+    private void ExtractStatistics(Resource resource = null) {
+      ISet<Slave> selectedSlaves = null;
+
+      if (resource != null) {
+
+
+        var slaveGroup = resource as SlaveGroup;
+        if (slaveGroup != null) {
+          selectedSlaves = new HashSet<Slave>(resourceDescendants[slaveGroup.Id].OfType<Slave>());
+          selectedSlaves.IntersectWith(newAssignedResources.OfType<Slave>());
+        } else {
+          selectedSlaves = new HashSet<Slave>(new[] { resource as Slave });
+        }
+      } else {
+        selectedSlaves = new HashSet<Slave>(newAssignedResources.OfType<Slave>());
+      }
+
+      int sumCores = selectedSlaves.OfType<Slave>().Sum(x => x.Cores.GetValueOrDefault());
+      int sumFreeCores = selectedSlaves.OfType<Slave>().Sum(x => x.FreeCores.GetValueOrDefault());
+      double sumMemory = selectedSlaves.OfType<Slave>().Sum(x => x.Memory.GetValueOrDefault()) / 1024.0;
+      double sumFreeMemory = selectedSlaves.OfType<Slave>().Sum(x => x.FreeMemory.GetValueOrDefault()) / 1024.0;
+
+      coresSummaryLabel.Text = $"{sumCores} Total ({sumFreeCores} Free / {sumCores - sumFreeCores} Used)";
+      memorySummaryLabel.Text = $"{sumMemory:0.00} GB Total ({sumFreeMemory:0.00} GB Free / {(sumMemory - sumFreeMemory):0.00} GB Used)";
+    }
+
+    private void ReColorTreeNodes(TreeNodeCollection nodes, Color c1, Color c2, bool resetText) {
+      foreach (TreeNode n in nodes) {
+        if (n.BackColor.Equals(c1)) {
+          n.BackColor = c2;
+          if(resetText) n.Text = ((Project)n.Tag).Name;
+        }
+        if (n.Nodes.Count > 0) {
+          ReColorTreeNodes(n.Nodes, c1, c2, resetText);
+        }
+      }
+    }
+
+    private void ExtractStatistics_Old(Resource resource = null) {
+      ISet<Slave> selectedSlaves = null;
+
+      if (resource != null) {
+        var slaveGroup = resource as SlaveGroup;
+        if (slaveGroup != null) {
+          var children = new HashSet<Resource>(availableResources.Where(x => x.ParentResourceId == slaveGroup.Id));
+          int nrOfChildren = children.Count;
+          do {
+            var newChildren = availableResources.Where(x => children.Any(y => y.Id == x.ParentResourceId));
+            foreach (var newChild in newChildren)
+              children.Add(newChild);
+          } while (children.Count > nrOfChildren);
+          selectedSlaves = new HashSet<Slave>(children.OfType<Slave>());
+          selectedSlaves.IntersectWith(assignedResources.OfType<Slave>());
+        } else {
+          selectedSlaves = new HashSet<Slave>(new[] { resource as Slave });
+        }
+      } else {
+        selectedSlaves = new HashSet<Slave>(assignedResources.OfType<Slave>());
+      }
+
+      int sumCores = selectedSlaves.OfType<Slave>().Sum(x => x.Cores.GetValueOrDefault());
+      int sumFreeCores = selectedSlaves.OfType<Slave>().Sum(x => x.FreeCores.GetValueOrDefault());
+      double sumMemory = selectedSlaves.OfType<Slave>().Sum(x => x.Memory.GetValueOrDefault()) / 1024.0;
+      double sumFreeMemory = selectedSlaves.OfType<Slave>().Sum(x => x.FreeMemory.GetValueOrDefault()) / 1024.0;
+
+      coresSummaryLabel.Text = $"{sumCores} Total ({sumFreeCores} Free / {sumCores - sumFreeCores} Used)";
+      memorySummaryLabel.Text = $"{sumMemory:0.00} GB Total ({sumFreeMemory:0.00} GB Free / {(sumMemory - sumFreeMemory):0.00} GB Used)";
+    }
+
+    private Resource BuildResourceTree_Old(IEnumerable<Resource> resources) {
       resourcesTreeView.Nodes.Clear();
       if (!resources.Any()) return null;
@@ -295 +841 @@
     }
 
-    private void ExpandSlaveGroupNodes() {
-      foreach (TreeNode n in nodeStore.Where(x => x.Tag is SlaveGroup)) {
-        TreeNode[] children = new TreeNode[n.Nodes.Count];
-        n.Nodes.CopyTo(children, 0);
-        if (children.Any(x => x.Tag is SlaveGroup)) n.Expand();
-      }
-    }
-
-    private void ExtractStatistics(Resource resource = null) {
-      ISet<Slave> selectedSlaves = null;
-
-      if (resource != null) {
-        var slaveGroup = resource as SlaveGroup;
-        if (slaveGroup != null) {
-          var children = new HashSet<Resource>(resources.Where(x => x.ParentResourceId == slaveGroup.Id));
-          int nrOfChildren = children.Count;
-          do {
-            var newChildren = resources.Where(x => children.Any(y => y.Id == x.ParentResourceId));
-            foreach (var newChild in newChildren)
-              children.Add(newChild);
-          } while (children.Count > nrOfChildren);
-          selectedSlaves = new HashSet<Slave>(children.OfType<Slave>());
-          selectedSlaves.IntersectWith(selectedResources.OfType<Slave>());
-        } else {
-          selectedSlaves = new HashSet<Slave>(new[] { resource as Slave });
-        }
-      } else {
-        selectedSlaves = new HashSet<Slave>(selectedResources.OfType<Slave>());
-      }
-
-      int sumCores = selectedSlaves.OfType<Slave>().Sum(x => x.Cores.GetValueOrDefault());
-      int sumFreeCores = selectedSlaves.OfType<Slave>().Sum(x => x.FreeCores.GetValueOrDefault());
-      double sumMemory = selectedSlaves.OfType<Slave>().Sum(x => x.Memory.GetValueOrDefault()) / 1024.0;
-      double sumFreeMemory = selectedSlaves.OfType<Slave>().Sum(x => x.FreeMemory.GetValueOrDefault()) / 1024.0;
-
-      coresSummaryLabel.Text = $"{sumCores} Total ({sumFreeCores} Free / {sumCores - sumFreeCores} Used)";
-      memorySummaryLabel.Text = $"{sumMemory:0.00} GB Total ({sumFreeMemory:0.00} GB Free / {(sumMemory - sumFreeMemory):0.00} GB Used)";
-    }
     #endregion
 
@@ -341 +849 @@
     }
 
-    public event EventHandler SelectedResourcesChanged;
-    private void OnSelectedResourcesChanged() {
-      SelectedResourcesChanged?.Invoke(this, EventArgs.Empty);
+    public event EventHandler AssignedResourcesChanged;
+    private void OnAssignedResourcesChanged() {
+      AssignedResourcesChanged?.Invoke(this, EventArgs.Empty);
     }