private void CalcGroups(List <WorkLogDataRow> fileData, ObservableCollection <TaskGroup> groups, TaskGroup summary, DateTime dateFrom, DateTime dateTo, ModelSettings settings) { foreach (WorkLogDataRow row in fileData) { if (row.Key == null) { continue; } DateTime bookDate = GetDate(row.WorkDateStr, settings.SourceFileSettings.DateField); if (bookDate >= dateFrom && bookDate <= dateTo) { TaskGroup group = groups.FirstOrDefault(x => x.Id == row.UserName); if (group == null) { group = new TaskGroup(); group.Id = row.UserName; group.Title = row.UserName; groups.Add(group); } Task task = CreateTask(row, settings); AddTaskToGroup(group, task); AddTaskToGroup(summary, task); } } }
public TaskGroupViewModel GetTaskGroup(string userId, int taskGroupId) { TaskGroup taskGroup = _context.TaskGroups .Include(tg => tg.Course) .Include(tg => tg.Variants) .FirstOrDefault(tg => tg.Id == taskGroupId); if (taskGroup == null) { throw new NotFoundException(); } return(new TaskGroupViewModel { Id = taskGroupId, CourseId = taskGroup.CourseId, CourseName = taskGroup.Course.Name, Name = taskGroup.Name, Description = taskGroup.Description, IsCourseTeacher = KaCakeUtils.IsCourseTeacher(_context, taskGroup.CourseId, userId), Variants = taskGroup.Variants.Select(variant => new TaskVariantViewModel() { Id = variant.Id, Name = variant.Name, Description = variant.Description }).ToList() }); }
public ObservableCollection <TaskGroup> LoadTimeSheetReport(string fileName, DateTime dateFrom, DateTime dateTo, ModelSettings settings) { if (!File.Exists(fileName)) { return(null); } List <WorkLogDataRow> fileData = ReadFile(fileName, settings); if (fileData == null) { return(null); } ObservableCollection <TaskGroup> groups = new ObservableCollection <TaskGroup>(); TaskGroup summary = new TaskGroup { IsSummary = true, Title = "All" }; groups.Add(summary); CalcGroups(fileData, groups, summary, dateFrom, dateTo, settings); CalcTotals(groups, settings); return(groups); }
public async Task <int> CreateAsync(string name) { var group = new TaskGroup(name); var id = await _taskGroupRepository.AddAsync(group); return(id); }
public TaskGroup UpdateTaskGroup(TaskGroup taskGroup) { TaskGroup tempTaskGroup; try { var x = DataContext.TaskGroups.Attach(taskGroup); var entry = DataContext.Entry(taskGroup); if (!String.IsNullOrEmpty(taskGroup.Name)) { entry.Property(e => e.Name).IsModified = true; } tempTaskGroup = x.Entity; base.DataContext.SaveChanges(); } catch (Exception ex) { throw ex; } return(tempTaskGroup); }
public Manager(AutomataConfiguration configuration) { Dictionary <Type, ILogSink> logSinks = new Dictionary <Type, ILogSink>(); this.configuration = configuration; if (this.configuration == null) { throw new ArgumentNullException("Configuration is null"); } if (!this.configuration.HasConfiguration) { throw new Exception("Automata configuration is incomplete."); } foreach (var group in this.configuration.TaskGroups) { var taskGroup = new TaskGroup(); taskGroup.Name = group.Name; var tasks = new List <ITask>(); if (!logSinks.ContainsKey(group.LogSink)) { var logSink = (ILogSink)Activator.CreateInstance(group.LogSink); Dictionary <string, string> logParameters = this.configuration.LogSinks.Where(s => s.LogSink == group.LogSink).FirstOrDefault()?.Parameters; if (logParameters != null) { logSink.Configure(logParameters); } logSinks.Add(group.LogSink, logSink); } taskGroup.LogSink = logSinks[group.LogSink]; // create task here, and assign it the logsink from the dictionary foreach (var task in group.Tasks) { var automationTask = (ITask)Activator.CreateInstance(task.Item2); automationTask.LogSink = taskGroup.LogSink; Dictionary <string, string> taskParameters = task.Item3; if (taskParameters != null) { automationTask.Configure(taskParameters); } automationTask.Name = task.Item1; automationTask.GroupName = taskGroup.Name; tasks.Add(automationTask); } taskGroup.AutomationTasks = tasks.ToArray(); taskGroups.Add(taskGroup); } }
/// <summary> /// Calculatee the gradients. /// </summary> public virtual void CalculateGradients() { if (this.workers == null) { Init(); } this.workers[0].Network.ClearContext(); this.totalError = 0; if (this.workers.Length > 1) { TaskGroup group = EngineConcurrency.Instance .CreateTaskGroup(); /* foreach */ foreach (IFlatGradientWorker worker in this.workers) { EngineConcurrency.Instance.ProcessTask(worker, group); } group.WaitForComplete(); } else { this.workers[0].Run(); } this.currentError = this.totalError / this.workers.Length; }
public async Task <int> AddAsync(TaskGroup group) { _context.TaskGroups.Add(group); await _context.SaveChangesAsync(); return(group.TaskGroupId); }
/// <summary> /// Perform one generation. /// </summary> public virtual void Iteration() { int countToMate = (int)(Population.Genomes.Count * PercentToMate); int offspringCount = countToMate * 2; int offspringIndex = Population.Genomes.Count - offspringCount; int matingPopulationSize = (int)(Population.Genomes.Count * MatingPopulation); TaskGroup group = EngineConcurrency.Instance .CreateTaskGroup(); // mate and form the next generation for (int i = 0; i < countToMate; i++) { IGenome mother = Population.Genomes[i]; int fatherInt = (int)(ThreadSafeRandom.NextDouble() * matingPopulationSize); IGenome father = Population.Genomes[fatherInt]; IGenome child1 = Population.Genomes[offspringIndex]; IGenome child2 = Population.Genomes[ offspringIndex + 1]; MateWorker worker = new MateWorker(mother, father, child1, child2); EngineConcurrency.Instance.ProcessTask(worker, group); offspringIndex += 2; } group.WaitForComplete(); // sort the next generation Population.Sort(); }
public async Task <ActionResult <TaskGroup> > PostProject(TaskGroup taskGroup) { this.context.TaskGroups.Add(taskGroup); await this.context.SaveChangesAsync(); return(this.CreatedAtAction(nameof(this.GetGroup), new { groupID = taskGroup.ID }, taskGroup)); }
/// <summary> /// Calculate the gradients. /// </summary> /// public virtual void CalculateGradients() { if (_workers == null) { Init(); } if (_flat.HasContext) { _workers[0].Network.ClearContext(); } _totalError = 0; if (_workers.Length > 1) { TaskGroup group = EngineConcurrency.Instance .CreateTaskGroup(); foreach (GradientWorker worker in _workers) { EngineConcurrency.Instance.ProcessTask(worker, group); } group.WaitForComplete(); } else { _workers[0].Run(); } CurrentError = _totalError / _workers.Length; }
/// <summary> /// 非同期タスクグループを作成する /// </summary> /// <param name="capacity">登録タスクキャパシティ</param> /// <returns>作成したタスクグループインターフェイス</returns> public ITaskGroup CreateAsyncTaskGroup(int capacity = 8, uint priority = DefaultPriority) { TaskGroup group = new TaskGroup(true, capacity, priority); AddGroup(group); return(group); }
private List <BuildDefinitionStep> AddTasks(TaskGroup tg) { var steps = new List <BuildDefinitionStep>(); foreach (var t in tg.Tasks) { var step = new BuildDefinitionStep { TimeoutInMinutes = t.TimeoutInMinutes, Condition = t.Condition, DisplayName = t.DisplayName, Environment = t.Environment, AlwaysRun = t.AlwaysRun, ContinueOnError = t.ContinueOnError, Enabled = t.Enabled, Inputs = t.Inputs, TaskDefinition = new Microsoft.TeamFoundation.Build.WebApi.TaskDefinitionReference { DefinitionType = t.Task.DefinitionType, Id = t.Task.Id, VersionSpec = t.Task.VersionSpec } }; steps.Add(step); } return(steps); }
public Context() { this.items = new List <ITask>(); this.groupAscending = true; this.taskGroup = TaskGroup.DueDate; }
public IActionResult TaskGroupCreate(AddTaskGroupViewModel addTaskGroup) { var check = _context.TaskGroups.Any(t => t.TaskGroupName == addTaskGroup.TaskGroupName); if (check) { ModelState.AddModelError(string.Empty, "Tokia užduočių grupė jau yra sukurta"); return(View()); } if (ModelState.IsValid) { //var newTaskGroup = new TaskGroup() { TaskGroupName = addTaskGroup.TaskGroupName, TaskGroupCount = addTaskGroup.TaskGroupCount }; var newTaskGroup = new TaskGroup() { TaskGroupName = addTaskGroup.TaskGroupName }; if (newTaskGroup != null) { _context.TaskGroups.Add(newTaskGroup); _context.SaveChanges(); } return(RedirectToAction("TaskGroup")); } return(View()); }
public TaskGroupChoose(TaskGroup[] TaskArr) { InitializeComponent(); TaskGroupPanelList.Dock = DockStyle.Fill; this.panel2.Controls.Add(TaskGroupPanelList); SetGroup(TaskArr); }
public async Task <ActionResult <TaskGroup> > PostTaskGroup(TaskGroup taskGroup) { _db.TaskGroups.Add(taskGroup); await _db.SaveChangesAsync(); return(CreatedAtAction("GetTaskGroup", new { id = taskGroup.ID }, taskGroup)); }
public Boolean Delete(TaskGroup taskGroup) { _context.TaskGroups.Remove(taskGroup); _context.SaveChanges(); _logger.LogInformation("Delete Task Group " + taskGroup.TaskGroupId + " " + taskGroup.Name); return(true); }
// TODO: Document public static void CreateGroup( string groupName, int totalThreads, bool @async, System.Action <Dictionary <string, object> > onComplete) { // TODO: May need to terminate old threads on the old group if this is squashing it var taskGroup = new TaskGroup { Name = groupName, Async = @async, TotalThreads = totalThreads, OnComplete = onComplete, TaskRunners = new List <TaskRunner>(), Results = new Dictionary <string, object>(), }; groupSpecificTaskLock.Add(taskGroup, new ReaderWriterLockSlim()); groupLock.EnterWriteLock(); try { groups.Add(groupName, taskGroup); } finally { groupLock.ExitWriteLock(); } }
public TaskGroup Save(TaskGroup taskGroup) { if (taskGroup.UserTasks != null) { try { taskGroup.UserTasks.ForEach(userTask => { _context.Entry(userTask).State = EntityState.Modified; //_context.Entry(userTask.User).State = EntityState.Detached; }); } catch (Exception ex) { _context.UserTasks.RemoveRange(taskGroup.UserTasks); throw; } } _context.TaskGroups.Add(taskGroup); if (taskGroup.TaskGroupId > 0) { _context.Entry(taskGroup).State = EntityState.Modified; } _context.SaveChanges(); return(taskGroup); }
public ActionResult PostEditTaskGroup(TaskGroup taskGroup) { db.Entry(taskGroup).State = EntityState.Modified; db.SaveChanges(); return(Redirect("/TaskGroup/Index")); }
public Environment(string luaToRun, ExtensionCollection extensionCollection) { var lua = new Lua(); var taskExtension = new TaskExtension(); taskExtension.LoadExtension(lua); extensionCollection.LoadExtensions(lua); lua.DoString(luaToRun); var tasks = lua["Pipeline"]; if (tasks is null) { throw new PipelineNotFoundException(); } if (tasks.GetType() != typeof(LuaTable)) { return; } _statusUpdater = new StatusUpdater(); _rootTaskGroup = new TaskGroup((LuaTable)tasks); _rootTaskGroup.Allow(_statusUpdater); _statusUpdater.StatusUpdate += update => Update?.Invoke(update); }
public async Task <IActionResult> PutTaskGroup(Guid id, TaskGroup taskGroup) { if (id != taskGroup.ID) { return(BadRequest()); } _db.Entry(taskGroup).State = EntityState.Modified; try { await _db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TaskGroupExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public ExceptionTest() { taskGroup = new TaskGroup { GroupName = "Academic Task", Active = "Yes", Color = "red" }; taskItem = new TaskItem { Name = "Training", Priority = TaskPriority.High, TaskStatus = TaskStatus.Yet_To_Start, TaskStartDate = DateTime.Now, TaskEndDate = DateTime.Now.AddDays(5), TaskGroup = "Academic Task", TaskColorCode = "purple" }; MongoDBUtility mongoDBUtility = new MongoDBUtility(); context = mongoDBUtility.MongoDBContext; _taskRepository = new TaskRepository(context); _taskService = new TaskService(_taskRepository); config = new ConfigurationBuilder().AddJsonFile("appsettings.test.json").Build(); }
private static TaskGroupUpdateParameter GetTaskGroupUpdateParameter(TaskGroup taskGroup) { var taskGroupUpdateParameter = new TaskGroupUpdateParameter { Id = taskGroup.Id, Name = taskGroup.Name, Description = taskGroup.Description, Comment = taskGroup.Comment, ParentDefinitionId = taskGroup.ParentDefinitionId }; if (taskGroup.Inputs.Any()) { foreach (var input in taskGroup.Inputs) { taskGroupUpdateParameter.Inputs.Add(input); } } if (taskGroup.Tasks.Any()) { foreach (var task in taskGroup.Tasks) { taskGroupUpdateParameter.Tasks.Add(task); } } return(taskGroupUpdateParameter); }
public FolderBaseEntry(IAbstractFolder folder, string parameter = null) { this.Name = folder.Name; this.GroupAscending = folder.GroupAscending; this.Group = folder.TaskGroup; this.Parameter = parameter; }
public ActionResult PostAddTaskGroup(TaskGroup taskGroup) { db.TaskGroups.Add(taskGroup); db.SaveChanges(); return(Redirect("/TaskGroup/Index")); }
private void schedulerControl1_EditAppointmentFormShowing(object sender, AppointmentFormEventArgs e) { Task singletask = this.session1.GetObjectByKey <Task>(e.Appointment.Id); if (singletask != null) { SetDefault(); using (RibbonFormNuovoTask form = new RibbonFormNuovoTask()) { TaskGroup taskgruppo = singletask.Gruppo; form.Init(taskgruppo); if (form.ShowDialog(this) == System.Windows.Forms.DialogResult.OK) { this.xpCollectionTask.Reload(); this.schedulerStorage1.RefreshData(); NewTask = taskgruppo; } } } e.DialogResult = System.Windows.Forms.DialogResult.OK; this.schedulerControl1.Refresh(); e.Handled = true; }
public IActionResult Create(int id, int?taskVariantId) { string userId = _userManager.GetUserId(User); TaskGroup taskGroup = _context.TaskGroups.Find(id); if (!KaCakeUtils.IsCourseTeacher(_context, taskGroup.CourseId, userId)) { return(Challenge()); } TaskVariant editingTaskVariant; if (taskVariantId.HasValue && (editingTaskVariant = _context.TaskVariants.Find(taskVariantId.Value)) != null) { return(View(new TaskVariantViewModel() { TaskGroupId = id, Id = taskVariantId.Value, Name = editingTaskVariant.Name, Description = editingTaskVariant.Description, IsUserTeacher = KaCakeUtils.IsCourseTeacher(_context, editingTaskVariant.TaskGroup.CourseId, userId) })); } return(View(new TaskVariantViewModel { TaskGroupId = id, IsUserTeacher = KaCakeUtils.IsCourseTeacher(_context, _context.TaskGroups.Find(id).CourseId, userId) })); }
public void Export(string fileName, DateTime dateFrom, DateTime dateTo, IEnumerable <TaskGroup> groups) { SpreadsheetInfo.SetLicense("E5M8-KYCM-HFC2-WRTR"); if (File.Exists(fileName)) { File.Delete(fileName); } if (groups == null) { throw new ApplicationException("no data"); } var workbook = new ExcelFile(); // Create new worksheet and set cell A1 value to 'Hello world!'. ExcelWorksheet ws = workbook.Worksheets.Add("TimeAnalytic"); int row = 0; //numeration starts from 0 WriteDate(ws, 1, "Date From", dateFrom); WriteDate(ws, 2, "Date To", dateTo); row = 4; WriteGroupHeader(ws, row); row++; TaskGroup summary = groups.FirstOrDefault(x => x.IsSummary); WriteGroupHeader(ws, row); row = WriteGroups(ws, groups, summary, ref row); row++; row++; WriteTasksHeader(ws, row); WriteTasksForGroups(ws, groups, summary, ref row); workbook.Save(fileName); }
private void WriteGroupData(ExcelWorksheet ws, TaskGroup group, int row) { ws.Cells[row, (int)TaskGroupDataPosition.Title].Value = group.Title; ws.Cells[row, (int)TaskGroupDataPosition.TotalEstimationDevelopment].Value = PrepareDouble(group.TotalEstimationDevelopment); ws.Cells[row, (int)TaskGroupDataPosition.TotalEstimationDevelopment].Style.NumberFormat = DOUBLE_FORMAT; ws.Cells[row, (int)TaskGroupDataPosition.TotalDoneEstimationDevelopment].Value = PrepareDouble(group.TotalDoneEstimationDevelopment); ws.Cells[row, (int)TaskGroupDataPosition.TotalDoneEstimationDevelopment].Style.NumberFormat = DOUBLE_FORMAT; ws.Cells[row, (int)TaskGroupDataPosition.TotalDoneBookedDevelopment].Value = PrepareDouble(group.TotalDoneBookedDevelopment); ws.Cells[row, (int)TaskGroupDataPosition.TotalDoneBookedDevelopment].Style.NumberFormat = DOUBLE_FORMAT; ws.Cells[row, (int)TaskGroupDataPosition.TotalTimeBooked].Value = PrepareDouble(group.TotalTimeBooked); ws.Cells[row, (int)TaskGroupDataPosition.TotalTimeBooked].Style.NumberFormat = DOUBLE_FORMAT; ws.Cells[row, (int)TaskGroupDataPosition.TotalBookedDevelopment].Value = PrepareDouble(group.TotalBookedDevelopment); ws.Cells[row, (int)TaskGroupDataPosition.TotalBookedDevelopment].Style.NumberFormat = DOUBLE_FORMAT; ws.Cells[row, (int)TaskGroupDataPosition.TotalBookedMeetings].Value = PrepareDouble(group.TotalBookedMeetings); ws.Cells[row, (int)TaskGroupDataPosition.TotalBookedMeetings].Style.NumberFormat = DOUBLE_FORMAT; ws.Cells[row, (int)TaskGroupDataPosition.TotalUnderEstimate].Value = PrepareDouble(group.TotalUnderEstimate); ws.Cells[row, (int)TaskGroupDataPosition.TotalUnderEstimate].Style.NumberFormat = DOUBLE_FORMAT; ws.Cells[row, (int)TaskGroupDataPosition.RateDoneBookedToBookedDevelopment].Value = PrepareDouble(group.RateDoneBookedToBookedDevelopment); ws.Cells[row, (int)TaskGroupDataPosition.RateDoneBookedToBookedDevelopment].Style.NumberFormat = DOUBLE_FORMAT; }
public FeedManager() { update_feed_map = new Dictionary<Feed, FeedUpdateTask> (); update_task_list = new TaskList<FeedUpdateTask> (); // Limit to 4 feeds downloading at a time update_task_group = new TaskGroup<FeedUpdateTask> (2, update_task_list); update_task_group.TaskStopped += OnUpdateTaskStopped; update_task_group.TaskAssociated += OnUpdateTaskAdded; // TODO // Start timeout to refresh feeds every so often }
public void TaskGroupFinishedSignal() { TaskGroup group = new TaskGroup(); group = group.Add(new Task(() => Debug.WriteLine(nameof(TaskGroupFinishedSignal)))); group = group.Add(new Task(() => Debug.WriteLine(nameof(TaskGroupFinishedSignal)))); ManualResetEvent resetEvent = new ManualResetEvent(false); group.Finished += (sender, e) => resetEvent.Set(); group.Start(); if (!resetEvent.WaitOne(1000)) { Assert.Fail(); } }
public void ConcurrentTaskGroupStart() { TaskGroup group = new TaskGroup(); group = group.Add(new Task(() => Debug.WriteLine(nameof(ConcurrentTaskGroupStart)))); group = group.Add(new Task(() => Debug.WriteLine(nameof(ConcurrentTaskGroupStart)))); var t1 = new Task(() => group.Start()); var t2 = new Task(() => group.Start()); t1.Start(); t2.Start(); Task.WaitAll(t1, t2); Assert.AreEqual(TaskStatus.RanToCompletion, t1.Status); Assert.AreEqual(TaskStatus.RanToCompletion, t2.Status); }
public void TaskCompletedSignal() { TaskGroup group = new TaskGroup(); int i = 0; group = group.Add(new Task(() => Debug.WriteLine(nameof(TaskCompletedSignal)))); group = group.Add(new Task(() => Debug.WriteLine(nameof(TaskCompletedSignal)))); group.TaskCompleted += (sender, e) => Interlocked.Increment(ref i); group.Start(); Thread.Sleep(1000); if (i != 2) { Assert.Fail(); } }
public void SetGroup(TaskGroup[] TaskArr) { List<FolderTrack.Types.TaskGroup> taskList = new List<FolderTrack.Types.TaskGroup>(); Dictionary<FolderTrack.Types.TaskGroup, object> TaskGroupTas; TaskGroupTas = new Dictionary<TaskGroup, object>(); foreach (FolderTrack.Types.TaskGroup tas in TaskArr) { Util.DBug2("TaskGroupChoose", tas.TaskName); taskList.Add(tas); TaskGroupTas[tas] = tas; } foreach (FolderTrack.Types.TaskGroup gr in taskList) { foreach (FolderTrack.Types.Task t in gr.TaskList.Values) { Util.DBug2("TaskGroupChoose", t.Action + " " + t.Detail + " " + t.percent); } } TaskGroupPanelList.SynchData(taskList); TaskGroupPanelList.AddFunctionCallToData(TaskGroupTas); }
public void ShowAllTask(TaskGroup[] task) { if (this.InvokeRequired) { this.Invoke(new VoidTaskGroupArrDelegate(ShowAllTask), new object[] { task }); return; } this.NoMonitorGroupPanel.Visible = false; this.MonitorGrouPanLis.Visible = false; this.EMonitorGrouPanLis.Visible = false; this.taskChoose.Visible = true; this.Monitpanel.Visible = true; this.taskChoose.SetGroup(task); }
public void Dispose(System.Threading.AutoResetEvent disposeHandle) { lock (update_task_group.SyncRoot) { if (update_task_group != null) { //update_task_group.CancelAsync (); //update_task_group.Handle.WaitOne (); update_task_group.Dispose (); //disposeHandle.WaitOne (); update_task_group.TaskStopped -= OnUpdateTaskStopped; update_task_group.TaskAssociated -= OnUpdateTaskAdded; update_task_group = null; } update_task_list = null; disposed = true; } }
public void TaskUpdate(TaskGroup[] task) { bool allowHide = true; if (CurrentTaskArr != null) { foreach (TaskGroup tas in CurrentTaskArr) { if (tas.Status == TaskGroup.FAILED) { allowHide = false; break; } } } if (task == null && allowHide) { new Thread(HideTask).Start(); return; } if (task != null) { CurrentTaskArr = task; } foreach (TaskGroup tas in task) { Util.DBug2("TaskManager", tas.TaskName); foreach (FolderTrack.Types.Task t in tas.TaskList.Values) { Util.DBug2("MainForm", t.Action + " " + t.Detail + " " + t.percent); } } bool showAllTask = false; if (this.taskChoose.Visible == false) { foreach (TaskGroup t in task) { if (t.Status == TaskGroup.PERSISTANT_FAIL) { showAllTask = true; break; } foreach (FolderTrack.Types.Task ta in t.TaskList.Values) { if (ta.ErrorDiscrip != null) { showAllTask = true; break; } } if (showAllTask == true) { break; } } } else { showAllTask = true; } if (showAllTask) { ShowAllTask(task); } else { hideTaskButton = false; new Thread(BlinkButton).Start(); } }
public void TaskUpdate(TaskGroup[] task) { }
public DashboardTaskGroupProperty(TaskGroup taskGroup) { TaskGroup = taskGroup; WorkingNode = TaskGroup.Owner; }
public void TaskUpdate(TaskGroup[] task) { if(CallList == null) { return; } foreach (FolderTrackCallBack flCall in CallList) { try { flCall.TaskUpdate(task); } catch (Exception) { //Dont care } } }
public void TaskUpdate(TaskGroup[] task) { foreach (FolderTrackCallBack flCall in CallList) { try { flCall.TaskUpdate(task); } catch (Exception) { //Don't care } } }
public static DashboardTaskGroupProperty CreateTaskGroupProperty(TaskGroup taskGroup) { return new DashboardTaskGroupProperty(taskGroup); }
/////////////////////////////// public void AddTaskGroup (TaskGroup group) { if (task_groups == null) task_groups = new ArrayList (); task_groups.Add (group); }