Index: branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/RefreshableJob.cs
===================================================================
--- branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/RefreshableJob.cs	(revision 6725)
+++ branches/HeuristicLab.Hive-3.4/sources/HeuristicLab.Clients.Hive/3.3/RefreshableJob.cs	(revision 6743)
@@ -55,12 +55,12 @@
     }
 
-    private ItemCollection<HiveTask> hiveJobs;
-    public ItemCollection<HiveTask> HiveJobs {
-      get { return hiveJobs; }
+    private ItemCollection<HiveTask> hiveTasks;
+    public ItemCollection<HiveTask> HiveTasks {
+      get { return hiveTasks; }
       set {
-        if (hiveJobs != value) {
-          if (hiveJobs != null) DeregisterHiveJobsEvents();
-          hiveJobs = value;
-          if (hiveJobs != null) RegisterHiveJobsEvents();
+        if (hiveTasks != value) {
+          if (hiveTasks != null) DeregisterHiveJobsEvents();
+          hiveTasks = value;
+          if (hiveTasks != null) RegisterHiveJobsEvents();
           OnHiveJobsChanged();
         }
@@ -100,5 +100,5 @@
           }
           if (RefreshAutomatically) {
-            if (this.HiveJobs != null && this.HiveJobs.Count > 0 && (jobResultPoller == null || !jobResultPoller.IsPolling)) {
+            if (this.HiveTasks != null && this.HiveTasks.Count > 0 && (jobResultPoller == null || !jobResultPoller.IsPolling)) {
               StartResultPolling();
             }
@@ -130,6 +130,6 @@
           isControllable = value;
           OnIsControllableChanged();
-          if (this.hiveJobs != null) {
-            foreach (var hiveJob in this.hiveJobs) {
+          if (this.hiveTasks != null) {
+            foreach (var hiveJob in this.hiveTasks) {
               hiveJob.IsControllable = value;
             }
@@ -186,5 +186,5 @@
 
     public StateLogListList StateLogList {
-      get { return new StateLogListList(this.GetAllHiveJobs().Select(x => x.StateLog)); }
+      get { return new StateLogListList(this.GetAllHiveTasks().Select(x => x.StateLog)); }
     }
 
@@ -196,5 +196,5 @@
       this.jobDownloader = new ConcurrentTaskDownloader<ItemTask>(2, 2);
       this.jobDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobDownloader_ExceptionOccured);
-      this.HiveJobs = new ItemCollection<HiveTask>();
+      this.HiveTasks = new ItemCollection<HiveTask>();
     }
     public RefreshableJob(Job hiveExperiment) {
@@ -204,5 +204,5 @@
       this.jobDownloader = new ConcurrentTaskDownloader<ItemTask>(2, 2);
       this.jobDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobDownloader_ExceptionOccured);
-      this.HiveJobs = new ItemCollection<HiveTask>();
+      this.HiveTasks = new ItemCollection<HiveTask>();
     }
     protected RefreshableJob(RefreshableJob original, Cloner cloner) {
@@ -214,5 +214,5 @@
       this.jobDownloader = new ConcurrentTaskDownloader<ItemTask>(2, 2);
       this.jobDownloader.ExceptionOccured += new EventHandler<EventArgs<Exception>>(jobDownloader_ExceptionOccured);
-      this.HiveJobs = cloner.Clone(original.HiveJobs);
+      this.HiveTasks = cloner.Clone(original.HiveTasks);
       this.ExecutionTime = original.ExecutionTime;
       this.ExecutionState = original.ExecutionState;
@@ -263,23 +263,23 @@
     }
     private void jobResultPoller_JobResultReceived(object sender, EventArgs<IEnumerable<LightweightTask>> e) {
-      foreach (LightweightTask lightweightJob in e.Value) {
-        HiveTask hiveJob = GetHiveJobById(lightweightJob.Id);
-        if (hiveJob != null) {
+      foreach (LightweightTask lightweightTask in e.Value) {
+        HiveTask hiveTask = GetHiveJobById(lightweightTask.Id);
+        if (hiveTask != null) {
           // lastJobDataUpdate equals DateTime.MinValue right after it was uploaded. When the first results are polled, this value is updated
-          if (hiveJob.Task.State == TaskState.Offline && lightweightJob.State != TaskState.Finished && lightweightJob.State != TaskState.Failed && lightweightJob.State != TaskState.Aborted) {
-            hiveJob.Task.LastJobDataUpdate = lightweightJob.LastJobDataUpdate;
+          if (hiveTask.Task.State == TaskState.Offline && lightweightTask.State != TaskState.Finished && lightweightTask.State != TaskState.Failed && lightweightTask.State != TaskState.Aborted) {
+            hiveTask.Task.LastTaskDataUpdate = lightweightTask.LastTaskDataUpdate;
           }
 
-          hiveJob.UpdateFromLightweightJob(lightweightJob);
-
-          if (!hiveJob.IsFinishedTaskDownloaded && !hiveJob.IsDownloading && hiveJob.Task.LastJobDataUpdate < lightweightJob.LastJobDataUpdate) {
-            log.LogMessage(string.Format("Downloading task {0}", lightweightJob.Id));
-            hiveJob.IsDownloading = true;
-            jobDownloader.DownloadJob(hiveJob.Task, (localJob, itemJob) => {
+          hiveTask.UpdateFromLightweightJob(lightweightTask);
+
+          if (!hiveTask.IsFinishedTaskDownloaded && !hiveTask.IsDownloading && hiveTask.Task.LastTaskDataUpdate < lightweightTask.LastTaskDataUpdate) {
+            log.LogMessage(string.Format("Downloading task {0}", lightweightTask.Id));
+            hiveTask.IsDownloading = true;
+            jobDownloader.DownloadTask(hiveTask.Task, (localJob, itemJob) => {
               log.LogMessage(string.Format("Finished downloading task {0}", localJob.Id));
-              HiveTask localHiveJob = GetHiveJobById(localJob.Id);
+              HiveTask localHiveTask = GetHiveJobById(localJob.Id);
 
               if (itemJob == null) {
-                localHiveJob.IsDownloading = false;
+                localHiveTask.IsDownloading = false;
               }
 
@@ -290,15 +290,15 @@
 
                 if (localJob.State == TaskState.Paused) {
-                  localHiveJob.ItemTask = itemJob;
+                  localHiveTask.ItemTask = itemJob;
                 } else {
                   if (localJob.ParentTaskId.HasValue) {
-                    HiveTask parentHiveJob = GetHiveJobById(localJob.ParentTaskId.Value);
-                    parentHiveJob.IntegrateChild(itemJob, localJob.Id);
+                    HiveTask parentHiveTask = GetHiveJobById(localJob.ParentTaskId.Value);
+                    parentHiveTask.IntegrateChild(itemJob, localJob.Id);
                   } else {
-                    localHiveJob.ItemTask = itemJob;
+                    localHiveTask.ItemTask = itemJob;
                   }
                 }
-                localHiveJob.IsDownloading = false;
-                localHiveJob.Task.LastJobDataUpdate = localJob.LastJobDataUpdate;
+                localHiveTask.IsDownloading = false;
+                localHiveTask.Task.LastTaskDataUpdate = localJob.LastTaskDataUpdate;
               }
             });
@@ -317,5 +317,5 @@
 
     public HiveTask GetHiveJobById(Guid jobId) {
-      foreach (HiveTask job in this.HiveJobs) {
+      foreach (HiveTask job in this.HiveTasks) {
         var hj = job.GetHiveTaskByTaskId(jobId);
         if (hj != null)
@@ -325,5 +325,5 @@
     }
     private void UpdateStatistics() {
-      var jobs = this.GetAllHiveJobs();
+      var jobs = this.GetAllHiveTasks();
       job.JobCount = jobs.Count();
       job.CalculatingCount = jobs.Count(j => j.Task.State == TaskState.Calculating);
@@ -333,5 +333,5 @@
 
     public bool AllJobsFinished() {
-      return this.GetAllHiveJobs().All(j => (j.Task.State == TaskState.Finished
+      return this.GetAllHiveTasks().All(j => (j.Task.State == TaskState.Finished
                                                    || j.Task.State == TaskState.Aborted
                                                    || j.Task.State == TaskState.Failed)
@@ -346,5 +346,5 @@
     }
     public void UpdateTotalExecutionTime() {
-      this.ExecutionTime = TimeSpan.FromMilliseconds(this.GetAllHiveJobs().Sum(x => x.Task.ExecutionTime.TotalMilliseconds));
+      this.ExecutionTime = TimeSpan.FromMilliseconds(this.GetAllHiveTasks().Sum(x => x.Task.ExecutionTime.TotalMilliseconds));
     }
     #endregion
@@ -468,15 +468,15 @@
     #endregion
 
-    #region HiveJobs Events
+    #region HiveTasks Events
     private void RegisterHiveJobsEvents() {
-      this.hiveJobs.ItemsAdded += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsAdded);
-      this.hiveJobs.ItemsRemoved += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsRemoved);
-      this.hiveJobs.CollectionReset += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_CollectionReset);
+      this.hiveTasks.ItemsAdded += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsAdded);
+      this.hiveTasks.ItemsRemoved += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsRemoved);
+      this.hiveTasks.CollectionReset += new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_CollectionReset);
     }
 
     private void DeregisterHiveJobsEvents() {
-      this.hiveJobs.ItemsAdded -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsAdded);
-      this.hiveJobs.ItemsRemoved -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsRemoved);
-      this.hiveJobs.CollectionReset -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_CollectionReset);
+      this.hiveTasks.ItemsAdded -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsAdded);
+      this.hiveTasks.ItemsRemoved -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_ItemsRemoved);
+      this.hiveTasks.CollectionReset -= new CollectionItemsChangedEventHandler<HiveTask>(hiveJobs_CollectionReset);
     }
 
@@ -514,5 +514,5 @@
         DeregisterResultPollingEvents();
       }
-      if (this.HiveJobs != null && this.HiveJobs.Count > 0 && this.GetAllHiveJobs().All(x => x.Task.Id != Guid.Empty)) {
+      if (this.HiveTasks != null && this.HiveTasks.Count > 0 && this.GetAllHiveTasks().All(x => x.Task.Id != Guid.Empty)) {
         if (this.RefreshAutomatically)
           StartResultPolling();
@@ -581,16 +581,16 @@
 
     public bool IsFinished() {
-      return HiveJobs != null
-        && HiveJobs.All(x => x.Task.DateFinished.HasValue && x.Task.DateCreated.HasValue);
-    }
-
-    public IEnumerable<HiveTask> GetAllHiveJobs() {
-      if (hiveJobs == null) return Enumerable.Empty<HiveTask>();
-
-      var jobs = new List<HiveTask>();
-      foreach (HiveTask job in HiveJobs) {
-        jobs.AddRange(job.GetAllHiveTasks());
-      }
-      return jobs;
+      return HiveTasks != null
+        && HiveTasks.All(x => x.Task.DateFinished.HasValue && x.Task.DateCreated.HasValue);
+    }
+
+    public IEnumerable<HiveTask> GetAllHiveTasks() {
+      if (hiveTasks == null) return Enumerable.Empty<HiveTask>();
+
+      var tasks = new List<HiveTask>();
+      foreach (HiveTask task in HiveTasks) {
+        tasks.AddRange(task.GetAllHiveTasks());
+      }
+      return tasks;
     }
 
