/// <summary>
/// Функция считывает ресурсы из объекта ДГ и добавляет их в справочники
/// </summary>
/// <param name="obj">Объект PLM, из которого происходит чтение</param>
/// <param name="strTask">Объект - структура задачи, в которую будут записаны ресурсы</param>
public void TransferResources(GanttItem gt, ref clTask strTask)
{
if (gt.ItemType != GanttItemType.TaskItem) return;
strTask.lResourceTask.Clear();
var task = (TaskItem)gt;
foreach (var resrel in task.Resources)
{
var resitem = resrel.Resource;
// Создание структуры трудовых ресурсов (для задачи)
stResource strResource = new stResource();
strResource.Res = resitem;
strResource.unit = 1;
var ioRes = GetIObyGT(resitem);
if (ioRes == null)
{
// Создание структуры трудовых ресурсов (для справочника)
stResource elemResource = new stResource();
elemResource.Res = resitem;
elemResource.objResurce = null;
// Запись нового ресурса в словарь ресурсов
dictResource.Add(elemResource);
}
else
{
strResource.responsible = IsRespUser(strTask, ioRes);
}
strResource.objResurce = ioRes;
// Запись в список трудовых ресурсов в структуре strTask
strTask.lResourceTask.Add(strResource);
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
List <GanttGroup> list = new List <GanttGroup>();
for (int i = 0; i < 10; ++i)
{
GanttGroup ganttGroup = new GanttGroup();
ganttGroup.Caption = "Group " + i;
GanttRow ganttRow = new GanttRow();
ganttRow.Caption = "test_" + i;
GanttItem ganttItem = new GanttItem();
ganttItem.Caption = "testItem_" + i;
ganttItem.Start = DateTime.Now;
ganttItem.End = ganttItem.Start.AddDays(7);
ganttRow.Items.Add(ganttItem);
ganttGroup.Rows.Add(ganttRow);
list.Add(ganttGroup);
}
ganttChart.Groups = list;
ganttChart.Start = DateTime.Now;
ganttChart.End = ganttChart.Start.AddDays(14);
ganttChart.Refresh();
}
void _ReloadSchedule()
{
var hourDay = GetRange("F3").ToFloat();
var sumHour = 0f;
var now = DateTime.Now;
var startDate = DateTime.Now.AddHours(-now.Hour).AddMinutes(-now.Minute).AddSeconds(-now.Second);
DateTime planStartDate = default;
foreach (var item in _items)
{
if (item.actStart == default)
{
if (planStartDate == default || item.planStart < planStartDate)
{
planStartDate = item.planStart;
}
}
}
if (planStartDate != default)
{
startDate = planStartDate;
}
int prevI = -1;
for (int i = 0, iLen = _items.Count; i < iLen; i++)
{
GanttItem item = _items[i];
if (item.actEnd == default)
{
if (prevI == -1)
{
item.planStart = startDate;
}
else
{
item.planStart = _items[prevI].planEnd;
}
prevI = i;
sumHour += item.planTime;
item.planEnd = startDate.AddDays(sumHour);
var shiftDays = item.ShiftEndByWeekend(_holidays);
sumHour += shiftDays;
SetRange($"F{i + 8}", item.planStart.ToString("MM/dd"));
SetRange($"G{i + 8}", item.planEnd.ToString("MM/dd"));
}
}
}
/// <summary>
/// Поиск задачи с максимальной датой окончания
/// </summary>
/// <param name="objGantt"></param> Исходная группа или задача Gantt
/// <param name="curDate"></param> Текущая максимальная дата окончания текущей задачи
/// <returns></returns>
private TaskItem SearchTaskEndDate(GanttItem objGantt, ref DateTime curDate)
{
if (objGantt.ItemType == GanttItemType.GroupItem)
{
// Группа задач
GroupItem gr = (GroupItem)objGantt;
for (int i = 0; i < gr.ChildItems.Count(); i++)
{
if (gr.ChildItems[i].ItemType == GanttItemType.GroupItem)
selDepInDepTask = SearchTaskEndDate(gr.ChildItems[i], ref curDate);
else
{
objGantt = (TaskItem)gr.ChildItems[i];
objGantt = SearchTaskEndDate(objGantt, ref curDate);
}
}
return selDepInDepTask;
}
else if (objGantt.ItemType == GanttItemType.TaskItem)
{
// Задача
if (((TaskItem)objGantt).EndDate > curDate)
{
selDepInDepTask = (TaskItem)objGantt;
curDate = selDepInDepTask.EndDate;
}
return selDepInDepTask;
}
else
return null;
}
private void ShowItemStatus(GanttItem item)
{
if (!(ucGantt1.gantt1.IsBarMoving || ucGantt1.gantt1.IsBarSizing))
{
if ((LastItemStatusKey == null && item == null) || (LastItemStatusKey != null && item != null && item.Key == LastItemStatusKey))
return;
}
MethodInvoker ShowItemStatusInvoker = delegate
{
if (item == null)
{
toolStripStatusLabelTaskName.Text = "";
toolStripStatusLabelStartDate.Text = "";
toolStripStatusLabelEndDate.Text = "";
toolStripStatusLabelDuration.Text = "";
LastItemStatusKey = null;
}
else
{
toolStripStatusLabelTaskName.Text = item.Text;
toolStripStatusLabelStartDate.Text = item.StartDateForDisplay;
toolStripStatusLabelEndDate.Text = item.EndDateForDisplay;
toolStripStatusLabelDuration.Text = item.DurationForDisplay;
LastItemStatusKey = item.Key;
}
};
Invoke(ShowItemStatusInvoker);
}
private void RegisterGanttRowItemEvents(GanttItem item)
{
item.PropertyChanged += GanttRowItemsItemOnChanged;
}
protected virtual void SelectGanttItem(GanttItem item)
{
if (m_GanttControl == null || GRD.CurrentRow == null)
return;
GanttItem t = (GanttItem)GRD.CurrentRow.DataBoundItem;
if (t != null && t.Key == item.Key)
return;
int i = bindingSource1.Find("Key", item.Key);
if (i >= 0)
bindingSource1.Position = i;
}
/// <summary>
/// Функция обновляет данные задачи в хранилище mainList
/// </summary>
/// <param name="task">объект диаграммы</param>
public void NewTask(GanttItem task)
{
clTask newStTask;
dictTasks.TryGetValue(task.Key, out newStTask);
if (newStTask == null)
newStTask = new clTask();
int index = mainList.IndexOf(newStTask);
newStTask.bGroup = false;
newStTask.TaskName = task.Text;
newStTask.keyGantt = task.Key;
newStTask.externalTask = false;
newStTask.Dates.RuleForStartDate = Service.GetNamedValue(@"WORKORG\WayToCalculateDates\ManualWayToCalculateDates");
// InternalCalculation1 - Вычислять начало
newStTask.Dates.DataBegTask = DateTime.MinValue;
newStTask.Dates.RuleForFinishDate = Service.GetNamedValue(@"WORKORG\WayToCalculateDates\ManualWayToCalculateDates");
newStTask.Dates.DataEndTask = DateTime.MinValue;
newStTask.nOrder = GetNextOrder();
// Календарь
if ((task as TaskItem).Calendar == null) newStTask.Dates.calendar = null;
else newStTask.Dates.calendar = this.CalendarsWorker.GetPLMCalendarByCalendarKey((task as TaskItem).Calendar.Key);
newStTask.SetMilestone((task as TaskItem).IsMilestone); // Признак Вехи
// Ограничения
newStTask.Constraints.StartDateNoEarlierThan = CheckDate((task as TaskItem).EarliestStartDate);
newStTask.Constraints.StartDateNoLaterThan = CheckDate((task as TaskItem).LatestStartDate);
newStTask.Constraints.FinishDateNotEarlierThan = CheckDate((task as TaskItem).EarliestEndDate);
newStTask.Constraints.FinishDateNoLaterThan = CheckDate((task as TaskItem).LatestEndDate);
// Процент завершения
newStTask.Dates.Percentage = (int)((KS.Gantt.TaskItem)task).PercentDonePercent;
if (task.ParentItem == null)
{
// Назначение основной группы - родительской для newStTask
if (this.GanttDiag.Groups.Count > 0)
this.GanttDiag.Groups[0].AddChild(task);
}
else
{
// Запись в список родительских задач в структуре newStTask
HelperClasses.stParentTask stPT = new HelperClasses.stParentTask(); // Структура родительской группы
clTask parentStTask = new clTask(); // Данные родительской задачи
if (dictTasks.TryGetValue(task.ParentItem.Key, out parentStTask) == true)
// Родительская задача существует
{
HelperClasses.stParentTask stParent = newStTask.lParentTask.Find(
delegate(HelperClasses.stParentTask bk)
{
return bk.keyGantt == parentStTask.keyGantt;
}
);
if (stParent.TaskName == null)
{
// Индекс записи данных родительской задачи в списке mainList
var ind = mainList.IndexOf(parentStTask);
stPT.IsPrimary = true; // Признак основной родительской задачи
stPT.Obj = parentStTask.Obj; // ИО родителской группы
stPT.keyGantt = parentStTask.keyGantt;
stPT.TaskName = parentStTask.TaskName;
stPT.idPlm = parentStTask.idPlm;
newStTask.lParentTask.Add(stPT);
// Поиск и удаление данных во всех дочерних задачах задачи newStTask
FindDelChlidSt(newStTask.keyGantt);
// Дополнение новой задачи в список дочерних для родительской
parentStTask.lChildrTask.Add(newStTask);
// Замена в словаре
dictTasks[task.ParentItem.Key] = parentStTask;
// Замена в списке (обновление данных родительской задачи)
mainList[ind] = parentStTask;
}
}
}
// Ресурсы
ResourceWorker.TransferResources(task, ref newStTask);
// Временные зависимости
clTask depStTask;
newStTask.Dates.lDependentTask.Clear();
foreach (var dp in ((TaskItem)task).Dependencies)
{
// Переносим только жёсткие зависимости
if (dp.TaskRelationMode == TaskRelationModes.Soft) continue;
stDependents stDep = new stDependents();
if (dictTasks.TryGetValue(dp.TaskKey, out depStTask))
{
stDep.Obj = depStTask.Obj;
stDep.idPlm = depStTask.Obj.Id;
stDep.TaskName = dp.Task.Text;
stDep.typeGantt = dp.TaskRelationType;
// Задание значения Тип временной зависимости для PLM
if (stDep.typeGantt == TaskRelationTypes.EndStart)
// Следует после (Окончание-начало)
stDep.ProjectTaskLinkType =
Service.GetNamedValue(@"WORKORG\ProjectTaskLinkType\l1");
else if (stDep.typeGantt == TaskRelationTypes.StartStart)
// Начать вместе с (Начало-начало)
stDep.ProjectTaskLinkType =
Service.GetNamedValue(@"WORKORG\ProjectTaskLinkType\l2");
else if (stDep.typeGantt == TaskRelationTypes.EndEnd)
// Завершить вместе с (Окончание-окончание)
stDep.ProjectTaskLinkType =
Service.GetNamedValue(@"WORKORG\ProjectTaskLinkType\l3");
else
// Завершить до (Начало-окончание)
stDep.ProjectTaskLinkType = Service.GetNamedValue(@"WORKORG\ProjectTaskLinkType\l4");
// Запаздывание (календарное)
stDep.Delay = dp.DelayDays;
// Ед.изм (дни/часы) - было depStTask.Dates.TypeOfDuration
stDep.DelayType = (dp.DelayDurationType == TaskItem.DurationTypes.FullWorkingDays ?
Service.GetNamedValue(@"WORKORG\TypeOfDuration\Days") : Service.GetNamedValue(@"WORKORG\TypeOfDuration\Hours"));
stDep.IsStrict = (task as TaskItem).ASAP ? 1 : 0;
// Использовать календарь от
stDep.UseTaskCalendar = true;
newStTask.Dates.lDependentTask.Add(stDep);
}
}
if (newStTask.Obj == null)
{
// Новая задача
if (dictTasks.ContainsKey(newStTask.keyGantt) == false)
{
dictTasks.Add(newStTask.keyGantt, newStTask);
mainList.Add(newStTask);
}
}
else
{
// Старая задача
mainList[index] = newStTask;
dictTasks[newStTask.keyGantt] = newStTask;
}
}
private void DrawBaseLine(GanttItem item, BasePlans.BasePlan baseplan, KS.Gantt.BoxFormatStyle bfstyle, Graphics Gfx)
{
// Поиск соответствующего задаче базового плана.
var plmobj = this.parent.InstHelperPLM.DictTasksGetInfoObj(item.Key);
var baseline2draw = baseplan.GetBaseLine4Task(plmobj);
if (baseline2draw == null) return;
Rectangle r = gantt1.RowBounds(item.RowIndex);
int barbott = r.Top + gantt1.BarHeight + (r.Height - gantt1.BarHeight) / 2;
int x1 = gantt1.Date2x(baseline2draw.Dates.DataBegTask);
int x2 = gantt1.Date2x(baseline2draw.Dates.DataEndTask);
Rectangle r2 = new Rectangle(x1, barbott, x2 - x1, gantt1.BarHeight / 4);
// only paint if on screen
if (r2.IntersectsWith(gantt1.ClientRectangle))
{
bfstyle.DrawBox(Gfx, r2, Gantt.BarStyles.Rounded);
}
}
/// <summary>
/// Чтение данных объекта диаграммы для закладки "Состав задачи" задачи
/// </summary>
/// <param name="gtTask"></param>группа или задача Gantt
/// <returns></returns>
private void FillTabComposition(GanttItem gtTask)
{
InfoObject Obj;
clTask curSt = new clTask();
// Поиск структуры stTask для текущей задачи
dictTasks.TryGetValue(gtTask.Key, out curSt);
Obj = curSt.Obj;
ICollection<CollectionElement> listTabSb;
EntityAttribute attr;
CollectionElement item;
if (gtTask.ItemType == GanttItemType.GroupItem)
{
// SubTaskList - Состоит из
listTabSb = Obj.GetAttribute("SubTaskList").CollectionElements;
listTabSb.Clear();
// Атрибут таблицы "Состоит из:"
attr = Obj.GetAttribute("SubTaskList");
int i = 0;
clTask childSt;
foreach (var chlid in ((GroupItem)gtTask).ChildItems)
{
// Поиск структуры chlidSt для текущей дочерней задачи из группы
dictTasks.TryGetValue(chlid.Key, out childSt);
FindChild(Obj, childSt);
// Строка таблицы
item = attr.CreateCollectionElement();
// Запись номера задачи "По порядку"
i++;
item["Order"] = i;
// Запись ссылки на объект PLM
item["ProjectTask"] = childSt.Obj;
attr.CollectionElements.Add(item);
}
listTabSb = Obj.GetAttribute("SubTaskList").CollectionElements;
}
}
/// <summary>
/// Заполнение данных объекта PLM в таблице Ресурсы закладки "Расчёт"
/// </summary>
/// <param name="gtTask"></param>группа или задача Gantt
/// <returns></returns>
private void FillTabResources(GanttItem gtTask)
{
// Обновляем ресурсы только у задач (не у групп)
if (gtTask.ItemType != GanttItemType.TaskItem) return;
InfoObject Obj;
clTask curSt = new clTask();
// Поиск структуры stTask для текущей задачи
dictTasks.TryGetValue(gtTask.Key, out curSt);
Obj = curSt.Obj;
var attr = Obj.GetAttribute("Resources");
attr.CollectionElements.Clear();
// Поиск контейнера, содержащего ресурсы
DataContainer ResourceCont = null;
foreach (var resource in curSt.lResourceTask)
if (resource.objResurce != null)
{
ResourceCont = resource.objResurce.Container;
break;
}
foreach (var resource in curSt.lResourceTask)
{
var objResurce = resource.objResurce;
if (objResurce == null && ResourceCont != null)
{
objResurce = new InfoObject(ResourceCont, @"InfoObjects\WORKORG\Resources\Resource\WorkingResource");
objResurce["ResourceName"] = resource.GetResourceNameGantt();
objResurce["ShortResourceName"] = resource.GetResourceNameGantt();
objResurce["BasicCalendar"] = Obj.GetValue<InfoObject>("Calendar");
objResurce.Save();
}
if (objResurce != null)
{
var item = attr.CreateCollectionElement();
item["ResourceLink"] = objResurce;
attr.CollectionElements.Add(item);
}
}
}
/// <summary>
/// Чтение данных объекта диаграммы для закладки "Даты" задачи
/// </summary>
/// <param name="gtItem"></param>группа или задача Gantt
/// <returns></returns>
private void FillTabDates(GanttItem gtItem)
{
InfoObject Obj;
clTask curSt = new clTask();
// Поиск структуры stTask для текущей задачи
dictTasks.TryGetValue(gtItem.Key, out curSt);
Obj = curSt.Obj;
// RuleForStartDate - Правило для Даты начала
Obj["RuleForStartDate"] = curSt.Dates.RuleForStartDate;
// InternalCalculation1 - Вычислять начало
// StartDate - Дата начала
var nDate = gtItem.StartDate;
if (gtItem.ItemType == GanttItemType.GroupItem)
nDate = (gtItem as GroupItem).StartDatePlan;
if (curSt.Dates.DataBegTask != nDate)
Obj["StartDate"] = nDate;
// RuleForDurationDate - Правило для Длительности
// InternalCalculation2 - Вычислять длительность
// TypeOfDuration - Ед.изм (дни/часы)
if (gtItem.ItemType == GanttItemType.TaskItem)
{
if (((TaskItem)gtItem).DurationType == TaskItem.DurationTypes.FullWorkingDays)
{
// Ед.изм - дни
Obj["Duration"] = gtItem.Duration.TotalDays;
Obj["TypeOfDuration"] = Service.GetNamedValue(@"WORKORG\TypeOfDuration\Days");
}
else
{
// Ед.изм - часы
Obj["Duration"] = gtItem.Duration.TotalHours;
Obj["TypeOfDuration"] = Service.GetNamedValue(@"WORKORG\TypeOfDuration\Hours");
}
}
// RuleForFinishDate - Правило для Даты окончания
Obj["RuleForFinishDate"] = curSt.Dates.RuleForFinishDate;
// InternalCalculation3 - Вычислять окончание
// FinishDate - Дата окончания
nDate = gtItem.EndDate;
if (gtItem.ItemType == GanttItemType.GroupItem)
nDate = (gtItem as GroupItem).EndDatePlan;
if (curSt.Dates.DataEndTask != nDate)
Obj["FinishDate"] = nDate;
// Calendar - Календарь
Obj["Calendar"] = curSt.Dates.calendar;
// Percentage - Процент завершения
Obj["Percentage"] = curSt.Dates.Percentage;
// IsApprox - Приблизительная оценка
// ProjectTaskLinks - Временны́е зависимости
ICollection<CollectionElement> timeDependencies = Obj.GetAttribute("ProjectTaskLinks").CollectionElements;
timeDependencies.Clear();
// Атрибут таблицы "Временны́е зависимости"
var attr = Obj.GetAttribute("ProjectTaskLinks");
foreach (var dep in curSt.Dates.lDependentTask)
{
// Строка таблицы
var item = attr.CreateCollectionElement();
item["ProjectTask"] = dep.Obj;
item["ProjectTaskLinkType"] = dep.ProjectTaskLinkType;
item["Delay"] = dep.Delay;
item["IsStrict"] = (dep.IsStrict == 1);
attr.CollectionElements.Add(item);
}
}
/// <summary>
/// Чтение данных объекта диаграммы для закладки "Свойства" задачи
/// </summary>
/// <param name="gtTask"></param>группа или задача Gantt
/// <returns></returns>
private void FillTabProperty(GanttItem gtTask)
{
clTask curSt = new clTask();
// Поиск структуры stTask для текущей задачи
dictTasks.TryGetValue(gtTask.Key, out curSt);
// KindOfTask - вид
// TaskName - наименование
curSt.TaskName = gtTask.Text;
// ResponsibleExecutive - ответственный исполнитель
// Urgency - срочность
// Priority - приоритет
// Status - статус
// PrognosedResourceExpenses - затраты по плану
// Id - идентификатор
}
private void SaveGroupPlm(clTask st, GanttItem gr)
{
st.Obj["TaskName"] = gr.Text;
st.Obj["Content"] = gr.Description;
// Заполнение закладки "Ограничения" для задачи
st.Obj["StartDateNoEarlierThan"] = st.Constraints.StartDateNoEarlierThan;
st.Obj["StartDateNoLaterThan"] = st.Constraints.StartDateNoLaterThan;
st.Obj["FinishDateNotEarlierThan"] = st.Constraints.FinishDateNotEarlierThan;
st.Obj["FinishDateNoLaterThan"] = st.Constraints.FinishDateNoLaterThan;
// Замена ответственного
var userRes = (User)gr.GetProperty("Responsible");
var ResponsibleExecutive = st.Obj.GetValue<User>("ResponsibleExecutive");
if (userRes != null && userRes != ResponsibleExecutive)
st.Obj["ResponsibleExecutive"] = userRes;
// Замена Идентификатора
var Identity = (string)gr.GetProperty("Identity");
if (Identity != null)
st.Obj["Id"] = Identity;
TaskItem.TaskPriorities Priority;
TaskItem.TaskStates status;
if (gr is TaskItem)
{
Priority = (gr as TaskItem).Priority;
status = (gr as TaskItem).Status;
}
else
{
Priority = (gr as GroupItem).Priority;
status = (gr as GroupItem).Status;
}
var oldDGpriority = st.GetDGPriority();
if (oldDGpriority != Priority)
st.Obj["Priority"] = st.GetPLMPriority(Priority);
if (status != TaskItem.TaskStates.Undefined)
st.Obj["State"] = this.GetStatusPLM(status);
FillTabProperty(gr);
FillTabDates(gr);
FillTabResources(gr);
FillTabComposition(gr);
st.Obj.Save();
Service.UI.RefreshObject(st.Obj);
}
public static byte[] RenderLegendItem(string styleFilePath, GanttItem item, bool completed)
{
byte[] ret = null;
DateTime startDate = DateTime.Now.Date;
GanttView gantt = CreateGanttView(startDate, DayOfWeek.Monday, 0, ItemHeight);
Element spanElement = gantt.CreateSpanElement(null, null, null);
DateTime pointDate = startDate.AddHours(36);
DateTime intervalStart = startDate.AddHours(12);
DateTime intervalFinish = intervalStart.AddDays(2);
string tag = completed ? "Completed" : "";
switch (item)
{
case GanttItem.PointStart:
gantt.CreatePointElement(spanElement, pointDate, null, "Start", tag);
break;
case GanttItem.PointFinish:
gantt.CreatePointElement(spanElement, pointDate, null, "Finish", tag);
break;
case GanttItem.PointActualStart:
gantt.CreatePointElement(spanElement, pointDate, null, "ActualStart", tag);
break;
case GanttItem.PointActualFinish:
gantt.CreatePointElement(spanElement, pointDate, null, "ActualFinish", tag);
break;
case GanttItem.Interval:
gantt.CreateIntervalElement(spanElement, intervalStart, intervalFinish, null, null, tag);
break;
case GanttItem.IntervalActual:
gantt.CreateIntervalElement(spanElement, intervalStart, intervalFinish, null, "Actual", tag);
break;
case GanttItem.IntervalProgress:
gantt.CreateIntervalElement(spanElement, intervalStart, intervalFinish, null, "Progress", tag);
break;
case GanttItem.IntervalSummary:
case GanttItem.IntervalProject:
Element interval = gantt.CreateIntervalElement(spanElement, intervalStart, intervalFinish, null, "Summary", tag);
gantt.CreatePointElement(interval, intervalStart, null, "SummaryStart", tag);
gantt.CreatePointElement(interval, intervalFinish, null, "SummaryFinish", tag);
break;
case GanttItem.PointMilestone:
AddMilestone(gantt, spanElement, pointDate, null, null, tag);
break;
case GanttItem.PointMilestoneBasePlanRight:
AddMilestone(gantt, spanElement, intervalStart, intervalFinish, null, tag);
break;
case GanttItem.PointMilestoneBasePlanLeft:
AddMilestone(gantt, spanElement, intervalFinish, intervalStart, null, tag);
break;
}
#region Render
using (MemoryStream stream = new MemoryStream())
{
gantt.LoadStyleSheetFromFile(styleFilePath);
gantt.ApplyStyleSheet();
gantt.RenderPortion(new Point(0, 0), new Size(24 * 3, Convert.ToInt32(ItemHeight)), 0, 0, ImageFormat.Png, stream);
ret = stream.ToArray();
}
#endregion
return(ret);
}
public static byte[] RenderLegendItem(string styleFilePath, GanttItem item, bool completed)
{
byte[] ret = null;
DateTime startDate = DateTime.Now.Date;
GanttView gantt = CreateGanttView(startDate, DayOfWeek.Monday, 0, ItemHeight);
Element spanElement = gantt.CreateSpanElement(null, null, null);
DateTime pointDate = startDate.AddHours(36);
DateTime intervalStart = startDate.AddHours(12);
DateTime intervalFinish = intervalStart.AddDays(2);
string tag = completed ? "Completed" : "";
switch (item)
{
case GanttItem.PointStart:
gantt.CreatePointElement(spanElement, pointDate, null, "Start", tag);
break;
case GanttItem.PointFinish:
gantt.CreatePointElement(spanElement, pointDate, null, "Finish", tag);
break;
case GanttItem.PointActualStart:
gantt.CreatePointElement(spanElement, pointDate, null, "ActualStart", tag);
break;
case GanttItem.PointActualFinish:
gantt.CreatePointElement(spanElement, pointDate, null, "ActualFinish", tag);
break;
case GanttItem.Interval:
gantt.CreateIntervalElement(spanElement, intervalStart, intervalFinish, null, null, tag);
break;
case GanttItem.IntervalActual:
gantt.CreateIntervalElement(spanElement, intervalStart, intervalFinish, null, "Actual", tag);
break;
case GanttItem.IntervalProgress:
gantt.CreateIntervalElement(spanElement, intervalStart, intervalFinish, null, "Progress", tag);
break;
case GanttItem.IntervalSummary:
case GanttItem.IntervalProject:
Element interval = gantt.CreateIntervalElement(spanElement, intervalStart, intervalFinish, null, "Summary", tag);
gantt.CreatePointElement(interval, intervalStart, null, "SummaryStart", tag);
gantt.CreatePointElement(interval, intervalFinish, null, "SummaryFinish", tag);
break;
case GanttItem.PointMilestone:
AddMilestone(gantt, spanElement, pointDate, null, null, tag);
break;
case GanttItem.PointMilestoneBasePlanRight:
AddMilestone(gantt, spanElement, intervalStart, intervalFinish, null, tag);
break;
case GanttItem.PointMilestoneBasePlanLeft:
AddMilestone(gantt, spanElement, intervalFinish, intervalStart, null, tag);
break;
}
#region Render
using (MemoryStream stream = new MemoryStream())
{
gantt.LoadStyleSheetFromFile(styleFilePath);
gantt.ApplyStyleSheet();
gantt.RenderPortion(new Point(0, 0), new Size(24 * 3, Convert.ToInt32(ItemHeight)), 0, 0, ImageFormat.Png, stream);
ret = stream.ToArray();
}
#endregion
return ret;
}
public void NewGroup(GanttItem task)
{
clTask newStGroup; // Структура новой группы
dictTasks.TryGetValue(task.Key, out newStGroup);
if (newStGroup == null)
newStGroup = new clTask();
int index = mainList.IndexOf(newStGroup);
newStGroup.bGroup = true;
newStGroup.TaskName = task.Text;
newStGroup.keyGantt = task.Key;
newStGroup.externalTask = false;
newStGroup.Dates.RuleForStartDate = Service.GetNamedValue(@"WORKORG\WayToCalculateDates\ManualWayToCalculateDates");
// InternalCalculation1 - Вычислять начало
newStGroup.Dates.DataBegTask = DateTime.MinValue;
newStGroup.Dates.RuleForFinishDate = Service.GetNamedValue(@"WORKORG\WayToCalculateDates\ManualWayToCalculateDates");
newStGroup.Dates.DataEndTask = DateTime.MinValue;
// Календарь переприсваивать не надо - пусть остаётся тот же, который был при импорте
// Признак Вехи переприсваивать не надо - пусть остаётся тот же, который был при импорте
if (index == -1)
// Новая группа
{
// Новая запись в словаре
dictTasks.Add(newStGroup.keyGantt, newStGroup);
// Новая запись в списке
mainList.Add(newStGroup);
index = mainList.IndexOf(newStGroup);
}
if (((GroupItem)task).ChildItems.Count() == 0)
{
// Создание новой задачи
TaskItem gt = this.GanttDiag.AddTask(DateTime.Now, DateTime.Now.AddDays(1), "Новая задача", GetNextOrder());
((GroupItem)task).AddChild(gt);
NewTask(gt);
}
foreach (var ts in ((GroupItem)task).ChildItems)
{
if (ts.ItemType == GanttItemType.GroupItem)
NewGroup(ts);
else
{
clTask strTask = null;
int ind = -1;
if (FindStOnKeyGantt(ts.Key, ref strTask, ref ind))
{
newStGroup.lChildrTask.Add(strTask);
}
NewTask(ts);
}
}
if (task.ParentItem == null) // Нет родительской группы
{
// Назначение основной группы - родительской для newStGroup
this.GanttDiag.Groups[0].AddChild(task);
}
else
{
// Запись в список родительских задач в структуре newStGroup
HelperClasses.stParentTask stPT = new HelperClasses.stParentTask(); // Структура родительской группы
clTask rabStTask = new clTask(); // Структура данных родительской группы
if (dictTasks.TryGetValue(task.ParentItem.Key, out rabStTask))
{
// Данные родительской группы rabStTask для группы newStTask определены
var ind = mainList.IndexOf(rabStTask);
// Поиск и удаление данных в дочерних задачах задачи newStTask
FindDelChlidSt(newStGroup.keyGantt);
stPT.Obj = rabStTask.Obj; // ИО родителской группы
stPT.IsPrimary = true; // Признак основной родительской задачи
stPT.keyGantt = rabStTask.keyGantt;
stPT.TaskName = rabStTask.TaskName;
stPT.idPlm = rabStTask.idPlm;
newStGroup.lParentTask.Add(stPT);
// Дополнение новой задачи в список дочерних
rabStTask.lChildrTask.Add(rabStTask);
// Замена в словаре
dictTasks[task.ParentItem.Key] = rabStTask;
// Замена в списке
mainList[ind] = rabStTask;
}
}
}
private void DrawTaskMonitored(GanttItem item, BasePlans.BasePlan baseplan)
{
(item as TaskItem).FormatStyle.BackgroundStyle.Color = this.usualTaskColor;
// Поиск соответствующего задаче базового плана.
var plmobj = this.parent.InstHelperPLM.DictTasksGetInfoObj(item.Key);
var baseline2draw = baseplan.GetBaseLine4Task(plmobj);
if (baseline2draw == null) return;
if (baseline2draw.Dates.DataEndTask < (item as TaskItem).EndDate)
(item as TaskItem).FormatStyle.BackgroundStyle.Color = Color.Red;
}