private IEnumerable <IEventInfo> GetTasks(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
 {
     foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
     {
         yield return(eventInfo);
     }
 }
		protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
		{
			foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
			{
				yield return eventInfo;
			}

			var task = hierarchicalItem.SourceItem as GanttDeadlineTask;
			var deadline = task != null ? task.GanttDeadLine : default(DateTime?);

			if (deadline.HasValue)
			{
				if (task.GanttDeadLine.HasValue && projectDeadLine < task.GanttDeadLine.Value)
				{
					deadline = task.GanttDeadLine = projectDeadLine;
					task.Refresh();
				}

				var roundedDeadline = state.Rounder.Round(new DateRange(deadline.Value, deadline.Value));
				var deadlineRange = new Range<long>(roundedDeadline.Start.Ticks, roundedDeadline.End.Ticks);

				if (deadlineRange.IntersectsWith(state.VisibleTimeRange))
				{
					yield return new TimeLineDeadlineEventInfo(deadlineRange, hierarchicalItem.Index, hierarchicalItem.SourceItem as GanttDeadlineTask);
				}
			}

			yield return new ProjectDeadlineEventInfo(new Range<long>(this.projectDeadLine.Ticks), 0, state.VisibleItems.Count - 1);
		}
        protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, Telerik.Windows.Core.HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return eventInfo;
            }

            var task = hierarchicalItem.SourceItem as GanttTask;
            if (task != null && !task.IsMilestone)
            {
                var roundedStart = state.Rounder.Round(new DateRange(task.Start, task.Start));
                var roundedEnd = state.Rounder.Round(new DateRange(task.End, task.End));
                var offSetTime = 0.3;
                var startLabelRange = new Range<long>(roundedStart.Start.AddDays(-1 - offSetTime).Ticks, roundedStart.Start.AddDays(-offSetTime).Ticks);
                var endLabelRange = new Range<long>(roundedEnd.Start.AddDays(offSetTime).Ticks, roundedEnd.Start.AddDays(1 + offSetTime).Ticks);

                if (startLabelRange.IntersectsWith(state.VisibleTimeRange))
                {
                    yield return new StartLabelEventInfo(startLabelRange, hierarchicalItem.Index)
                    {
                        OriginalEvent = hierarchicalItem.SourceItem
                    };
                }

                if (endLabelRange.IntersectsWith(state.VisibleTimeRange))
                {
                    yield return new EndLabelEventInfo(endLabelRange, hierarchicalItem.Index)
                    {
                        OriginalEvent = hierarchicalItem.SourceItem
                    };
                }
            }
        }
Example #4
0
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalWrapper)
        {
            if (!(hierarchicalWrapper.SourceItem is CustomRecurrenceTask))
            {
                foreach (var info in base.GetEventInfos(state, hierarchicalWrapper))
                {
                    yield return(info);
                }
            }

            var          dateRange    = hierarchicalWrapper.SourceItem as IDateRange;
            var          roundedRange = state.Rounder.Round(dateRange);
            var          taskRange    = new Range <long>(roundedRange.Start.Ticks, roundedRange.End.Ticks);
            var          task         = hierarchicalWrapper.SourceItem as CustomRecurrenceTask;
            Range <long> range        = null;

            if (task != null && task.RecurrenceRule != null)
            {
                for (int i = 0; i < task.RecurrenceRule.OcurrenceCount; i++)
                {
                    var recurrence = state.Rounder.Round(this.GetRecurrence(task, i));
                    range = new Range <long>(recurrence.Start.Ticks, recurrence.End.Ticks);

                    yield return(new TimeLineRecurrenceEventInfo(range, hierarchicalWrapper.Index)
                    {
                        OriginalEvent = recurrence
                    });
                }
            }
        }
Example #5
0
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return(eventInfo);
            }

            var task     = hierarchicalItem.SourceItem as GanttDeadlineTask;
            var deadline = task != null ? task.GanttDeadLine : default(DateTime?);

            if (deadline.HasValue)
            {
                if (task.GanttDeadLine.HasValue && projectDeadLine < task.GanttDeadLine.Value)
                {
                    deadline = task.GanttDeadLine = projectDeadLine;
                    task.Refresh();
                }

                var roundedDeadline = state.Rounder.Round(new DateRange(deadline.Value, deadline.Value));
                var deadlineRange   = new Range <long>(roundedDeadline.Start.Ticks, roundedDeadline.End.Ticks);

                if (deadlineRange.IntersectsWith(state.VisibleTimeRange))
                {
                    yield return(new TimeLineDeadlineEventInfo(deadlineRange, hierarchicalItem.Index, hierarchicalItem.SourceItem as GanttDeadlineTask));
                }
            }

            yield return(new ProjectDeadlineEventInfo(new Range <long>(this.projectDeadLine.Ticks), 0, state.VisibleItems.Count - 1));
        }
        protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalWrapper)
        {
            if (!(hierarchicalWrapper.SourceItem is CustomRecurrenceTask))
            {
                foreach (var info in base.GetEventInfos(state, hierarchicalWrapper))
                {
                    yield return info;
                }
            }

            var dateRange = hierarchicalWrapper.SourceItem as IDateRange;
            var roundedRange = state.Rounder.Round(dateRange);
            var taskRange = new Range<long>(roundedRange.Start.Ticks, roundedRange.End.Ticks);
            var task = hierarchicalWrapper.SourceItem as CustomRecurrenceTask;
            Range<long> range = null;

            if (task != null && task.RecurrenceRule != null)
            {
                for (int i = 0; i < task.RecurrenceRule.OcurrenceCount; i++)
                {
                    var recurrence = state.Rounder.Round(this.GetRecurrence(task, i));
                    range = new Range<long>(recurrence.Start.Ticks, recurrence.End.Ticks);

                    yield return new TimeLineRecurrenceEventInfo(range, hierarchicalWrapper.Index)
                    {
                        OriginalEvent = recurrence
                    };
                }
            }
        }
Example #7
0
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, Telerik.Windows.Core.HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return(eventInfo);
            }

            var task = hierarchicalItem.SourceItem as GanttTask;

            if (task != null && !task.IsMilestone)
            {
                var roundedStart    = state.Rounder.Round(new DateRange(task.Start, task.Start));
                var roundedEnd      = state.Rounder.Round(new DateRange(task.End, task.End));
                var offSetTime      = 0.3;
                var startLabelRange = new Range <long>(roundedStart.Start.AddDays(-1 - offSetTime).Ticks, roundedStart.Start.AddDays(-offSetTime).Ticks);
                var endLabelRange   = new Range <long>(roundedEnd.Start.AddDays(offSetTime).Ticks, roundedEnd.Start.AddDays(1 + offSetTime).Ticks);

                if (startLabelRange.IntersectsWith(state.VisibleTimeRange))
                {
                    yield return(new StartLabelEventInfo(startLabelRange, hierarchicalItem.Index)
                    {
                        OriginalEvent = hierarchicalItem.SourceItem
                    });
                }

                if (endLabelRange.IntersectsWith(state.VisibleTimeRange))
                {
                    yield return(new EndLabelEventInfo(endLabelRange, hierarchicalItem.Index)
                    {
                        OriginalEvent = hierarchicalItem.SourceItem
                    });
                }
            }
        }
 private IEnumerable<IEventInfo> GetTasks(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
 {
     foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
     {
         yield return eventInfo;
     }
 }
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            if (!hierarchicalItem.IsExpanded)
            {
                return(base.GetEventInfos(state, hierarchicalItem));
            }

            return(Enumerable.Empty <IEventInfo>());
        }
        protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            if (!hierarchicalItem.IsExpanded)
            {
                return base.GetEventInfos(state, hierarchicalItem);
            }

            return Enumerable.Empty<IEventInfo>();
        }
        private IEnumerable<IEventInfo> GetAllChildren(TimeLineVisualizationState state, int index, HierarchicalItem hierarchicalItem)
        {
            if (!hierarchicalItem.CanExpand)
            {
                return this.GetEventInfosBase(state, index, hierarchicalItem);
            }

            return hierarchicalItem.Children.SelectMany(h => this.GetAllChildren(state, index, h));
        }
        private IEnumerable <IEventInfo> GetAllChildren(TimeLineVisualizationState state, int index, HierarchicalItem hierarchicalItem)
        {
            if (!hierarchicalItem.CanExpand)
            {
                return(this.GetEventInfosBase(state, index, hierarchicalItem));
            }

            return(hierarchicalItem.Children.SelectMany(h => this.GetAllChildren(state, index, h)));
        }
        private IEnumerable<IEventInfo> GetAllChildren(TimeLineVisualizationState state, int index, HierarchicalItem hierarchicalItem)
        {
            var recurringTask = hierarchicalItem.SourceItem as RecurrenceTask;
            if (recurringTask != null)
            {
                foreach (var recurrence in recurringTask.Recurrences)
                {
                    var roundedRecurrence = state.Rounder.Round(new DateRange(recurrence.Start, recurrence.End));
                    var range = new Range<long>(roundedRecurrence.Start.Ticks, roundedRecurrence.End.Ticks);

                    yield return new TimeLineRecurrenceEventInfo(range, hierarchicalItem.Index) { OriginalEvent = recurrence };
                }
            }
        }
        protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            if (hierarchicalItem.SourceItem is RecurrenceTask)
            {
                if (!hierarchicalItem.IsExpanded)
                {
                    return this.GetAllChildren(state, hierarchicalItem.Index, hierarchicalItem);
                }

                return Enumerable.Empty<IEventInfo>();
            }

            return this.GetTasks(state, hierarchicalItem);
        }
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, Telerik.Windows.Core.HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return(eventInfo);
            }

            var task = hierarchicalItem.SourceItem as GanttResourceTask;

            yield return(new TimeLineResourceEventInfo(new Range <long>(task.End.Ticks, task.End.AddYears(2).Ticks), hierarchicalItem.Index, 1, new Range <int>(0), IsSummary(hierarchicalItem.SourceItem), IsMilestone(hierarchicalItem.SourceItem))
            {
                OriginalEvent = hierarchicalItem.SourceItem
            });
        }
        protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, Telerik.Windows.Core.HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return eventInfo;
            }

            var task = hierarchicalItem.SourceItem as GanttResourceTask;

            yield return new TimeLineResourceEventInfo(new Range<long>(task.End.Ticks, task.End.AddYears(2).Ticks), hierarchicalItem.Index, 1, new Range<int>(0), IsSummary(hierarchicalItem.SourceItem), IsMilestone(hierarchicalItem.SourceItem))
            {
                OriginalEvent = hierarchicalItem.SourceItem
            };
        }
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            if (hierarchicalItem.SourceItem is RecurrenceTask)
            {
                if (!hierarchicalItem.IsExpanded)
                {
                    return(this.GetAllChildren(state, hierarchicalItem.Index, hierarchicalItem));
                }

                return(Enumerable.Empty <IEventInfo>());
            }

            return(this.GetTasks(state, hierarchicalItem));
        }
Example #18
0
        protected override System.Collections.IEnumerable GetBackgroundData(TimeLineVisualizationState state)
        {
            foreach (var background in base.GetBackgroundData(state))
            {
                yield return(background);
            }

            var visibleRange  = state.VisibleTimeRange;
            var deadline      = state.Rounder.Round(new DateRange(this.projectDeadline, this.projectDeadline));
            var deadlineRange = new Range <long>(deadline.Start.Ticks, deadline.End.Ticks);

            if (visibleRange.IntersectsWith(deadlineRange))
            {
                yield return(new TimeLineDeadlineEventInfo(deadlineRange));
            }
        }
        protected override IEnumerable GetBackgroundData(TimeLineVisualizationState state)
        {
            foreach (var background in base.GetBackgroundData(state))
            {
                yield return background;
            }

            var visibleRange = state.VisibleTimeRange;
            var deadline = state.Rounder.Round(new DateRange(this.projectDeadline, this.projectDeadline));
            var deadlineRange = new Range<long>(deadline.Start.Ticks, deadline.End.Ticks);

            if (visibleRange.IntersectsWith(deadlineRange))
            {
                yield return new TimeLineDeadlineEventInfo(deadlineRange);
            }
        }
        private IEnumerable <IEventInfo> GetEventInfosBase(TimeLineVisualizationState state, int index, HierarchicalItem hierarchicalItem)
        {
            var dateRange    = hierarchicalItem.SourceItem as IDateRange;
            var roundedRange = state.Rounder.Round(dateRange);
            var taskRange    = new Range <long>(roundedRange.Start.Ticks, roundedRange.End.Ticks);

            if (taskRange.IntersectsWith(state.VisibleTimeRange))
            {
                var eventInfo = new EventInfo(taskRange, index, 1, new Range <int>(0), IsSummary(hierarchicalItem.SourceItem), IsMilestone(hierarchicalItem.SourceItem))
                {
                    OriginalEvent = hierarchicalItem.SourceItem
                };

                yield return(eventInfo);
            }
        }
        private IEnumerable<IEventInfo> GetEventInfosBase(TimeLineVisualizationState state, int index, HierarchicalItem hierarchicalItem)
        {
            var dateRange = hierarchicalItem.SourceItem as IDateRange;
            var roundedRange = state.Rounder.Round(dateRange);
            var taskRange = new Range<long>(roundedRange.Start.Ticks, roundedRange.End.Ticks);

            if (taskRange.IntersectsWith(state.VisibleTimeRange))
            {
                var eventInfo = new EventInfo(taskRange, index, 1, new Range<int>(0), IsSummary(hierarchicalItem.SourceItem), IsMilestone(hierarchicalItem.SourceItem))
                {
                    OriginalEvent = hierarchicalItem.SourceItem
                };

                yield return eventInfo;
            }
        }
Example #22
0
        private IEnumerable <IEventInfo> GetAllChildren(TimeLineVisualizationState state, int index, HierarchicalItem hierarchicalItem)
        {
            var recurringTask = hierarchicalItem.SourceItem as RecurrenceTask;

            if (recurringTask != null)
            {
                foreach (var recurrence in recurringTask.Recurrences)
                {
                    var roundedRecurrence = state.Rounder.Round(new DateRange(recurrence.Start, recurrence.End));
                    var range             = new Range <long>(roundedRecurrence.Start.Ticks, roundedRecurrence.End.Ticks);

                    yield return(new TimeLineRecurrenceEventInfo(range, hierarchicalItem.Index)
                    {
                        OriginalEvent = recurrence
                    });
                }
            }
        }
        protected override IEnumerable GetBackgroundData(TimeLineVisualizationState state)
        {
            foreach (var background in base.GetBackgroundData(state))
            {
                yield return background;
            }

            var visibleRange = state.VisibleTimeRange;
            foreach (var deadLine in GlobalDeadLines)
            {
                var deadline = state.Rounder.Round(new DateRange(deadLine.Start, deadLine.End));
                var deadlineRange = new Range<long>(deadline.Start.Ticks, deadline.End.Ticks);

                if (visibleRange.IntersectsWith(deadlineRange))
                {
                    yield return new GlobalEventTimeSlotInfo(deadlineRange);
                }
            }
        }
Example #24
0
        protected override IEnumerable GetBackgroundData(TimeLineVisualizationState state)
        {
            foreach (var background in base.GetBackgroundData(state))
            {
                yield return(background);
            }

            var visibleRange = state.VisibleTimeRange;

            foreach (var deadLine in GlobalDeadLines)
            {
                var deadline      = state.Rounder.Round(new DateRange(deadLine.Start, deadLine.End));
                var deadlineRange = new Range <long>(deadline.Start.Ticks, deadline.End.Ticks);

                if (visibleRange.IntersectsWith(deadlineRange))
                {
                    yield return(new GlobalEventTimeSlotInfo(deadlineRange));
                }
            }
        }
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return(eventInfo);
            }

            var task = hierarchicalItem.SourceItem as GanttBaselineTask;
            var baselineStartDate = task != null ? task.StartPlannedDate : DateTime.MinValue;

            if (baselineStartDate != null && baselineStartDate != DateTime.MinValue)
            {
                var roundedDeadline = state.Rounder.Round(new DateRange(baselineStartDate, task.EndPlannedDate));
                var baselineRange   = new Range <long>(roundedDeadline.Start.Ticks, roundedDeadline.End.Ticks);

                if (baselineRange.IntersectsWith(state.VisibleTimeRange))
                {
                    yield return(new BaselineEventInfo(baselineRange, hierarchicalItem.Index, hierarchicalItem.SourceItem as GanttBaselineTask));
                }
            }
        }
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return(eventInfo);
            }

            var dateRange    = hierarchicalItem.SourceItem as IDateRange;
            var roundedRange = state.Rounder.Round(dateRange);
            var currentDay   = new DateTime(roundedRange.Start.Year, this.visibleRange.Start.Month, this.visibleRange.Start.Day);

            while (this.visibleRange.End > currentDay)
            {
                var range = new Range <long>(currentDay.Ticks, currentDay.Ticks);
                currentDay = currentDay.AddDays(1);

                yield return(new IntervalEventInfo(range, hierarchicalItem.Index));
            }

            yield return(new CurrentHourIndicatorEventInfo(new Range <long>(DateTime.Now.Ticks, DateTime.Now.Ticks), hierarchicalItem.Index));
        }
        protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, Telerik.Windows.Core.HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return eventInfo;
            }

            var task = hierarchicalItem.SourceItem as GanttDeadlineTask;
            var deadline = task != null ? task.GanttDeadLine : default(DateTime?);

            if (deadline.HasValue)
            {
                var roundedDeadline = state.Rounder.Round(new DateRange(deadline.Value, deadline.Value));
                var deadlineRange = new Range<long>(roundedDeadline.Start.Ticks, roundedDeadline.End.Ticks);

                if (deadlineRange.IntersectsWith(state.VisibleTimeRange))
                {
                    yield return new TimeLineDeadlineEventInfo(deadlineRange, hierarchicalItem.Index);
                }
            }
        }
        protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return eventInfo;
            }

            var dateRange = hierarchicalItem.SourceItem as IDateRange;
            var roundedRange = state.Rounder.Round(dateRange);
            var currentDay = new DateTime(roundedRange.Start.Year, this.visibleRange.Start.Month, this.visibleRange.Start.Day);

            while (this.visibleRange.End > currentDay)
            {
                var range = new Range<long>(currentDay.Ticks, currentDay.Ticks);
                currentDay = currentDay.AddDays(1);

                yield return new IntervalEventInfo(range, hierarchicalItem.Index);
            }

            yield return new CurrentHourIndicatorEventInfo(new Range<long>(DateTime.Now.Ticks, DateTime.Now.Ticks), hierarchicalItem.Index);
        }
Example #29
0
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, Telerik.Windows.Core.HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return(eventInfo);
            }

            var task     = hierarchicalItem.SourceItem as GanttDeadlineTask;
            var deadline = task != null ? task.GanttDeadLine : default(DateTime?);

            if (deadline.HasValue)
            {
                var roundedDeadline = state.Rounder.Round(new DateRange(deadline.Value, deadline.Value));
                var deadlineRange   = new Range <long>(roundedDeadline.Start.Ticks, roundedDeadline.End.Ticks);

                if (deadlineRange.IntersectsWith(state.VisibleTimeRange))
                {
                    yield return(new TimeLineDeadlineEventInfo(deadlineRange, hierarchicalItem.Index));
                }
            }
        }
		protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
		{
			foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
			{
				yield return eventInfo;
			}

			var task = hierarchicalItem.SourceItem as GanttBaselineTask;
			var baselineStartDate = task != null ? task.StartPlannedDate : DateTime.MinValue;

			if (baselineStartDate != null && baselineStartDate != DateTime.MinValue)
			{
				var roundedDeadline = state.Rounder.Round(new DateRange(baselineStartDate, task.EndPlannedDate));
				var baselineRange = new Range<long>(roundedDeadline.Start.Ticks, roundedDeadline.End.Ticks);

				if (baselineRange.IntersectsWith(state.VisibleTimeRange))
				{
					yield return new BaselineEventInfo(baselineRange, hierarchicalItem.Index, hierarchicalItem.SourceItem as GanttBaselineTask);
				}
			}
		}
        protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, Telerik.Windows.Core.HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return eventInfo;
            }

            var task = hierarchicalItem.SourceItem as CustomGanttTask;
            foreach (var deadLine in task.CustomDeadLines)
            {
                if (deadLine != null)
                {
                    var roundedDeadline = state.Rounder.Round(deadLine);
                    var deadlineRange = new Range<long>(roundedDeadline.Start.Ticks, roundedDeadline.End.Ticks);

                    if (deadlineRange.IntersectsWith(state.VisibleTimeRange))
                    {
                        yield return new NationalEventSlotInfo(deadlineRange, hierarchicalItem.Index);
                    }
                }
            }
        }
Example #32
0
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, Telerik.Windows.Core.HierarchicalItem hierarchicalItem)
        {
            foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
            {
                yield return(eventInfo);
            }

            var task = hierarchicalItem.SourceItem as CustomGanttTask;

            foreach (var deadLine in task.CustomDeadLines)
            {
                if (deadLine != null)
                {
                    var roundedDeadline = state.Rounder.Round(deadLine);
                    var deadlineRange   = new Range <long>(roundedDeadline.Start.Ticks, roundedDeadline.End.Ticks);

                    if (deadlineRange.IntersectsWith(state.VisibleTimeRange))
                    {
                        yield return(new NationalEventSlotInfo(deadlineRange, hierarchicalItem.Index));
                    }
                }
            }
        }