source: branches/HeuristicLab.Hive-3.3/sources/HeuristicLab.Hive/HeuristicLab.Hive.Server.Console/3.3/HiveServerManagementConsole.cs @ 5153

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Linq;
using System.ServiceModel;
using System.Windows.Forms;
using HeuristicLab.Hive.Contracts;
using HeuristicLab.Hive.Contracts.BusinessObjects;
using HeuristicLab.Hive.Contracts.Interfaces;
using HeuristicLab.Hive.Contracts.ResponseObjects;

namespace HeuristicLab.Hive.Server.ServerConsole {

  /// <summary>
  /// if form is closed the loginform gets an information
  /// </summary>
  /// <param name="cf"></param>
  /// <param name="error"></param>
  public delegate void closeForm(bool cf, bool error);

  public delegate void updateListView(JobDataFetcher fetcher, ListView sender, int category);

  public partial class HiveServerManagementConsole : Form {

    public event closeForm closeFormEvent;

    #region private variables
    private ResponseList<JobDto> jobs = null;

    List<ListViewGroup> jobGroup;
    private Dictionary<Guid, List<ListViewItem>> clientList = new Dictionary<Guid, List<ListViewItem>>();
    private List<Changes> changes = new List<Changes>();

    private JobDto currentJob = null;
    private SlaveDto currentSlave = null;

    private TreeNode currentGroupNode = null;
    Guid parentgroup = Guid.Empty;
    private ToolTip tt = new ToolTip();

    private const string NOGROUP = "No group";
    private TreeNode hoverNode;
    private List<ListViewGroup> lvSlaveGroups;

    private JobDataFetcher jdfFinished = null;
    private JobDataFetcher jdfOffline = null;
    private JobDataFetcher jdfCalculating = null;


    #endregion

    #region Properties
    private ISlaveManager SlaveManager {
      get {
        try {
          return ServiceLocator.GetSlaveManager();
        }
        catch (FaultException ex) {
          MessageBox.Show(ex.Message);
        }
        return null;
      }
    }
    #endregion

    public HiveServerManagementConsole() {
      InitializeComponent();
      Init();
      AddSlaves();
      //AddJobs();
      StartAutoUpdateTimers();
      //timerSyncronize.Start();
    }

    private void StartAutoUpdateTimers() {
      jdfCalculating.NewDataAvailable += new EventHandler(jdf_NewDataAvailable);
      jdfOffline.NewDataAvailable += new EventHandler(jdf_NewDataAvailable);
      jdfFinished.NewDataAvailable += new EventHandler(jdf_NewDataAvailable);
      jdfFinished.Start();
      jdfOffline.Start();
      jdfCalculating.Start();
    }

    void jdf_NewDataAvailable(object sender, EventArgs e) {
      JobDataFetcher fetcher = (JobDataFetcher)sender;
      if (fetcher.PollStates.Contains(JobState.Finished)) {
        UpdateJobListView(fetcher, lv_finishedJobs, 0);
      } else if (fetcher.PollStates.Contains(JobState.Calculating)) {
        UpdateJobListView(fetcher, lv_calculatingJobs, 1);
      } else if (fetcher.PollStates.Contains(JobState.Offline)) {
        UpdateJobListView(fetcher, lv_offlineJobs, 2);
      }
    }

    private void UpdateJobListView(JobDataFetcher fetcher, ListView listView, int category) {
      if (listView.InvokeRequired) {
        listView.Invoke(new updateListView(UpdateJobListView), new object[] { fetcher, listView, category });
      } else {
        listView.BeginUpdate();
        listView.Items.Clear();
        foreach (JobDto job in fetcher.CachedJobs) {
          ListViewItem lvi = new ListViewItem(job.Id.ToString(), category);
          lvi.Tag = job;
          listView.Items.Add(lvi);
        }
        listView.EndUpdate();
      }
    }


    private void Init() {

      jdfFinished = new JobDataFetcher(new JobState[] { JobState.Finished }, 50);
      jdfCalculating = new JobDataFetcher(new JobState[] { JobState.Calculating }, 50);
      jdfOffline = new JobDataFetcher(new JobState[] { JobState.Offline }, 50);

      cmb_finishedJob_count.SelectedItem = "50";
      cmb_offlineJob_count.SelectedItem = "50";
      cmb_calculatingJob_count.SelectedItem = "50";

      calcToolStripAbortItem.Click += (s, e) => {
        if (lv_calculatingJobs.SelectedItems.Count > 0) {
          ServiceLocator.GetJobManager().AbortJob(((JobDto)lv_calculatingJobs.SelectedItems[0].Tag).Id);
        }
      };

      offlineItemAbortJob.Click += (s, e) => {
        if (lv_offlineJobs.SelectedItems.Count > 0) {
          ServiceLocator.GetJobManager().AbortJob(((JobDto)lv_offlineJobs.SelectedItems[0].Tag).Id);
        }
      };

      //adding group
      menuItemAddGroup.Click += (s, e) => {
        AddGroup addgroup = new AddGroup();
        parentgroup = Guid.Empty;
        if ((tvClientControl.SelectedNode != null) && (((SlaveGroupDto)tvClientControl.SelectedNode.Tag).Id != Guid.Empty)) {
          parentgroup = ((SlaveGroupDto)tvClientControl.SelectedNode.Tag).Id;
        }
        addgroup.addGroupEvent += new AddGroupDelegate(addgroup_addGroupEvent);
        addgroup.Show();
      };

      //adding group
      menuItemDeleteGroup.Click += (s, e) => {
        ISlaveManager slaveManager = ServiceLocator.GetSlaveManager();
        if (tvClientControl.SelectedNode != null) {
          Response resp = slaveManager.DeleteSlaveGroup(((SlaveGroupDto)tvClientControl.SelectedNode.Tag).Id);
          if (tvClientControl.SelectedNode == currentGroupNode) {
            currentGroupNode = null;
          }
          tvClientControl.Nodes.Remove(tvClientControl.SelectedNode);
          AddSlaves();
        }
      };

      menuItemOpenCalendar.Click += (s, e) => {
        if (tvClientControl.SelectedNode != null) {
          CgCalendar cal = new CgCalendar(((SlaveGroupDto)tvClientControl.SelectedNode.Tag).Id, ((SlaveGroupDto)tvClientControl.SelectedNode.Tag).Name);
          cal.Show();
        }
      };


      // drag item to treeview
      lvClientControl.ItemDrag += delegate(object sender, ItemDragEventArgs e) {
        List<string> itemIDs = new List<string>((sender as ListView).SelectedItems.Count);
        foreach (ListViewItem item in (sender as ListView).SelectedItems) {
          itemIDs.Add(item.Name);
        }
        (sender as ListView).DoDragDrop(itemIDs.ToArray(), DragDropEffects.Move);
      };

      // drag enter on treeview
      tvClientControl.DragEnter += delegate(object sender, DragEventArgs e) {
        e.Effect = DragDropEffects.Move;
      };

      // drag over
      tvClientControl.DragOver += delegate(object sender, DragEventArgs e) {
        Point mouseLocation = tvClientControl.PointToClient(new Point(e.X, e.Y));
        TreeNode node = tvClientControl.GetNodeAt(mouseLocation);
        if (node != null && ((SlaveGroupDto)node.Tag).Id != Guid.Empty) {
          e.Effect = DragDropEffects.Move;
          if (hoverNode == null) {
            node.BackColor = Color.LightBlue;
            node.ForeColor = Color.White;
            hoverNode = node;
          } else if (hoverNode != node) {
            hoverNode.BackColor = Color.White;
            hoverNode.ForeColor = Color.Black;
            node.BackColor = Color.LightBlue;
            node.ForeColor = Color.White;
            hoverNode = node;
          }
        } else {
          e.Effect = DragDropEffects.None;
        }
      };

      // drag drop event
      tvClientControl.DragDrop += delegate(object sender, DragEventArgs e) {
        if (e.Data.GetDataPresent(typeof(string[]))) {
          Point dropLocation = (sender as TreeView).PointToClient(new Point(e.X, e.Y));
          TreeNode dropNode = (sender as TreeView).GetNodeAt(dropLocation);
          if (((SlaveGroupDto)dropNode.Tag).Id != Guid.Empty) {
            Dictionary<SlaveDto, Guid> clients = new Dictionary<SlaveDto, Guid>();
            foreach (ListViewItem lvi in lvClientControl.SelectedItems) {
              Guid groupId = Guid.Empty;
              foreach (ListViewGroup lvg in lvSlaveGroups) {
                if (lvi.Group.Header == ((SlaveGroupDto)lvg.Tag).Name) {
                  groupId = ((SlaveGroupDto)lvg.Tag).Id;
                }
              }
              clients.Add((SlaveDto)lvi.Tag, groupId);
            }
            ChangeGroup(clients, ((SlaveGroupDto)dropNode.Tag).Id);
          }
          tvClientControl_DragLeave(null, EventArgs.Empty);
          AddSlaves();
        }
      };
    }

    /// <summary>
    /// Change client to other group
    /// </summary>
    /// <param name="clients">list of clients</param>
    /// <param name="clientgroupID">group of clients</param>
    private void ChangeGroup(Dictionary<SlaveDto, Guid> clients, Guid clientgroupID) {
      ISlaveManager slaveManager = ServiceLocator.GetSlaveManager();
      foreach (KeyValuePair<SlaveDto, Guid> client in clients) {
        if (client.Key.Id != Guid.Empty) {
          Response resp = slaveManager.DeleteResourceFromGroup(client.Value, client.Key.Id);
        }
        slaveManager.AddResourceToGroup(clientgroupID, client.Key);
      }
    }

    #region Backgroundworker
    /// <summary>
    /// event on Ticker
    /// </summary>
    /// <param name="obj"></param>
    /// <param name="e"></param>
    private void TickSync(object obj, EventArgs e) {
      if (!updaterWoker.IsBusy) {
        updaterWoker.RunWorkerAsync();
      }
    }

    private void updaterWoker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {
      RefreshForm();
    }

    private void updaterWoker_DoWork(object sender, DoWorkEventArgs e) {
      changes.Clear();

      ResponseList<JobDto> jobsOld = jobs;
      try {
        IJobManager jobManager = ServiceLocator.GetJobManager();

        jobs = jobManager.GetAllJobs();

        IDictionary<int, JobDto> jobsOldHelp;
        CloneList(jobsOld, out jobsOldHelp);

        if (jobsOld != null && jobsOld.List != null && jobsOldHelp != null)
          GetDelta(jobsOld.List, jobsOldHelp);

      }
      catch (FaultException fe) {
        MessageBox.Show(fe.Message);
      }

    }

    #endregion


    private void AddSlaves() {
      lvSlaveGroups = new List<ListViewGroup>();
      clientList.Clear();
      tvClientControl.Nodes.Clear();
      try {
        ResponseList<SlaveGroupDto> clientGroups = SlaveManager.GetAllSlaveGroups();

        if (clientGroups != null && clientGroups.List != null) {
          foreach (SlaveGroupDto cg in clientGroups.List) {
            AddSlaveOrGroup(cg, null);
          }

          if (currentGroupNode != null) {
            lvClientControl.Items.Clear();
            lvClientControl.Groups.Clear();
            AddGroupsToListView(currentGroupNode);
          }
          tvClientControl.ExpandAll();
        }

      }
      catch (FaultException fe) {
        MessageBox.Show(fe.Message);
      }
    }

    private void AddSlaveOrGroup(SlaveGroupDto clientGroup, TreeNode currentNode) {
      currentNode = CreateTreeNode(clientGroup, currentNode);
      List<ListViewItem> clientGroupList = new List<ListViewItem>();
      ListViewGroup lvg;
      if (string.IsNullOrEmpty(clientGroup.Name)) {
        lvg = new ListViewGroup(NOGROUP, HorizontalAlignment.Left);
      } else {
        lvg = new ListViewGroup(clientGroup.Name, HorizontalAlignment.Left);
      }
      lvClientControl.Groups.Add(lvg);
      lvg.Tag = clientGroup;
      lvSlaveGroups.Add(lvg);
      foreach (ResourceDto resource in clientGroup.Resources) {
        if (resource is SlaveDto) {
          int percentageUsage;
          if (((SlaveDto)resource).NrOfCores.HasValue && ((SlaveDto)resource).NrOfFreeCores.HasValue) {
            percentageUsage = CapacityRam(((SlaveDto)resource).NrOfCores.Value, ((SlaveDto)resource).NrOfFreeCores.Value);
          } else {
            percentageUsage = 0;
          }

          int usage = 3;
          if ((((SlaveDto)resource).State != SlaveState.Offline) &&
            (((SlaveDto)resource).State != SlaveState.NullState)) {
            if ((percentageUsage >= 0) && (percentageUsage <= 25)) {
              usage = 0;
            } else if ((percentageUsage > 25) && (percentageUsage <= 75)) {
              usage = 1;
            } else if ((percentageUsage > 75) && (percentageUsage <= 100)) {
              usage = 2;
            }
          }
          ListViewItem lvi = new ListViewItem(resource.Name, usage, lvg);
          lvi.Tag = resource as SlaveDto;
          clientGroupList.Add(lvi);
        } else if (resource is SlaveGroupDto) {
          AddSlaveOrGroup(resource as SlaveGroupDto, currentNode);
        }
      }
      clientList.Add(clientGroup.Id, clientGroupList);
    }

    private TreeNode CreateTreeNode(SlaveGroupDto clientGroup, TreeNode currentNode) {
      TreeNode tn;
      if (string.IsNullOrEmpty(clientGroup.Name)) {
        tn = new TreeNode(NOGROUP);
      } else {
        tn = new TreeNode(clientGroup.Name);
      }
      tn.Tag = clientGroup;
      if (currentNode == null) {
        tvClientControl.Nodes.Add(tn);
      } else {
        currentNode.Nodes.Add(tn);
      }
      return tn;
    }

    private void AddGroupsToListView(TreeNode node) {
      if (node != null) {
        ListViewGroup lvg = new ListViewGroup(node.Text, HorizontalAlignment.Left);
        lvClientControl.Groups.Add(lvg);
        lvg.Tag = node.Tag;
        foreach (ListViewItem item in clientList[((SlaveGroupDto)node.Tag).Id]) {
          item.Group = lvg;
          lvClientControl.Items.Add(item);
        }

        if (node.Nodes != null) {
          foreach (TreeNode curNode in node.Nodes) {
            AddGroupsToListView(curNode);
          }
        }
      }
    }

    /// <summary>
    /// if one job is clicked, the details for the clicked job are shown
    /// in the second panel
    /// </summary>
    private void JobClicked() {
      plJobDetails.Visible = true;
      lvJobDetails.Items.Clear();

      ResponseObject<JobDto> response = ServiceLocator.GetJobManager().GetJobByIdWithDetails(currentJob.Id);

      if (response.StatusMessage != ResponseStatus.Ok || response.Obj == null)
        return;

      JobDto job = response.Obj;

      //lvSnapshots.Enabled = true;

      if (job.State == JobState.Offline) {
        pbJobControl.Image = ilLargeImgJob.Images[2];
      } else if (job.State == JobState.Calculating) {
        pbJobControl.Image = ilLargeImgJob.Images[1];
      } else if (job.State == JobState.Finished) {
        pbJobControl.Image = ilLargeImgJob.Images[0];
      }

      lblJobName.Text = job.Id.ToString();

      progressJob.Value = (int)(currentJob.ExecutionTime.TotalDays % 1) * progressJob.Maximum;
      lblProgress.Text = currentJob.ExecutionTime.ToString();

      ListViewItem lvi = new ListViewItem();
      lvi.Text = "User:";
      lvi.SubItems.Add(job.UserId.ToString());
      lvJobDetails.Items.Add(lvi);

      lvi = null;
      lvi = new ListViewItem();
      lvi.Text = "created at:";
      lvi.SubItems.Add(job.DateCreated.ToString());
      lvJobDetails.Items.Add(lvi);

      if (job.ParentJobId != null) {
        lvi = null;
        lvi = new ListViewItem();
        lvi.Text = "Parent job:";
        lvi.SubItems.Add(job.ParentJobId.ToString());
        lvJobDetails.Items.Add(lvi);
      }

      lvi = null;
      lvi = new ListViewItem();
      lvi.Text = "Priority:";
      lvi.SubItems.Add(job.Priority.ToString());
      lvJobDetails.Items.Add(lvi);

      if (job.Project != null) {
        lvi = null;
        lvi = new ListViewItem();
        lvi.Text = "Project:";
        lvi.SubItems.Add(job.Project.Name.ToString());
        lvJobDetails.Items.Add(lvi);
      }

      if (job.Slave != null) {
        lvi = null;
        lvi = new ListViewItem();
        lvi.Text = "Calculation begin:";
        lvi.SubItems.Add(job.DateCalculated.ToString());
        lvJobDetails.Items.Add(lvi);


        lvi = null;
        lvi = new ListViewItem();
        lvi.Text = "Slave calculated:";
        lvi.SubItems.Add(job.Slave.Name.ToString());
        lvJobDetails.Items.Add(lvi);

        if (job.State == JobState.Finished) {
          lvi = null;
          lvi = new ListViewItem();
          lvi.Text = "Calculation ended:";
          lvi.SubItems.Add(job.DateFinished.ToString());
          lvJobDetails.Items.Add(lvi);
        }
      }
    }

    /// <summary>
    /// if one client is clicked, the details for the clicked client are shown
    /// in the second panel
    /// </summary>
    private void SlaveClicked() {
      plClientDetails.Visible = true;

      if (currentSlave != null) {
        int percentageUsage;
        if (currentSlave.NrOfCores.HasValue && currentSlave.NrOfFreeCores.HasValue) {
          percentageUsage = CapacityRam(currentSlave.NrOfCores.Value, currentSlave.NrOfFreeCores.Value);
        } else {
          percentageUsage = 0;
        }
        int usage = 3;
        if ((currentSlave.State != SlaveState.Offline) && (currentSlave.State != SlaveState.NullState)) {
          if ((percentageUsage >= 0) && (percentageUsage <= 25)) {
            usage = 0;
          } else if ((percentageUsage > 25) && (percentageUsage <= 75)) {
            usage = 1;
          } else if ((percentageUsage > 75) && (percentageUsage <= 100)) {
            usage = 2;
          }
        }
        pbClientControl.Image = ilLargeImgClient.Images[usage];
        lblClientName.Text = currentSlave.Name;
        lblLogin.Text = currentSlave.Login.ToString();
        lblState.Text = currentSlave.State.ToString();
      }
    }

    private void RefreshForm() {
      foreach (Changes change in changes) {
        if (change.Types == Type.Job) {
          RefreshJob(change);
        }
      }
    }

    private void RefreshJob(Changes change) {
      /*if (change.ChangeType == Change.Update) {
        for (int i = 0; i < lvJobControl.Items.Count; i++) {
          if (lvJobControl.Items[i].Text == change.ID.ToString()) {
            foreach (JobDto job in jobs.List) {
              if (job.Id == change.ID) {
                lvJobControl.Items[i].Tag = job;
                if (currentJob != null) {
                  if (currentJob.Id == change.ID) {
                    currentJob = job;
                    JobClicked();
                  }
                }
                break;
              }
            }
            State state = jobs.List[change.Position].State;
            if (state == State.finished) {
              lvJobControl.Items[i].Group = jobGroup[1];
              lvJobControl.Items[i].ImageIndex = 0;
            } else if (state == State.calculating) {
              lvJobControl.Items[i].Group = jobGroup[0];
              lvJobControl.Items[i].ImageIndex = 1;
            } else if (state == State.offline || state == State.pending) {
              lvJobControl.Items[i].Group = jobGroup[2];
              lvJobControl.Items[i].ImageIndex = 2;
            }
            lvJobControl.Refresh();
          }
        }
      } else if (change.ChangeType == Change.Create) {

        ListViewItem lvi = new ListViewItem(
          change.ID.ToString(), 2, jobGroup[2]);
        foreach (JobDto job in jobs.List) {
          if (job.Id == change.ID) {
            lvi.Tag = job;
            break;
          }
        }
        lvJobControl.Items.Add(lvi);

      } else if (change.ChangeType == Change.Delete) {
        for (int i = 0; i < lvJobControl.Items.Count; i++) {
          if (change.ID.ToString() == lvJobControl.Items[i].Text.ToString()) {
            lvJobControl.Items[i].Remove();
            break;
          }
        }
      }                    */
    }


    #region Eventhandlers
    /// <summary>
    /// Send event to Login-GUI when closing
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void Close_Click(object sender, EventArgs e) {
      if (closeFormEvent != null) {
        closeFormEvent(true, false);
      }
      this.Close();
    }

    /// <summary>
    /// Send evnt to Login-GUI when closing
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void HiveServerConsoleInformation_FormClosing(object sender, FormClosingEventArgs e) {
      if (closeFormEvent != null) {
        closeFormEvent(true, false);
      }
    }

    private void AddJob_Click(object sender, EventArgs e) {
      AddJobForm newForm = new AddJobForm();
      newForm.Show();
      newForm.addJobEvent += new addDelegate(updaterWoker.RunWorkerAsync);
    }

    private void OnLVJobControlClicked(object sender, EventArgs e) {
      JobListView jlv = (JobListView)sender;
      currentJob = (JobDto)jlv.SelectedItems[0].Tag;
      JobClicked();
    }

    private void lvJobControl_MouseMove(object sender, MouseEventArgs e) {
      JobListView jlv = (JobListView)sender;
      if ((jlv.GetItemAt(e.X, e.Y) != null) &&
        (jlv.GetItemAt(e.X, e.Y).ToolTipText != null)) {
        tt.SetToolTip(jlv, jlv.GetItemAt(e.X, e.Y).ToolTipText);
      }
    }

    private void lvJobControl_MouseUp(object sender, MouseEventArgs e) {
      // If the right mouse button was clicked and released,
      // display the shortcut menu assigned to the ListView. 
      JobListView jlv = (JobListView)sender;
      jlv.ContextMenuStrip.Items.Clear();
      ListViewHitTestInfo hitTestInfo = jlv.HitTest(e.Location);
      if (e.Button == MouseButtons.Right && hitTestInfo.Item != null && jlv.SelectedItems.Count == 1) {
        JobDto selectedJob = (JobDto)jlv.SelectedItems[0].Tag;

        if (selectedJob != null && selectedJob.State == JobState.Calculating) {
          jlv.ContextMenuStrip.Items.Add(offlineItemAbortJob);
          jlv.ContextMenuStrip.Items.Add(menuItemGetSnapshot);
        }
      }
      jlv.ContextMenuStrip.Show(new Point(e.X, e.Y));
    }

    private void tvClientControl_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e) {
      lvClientControl.Items.Clear();
      lvClientControl.Groups.Clear();
      currentGroupNode = e.Node;
      AddGroupsToListView(e.Node);
    }

    private void groupToolStripMenuItem_Click(object sender, EventArgs e) {
      AddGroup addgroup = new AddGroup();
      parentgroup = Guid.Empty;
      if ((tvClientControl.SelectedNode != null) && (((SlaveGroupDto)tvClientControl.SelectedNode.Tag).Id != Guid.Empty)) {
        parentgroup = ((SlaveGroupDto)tvClientControl.SelectedNode.Tag).Id;
      }
      addgroup.addGroupEvent += new AddGroupDelegate(addgroup_addGroupEvent);
      addgroup.Show();
    }

    private void projectToolStripMenuItem_Click(object sender, EventArgs e) {
      AddProject addproject = new AddProject();
      addproject.AddProjectEvent += new AddProjectDelegate(addproject_AddProjectEvent);
      addproject.Show();
    }

    private void OnLVClientClicked(object sender, EventArgs e) {
      currentSlave = (SlaveDto)lvClientControl.SelectedItems[0].Tag;
      SlaveClicked();
    }

    private void tvClientControl_MouseUp(object sender, MouseEventArgs e) {
      // If the right mouse button was clicked and released,
      // display the shortcut menu assigned to the ListView. 
      contextMenuGroup.Items.Clear();
      TreeViewHitTestInfo hitTestInfo = tvClientControl.HitTest(e.Location);
      tvClientControl.SelectedNode = hitTestInfo.Node;
      if (e.Button != MouseButtons.Right) return;
      if (hitTestInfo.Node != null) {
        ResourceDto selectedGroup = (ResourceDto)tvClientControl.SelectedNode.Tag;

        if (selectedGroup != null) {
          contextMenuGroup.Items.Add(menuItemAddGroup);
          contextMenuGroup.Items.Add(menuItemDeleteGroup);
          contextMenuGroup.Items.Add(menuItemOpenCalendar);
        }
      } else {
        contextMenuGroup.Items.Add(menuItemAddGroup);
      }
      tvClientControl.ContextMenuStrip.Show(tvClientControl, new Point(e.X, e.Y));
    }

    private void addproject_AddProjectEvent(string name) {
      IJobManager jobManager = ServiceLocator.GetJobManager();

      ProjectDto pg = new ProjectDto() { Name = name };
      jobManager.CreateProject(pg);

    }

    private void addgroup_addGroupEvent(string name) {
      ISlaveManager slaveManager = ServiceLocator.GetSlaveManager();

      if (parentgroup != Guid.Empty) {
        SlaveGroupDto cg = new SlaveGroupDto() { Name = name };
        ResponseObject<SlaveGroupDto> respcg = slaveManager.AddSlaveGroup(cg);
        Response res = slaveManager.AddResourceToGroup(parentgroup, respcg.Obj);
        if (res != null && res.StatusMessage != ResponseStatus.Ok) {
          MessageBox.Show(res.StatusMessage.ToString(), "Error adding Group", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
      } else {
        SlaveGroupDto cg = new SlaveGroupDto() { Name = name };
        slaveManager.AddSlaveGroup(cg);
      }
      AddSlaves();
    }


    private void Refresh_Click(object sender, EventArgs e) {
      Form overlayingForm = new Form();

      overlayingForm.Show();
      overlayingForm.FormBorderStyle = FormBorderStyle.None;
      overlayingForm.BackColor = Color.Gray;
      overlayingForm.Opacity = 0.4;
      overlayingForm.Size = this.Size;
      overlayingForm.Location = this.Location;

      AddSlaves();

      overlayingForm.Close();
    }

    private void largeIconsToolStripMenuItem_Click(object sender, EventArgs e) {
      lvClientControl.View = View.LargeIcon;
      //lvJobControl.View = View.LargeIcon;
      largeIconsToolStripMenuItem.CheckState = CheckState.Checked;
      smallIconsToolStripMenuItem.CheckState = CheckState.Unchecked;
      listToolStripMenuItem.CheckState = CheckState.Unchecked;
    }

    private void smallIconsToolStripMenuItem_Click(object sender, EventArgs e) {
      lvClientControl.View = View.SmallIcon;
      //lvJobControl.View = View.SmallIcon;
      largeIconsToolStripMenuItem.CheckState = CheckState.Unchecked;
      smallIconsToolStripMenuItem.CheckState = CheckState.Checked;
      listToolStripMenuItem.CheckState = CheckState.Unchecked;
    }

    private void listToolStripMenuItem_Click(object sender, EventArgs e) {
      lvClientControl.View = View.List;
      //lvJobControl.View = View.List;
      largeIconsToolStripMenuItem.CheckState = CheckState.Unchecked;
      smallIconsToolStripMenuItem.CheckState = CheckState.Unchecked;
      listToolStripMenuItem.CheckState = CheckState.Checked;
    }

    private void tvClientControl_DragLeave(object sender, EventArgs e) {
      foreach (TreeNode node in tvClientControl.Nodes) {
        node.BackColor = Color.White;
        node.ForeColor = Color.Black;
      }
    }
    #endregion

    #region Helper methods

    private void CloneList(ResponseList<JobDto> oldList, out IDictionary<int, JobDto> newList) {
      newList = new Dictionary<int, JobDto>();
      if (oldList != null && oldList.List != null) {
        for (int i = 0; i < oldList.List.Count; i++) {
          newList.Add(i, oldList.List[i]);
        }
      }
    }

    private bool IsEqual(SlaveDto ci1, SlaveDto ci2) {
      if (ci1 == null && ci2 == null) {
        return true;
      }
      if (ci2 == null) {
        return false;
      }
      if (ci1.Id.Equals(ci2.Id)) {
        return true;
      } else return false;
    }

    private int CapacityRam(int noCores, int freeCores) {
      if (noCores > 0) {
        int capacity = ((noCores - freeCores) / noCores) * 100;
        return capacity;
      }
      return 100;
    }

    private void GetDelta(IList<JobDto> oldJobs, IDictionary<int, JobDto> helpJobs) {
      bool found = false;
      for (int i = 0; i < jobs.List.Count; i++) {
        JobDto job = jobs.List[i];
        for (int j = 0; j < oldJobs.Count; j++) {

          JobDto jobold = oldJobs[j];

          if (job.Id.Equals(jobold.Id)) {

            found = true;
            bool change = false;
            if (job.State != jobold.State) {
              change = true;
            }
            if (job.State != JobState.Offline) {
              if ((!IsEqual(job.Slave, jobold.Slave)) || (job.State != jobold.State)
                   || (job.ExecutionTime != jobold.ExecutionTime)) {
                change = true;
              }
            } else if (job.DateCalculated != jobold.DateCalculated) {
              change = true;
            }
            if (change) {
              changes.Add(new Changes { Types = Type.Job, ID = job.Id, ChangeType = Change.Update, Position = i });
            }

            int removeAt = -1;
            foreach (KeyValuePair<int, JobDto> kvp in helpJobs) {
              if (job.Id.Equals(kvp.Value.Id)) {
                removeAt = kvp.Key;
                break;
              }
            }
            if (removeAt >= 0) {
              helpJobs.Remove(removeAt);
            }
            break;
          }

        }
        if (found == false) {
          changes.Add(new Changes { Types = Type.Job, ID = job.Id, ChangeType = Change.Create });
        }
        found = false;
      }
      foreach (KeyValuePair<int, JobDto> kvp in helpJobs) {
        changes.Add(new Changes { Types = Type.Job, ID = kvp.Value.Id, ChangeType = Change.Delete, Position = kvp.Key });
      }
    }

    #endregion

    private void btn_prev_Click(object sender, EventArgs e) {
      if (sender == btn_finishedJob_prev)
        jdfFinished.Backward();
      else if (sender == btn_calculatingJobs_prev)
        jdfCalculating.Backward();
      else if (sender == btn_offlinejob_prev) {
        jdfOffline.Backward();
      }
    }

    private void btn_next_Click(object sender, EventArgs e) {
      if (sender == btn_finishedJob_next)
        jdfFinished.Forward();
      else if (sender == btn_calculatingJobs_next)
        jdfCalculating.Forward();
      else if (sender == btn_offlineJob_next) {
        jdfOffline.Forward();
      }
    }

    private void cmb_count_SelectedIndexChanged(object sender, EventArgs e) {
      ComboBox box = (ComboBox)sender;
      if (box.SelectedItem != null) {
        int val;
        if (Int32.TryParse(box.SelectedItem.ToString(), out val)) {
          if (box == cmb_offlineJob_count) {
            jdfOffline.NrOfEntriesOnPage = val;
          } else if (box == cmb_finishedJob_count) {
            jdfFinished.NrOfEntriesOnPage = val;
          } else if (box == cmb_calculatingJob_count) {
            jdfCalculating.NrOfEntriesOnPage = val;
          }
        }
      }
    }

    private void lv_Jobs_SelectedIndexChanged(object sender, EventArgs e) {
      ListView lv = (ListView)sender;
      if (lv.SelectedItems.Count > 0) {
        foreach (ListViewItem lvi in lv.SelectedItems) {
          currentJob = (JobDto)lvi.Tag;
          JobClicked();
        }
      }
    }
  }
}