public void PerformClickShouldExecuteCommand()
        {
            var clicked = false;
            var command = new Command<string>(
                p =>
                {
                    Assert.Null( p );
                    clicked = true;
                } );
            var target = new HierarchicalItem<string>( "test", command );

            target.PerformClick();
            Assert.True( clicked );

            clicked = false;
            command = new Command<string>(
                p =>
                {
                    Assert.Equal( "test2", p );
                    clicked = true;
                } );
            target = new HierarchicalItem<string>( "test", command );
            target.PerformClick( "test2" );
            Assert.True( clicked );
        }
Example #2
0
        public HierarchicalGroup CreateGroup(string presetsKey, string displayName = "", string prependWithDefault = null)
        {
            Func <IEnumerable <object> > groupPresets = () => {
                var result = UserPresetsControl.GroupPresets(presetsKey);

                if (prependWithDefault != null)
                {
                    var menuItem = new HierarchicalItem {
                        Header = new TextBlock {
                            Text = prependWithDefault, FontStyle = FontStyles.Italic
                        }
                    };

                    HierarchicalItemsView.SetValue(menuItem, null);
                    result = result.Prepend(menuItem);
                }

                return(result);
            };

            var group = new HierarchicalGroup(displayName, groupPresets());

            var handler = new EventHandler((sender, e) => {
                group.ReplaceEverythingBy(groupPresets());
            });

            PresetsManager.Instance.Watcher(presetsKey).Update += handler;
            _presetsHandlersToRemove.Add(new PresetsHandlerToRemove {
                Key = presetsKey, Handler = handler
            });

            return(group);
        }
        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
                    };
                }
            }
        }
 private IEnumerable<IEventInfo> GetTasks(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
 {
     foreach (var eventInfo in base.GetEventInfos(state, hierarchicalItem))
     {
         yield return eventInfo;
     }
 }
 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);
		}
        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));
        }
        protected override IEnumerable<IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            if (!hierarchicalItem.IsExpanded)
            {
                return base.GetEventInfos(state, hierarchicalItem);
            }

            return Enumerable.Empty<IEventInfo>();
        }
Example #9
0
        private static void DoGroup(HierarchicalItem field)
        {
            if (field == null)
            {
                return;
            }

            ViewModel.IMainViewModel mainViewModel = TMPApplication.TMPApp.Instance.MainViewModel as ViewModel.IMainViewModel;
            if (mainViewModel == null)
            {
                return;
            }
            ViewModel.IViewModelWithDataView viewModel = mainViewModel.CurrentViewModel as ViewModel.IViewModelWithDataView;
            if (viewModel == null)
            {
                return;
            }

            if (viewModel.View == null)
            {
                return;
            }

            if (viewModel.View.CanSort == false)
            {
                return;
            }

            using (viewModel.View.DeferRefresh())
            {
                GroupingFields = string.Empty;
                viewModel.View.GroupDescriptions.Clear();
                if (field.Name == None)
                {
                    return;
                }

                Stack <string>   stack = new();
                HierarchicalItem item  = field;
                while (item != null)
                {
                    stack.Push(item.Name);
                    item = item.Parent;
                }

                string[] values = stack.ToArray();
                GroupingFields = string.Join(" > ", values.Select(s => s.Replace("_", " ", AppSettings.StringComparisonMethod)));
                foreach (string value in values)
                {
                    viewModel.View.GroupDescriptions.Add(new PropertyGroupDescription(value));
                }
            }
        }
        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);
        }
        public void ShouldSelectedAndUnselect()
        {
            var target = new HierarchicalItem<string>( "test", new Command<string>( Console.WriteLine ) );

            Assert.Equal( "test", target.Value );
            Assert.Null( target.IsSelected );
            Assert.PropertyChanged( target, "IsSelected", () => target.IsSelected = true );
            Assert.True( target.IsSelected.Value );

            target.Unselect.Execute( null );
            Assert.False( target.IsSelected.Value );

            target.Select.Execute( null );
            Assert.True( target.IsSelected.Value );
        }
        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;
            }
        }
 public HierarchicalItemsTemplate()
 {
     InitializeComponent();
     root = new HierarchicalItem("Root");
     root.Children.Add(new HierarchicalItem("1"));
     root.Children[0].Children.Add(new HierarchicalItem("1.1"));
     root.Children[0].Children.Add(new HierarchicalItem("1.2"));
     root.Children[0].Children.Add(new HierarchicalItem("1.3"));
     root.Children.Add(new HierarchicalItem("2"));
     root.Children[1].Children.Add(new HierarchicalItem("2.1"));
     root.Children[1].Children.Add(new HierarchicalItem("2.2"));
     root.Children[1].Children.Add(new HierarchicalItem("2.3"));
     root.Children.Add(new HierarchicalItem("Lorem ipsum dolor sit amet, consectetur adipiscing elit.\nSed non risus. Suspendisse lectus tortor, dignissim sit amet, adipiscing nec, ultricies sed, dolor."));
     root.Children[2].Children.Add(new HierarchicalItem("3.1"));
     root.Children[2].Children.Add(new HierarchicalItem("3.2"));
     root.Children[2].Children.Add(new HierarchicalItem("3.3"));
     root.Children[2].Children[0].Children.Add(new HierarchicalItem("Lorem ipsum dolor sit amet"));
     this.BindingContext = this;
 }
        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, 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);
				}
			}
		}
        public void ConstructorShouldSetExpectedProperties()
        {
            var command = new Command<string>( Console.WriteLine );
            var target = new HierarchicalItem<string>( "test", command );

            Assert.Equal( "test", target.Value );
            Assert.Null( target.IsSelected );
            Assert.IsType<CommandInterceptor<object>>( target.Click );

            target = new HierarchicalItem<string>( "test", command, EqualityComparer<string>.Default );
            Assert.Equal( "test", target.Value );
            Assert.Null( target.IsSelected );
            Assert.IsType<CommandInterceptor<object>>( target.Click );

            target = new HierarchicalItem<string>( "test", true, command );
            Assert.Equal( "test", target.Value );
            Assert.Equal( true, target.IsSelected );
            Assert.IsType<CommandInterceptor<object>>( target.Click );

            target = new HierarchicalItem<string>( "test", true, command, EqualityComparer<string>.Default );
            Assert.Equal( "test", target.Value );
            Assert.Equal( true, target.IsSelected );
            Assert.IsType<CommandInterceptor<object>>( target.Click );
        }
Example #18
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
                    });
                }
            }
        }
        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)));
        }
Example #20
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
                    });
                }
            }
        }
        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);
            }
        }
        public void EqualsShouldReturnExpectedResult()
        {
            var command = new Command<string>( Console.WriteLine );
            var target = new HierarchicalItem<string>( "test", command );
            var child = new HierarchicalItem<string>( "test", command );

            target.Add( child );

            Assert.True( target == new HierarchicalItem<string>( "test", command ) );
            Assert.True( target != new HierarchicalItem<string>( "test1", command ) );
            Assert.True( target.Equals( new HierarchicalItem<string>( "test", command ) ) );
            Assert.False( target.Equals( new HierarchicalItem<string>( "test1", command ) ) );
            Assert.True( target.Equals( (object) new HierarchicalItem<string>( "test", command ) ) );
            Assert.False( target.Equals( (object) new HierarchicalItem<string>( "test1", command ) ) );

            Assert.False( child == target );
            Assert.True( child != target );
            Assert.False( child.Equals( target ) );
            Assert.False( child.Equals( (object) target ) );

            var comparer = StringComparer.OrdinalIgnoreCase;
            target = new HierarchicalItem<string>( "test", command, comparer );

            Assert.True( target == new HierarchicalItem<string>( "TEST", command, comparer ) );
            Assert.True( target != new HierarchicalItem<string>( "TEST1", command, comparer ) );
            Assert.True( target.Equals( new HierarchicalItem<string>( "TEST", command, comparer ) ) );
            Assert.False( target.Equals( new HierarchicalItem<string>( "TEST1", command, comparer ) ) );
            Assert.True( target.Equals( (object) new HierarchicalItem<string>( "TEST", command, comparer ) ) );
            Assert.False( target.Equals( (object) new HierarchicalItem<string>( "TEST1", command, comparer ) ) );
        }
        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)
        {
            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, 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));
        }
 public void DepthPropertyShouldReturnCorrectLevel()
 {
     var command = new Command<string>( Console.WriteLine );
     var target = new HierarchicalItem<string>( "test", command );
     Assert.Equal( 0, target.Depth );
     target.Add( new HierarchicalItem<string>( "1", command ) );
     Assert.Equal( 1, target[0].Depth );
     target[0].Add( new HierarchicalItem<string>( "2", command ) );
     Assert.Equal( 2, target[0][0].Depth );
     target[0][0].Add( new HierarchicalItem<string>( "3", command ) );
     Assert.Equal( 3, target[0][0][0].Depth );
 }
 public void ParentPropertyShouldReturnCorrectObject()
 {
     var command = new Command<string>( Console.WriteLine );
     var target = new HierarchicalItem<string>( "test", command );
     Assert.Null( target.Parent );
     target.Add( new HierarchicalItem<string>( "1", command ) );
     Assert.Equal( target, target[0].Parent );
     target[0].Add( new HierarchicalItem<string>( "2", command ) );
     Assert.Equal( target[0], target[0][0].Parent );
     target[0][0].Add( new HierarchicalItem<string>( "3", command ) );
     Assert.Equal( target[0][0], target[0][0][0].Parent );
 }
        public void TwoItemsWithTheSameValueAtDifferentDepthsShouldYieldDifferentHashCodes()
        {
            var comparer = new DynamicComparer<Tuple<int, string>>( tuple => tuple.Item1.GetHashCode() );
            var command = new Command<string>( Console.WriteLine );
            var item1 = new HierarchicalItem<Tuple<int, string>>( new Tuple<int, string>( 1, "0" ), command, comparer );
            item1.Add( new HierarchicalItem<Tuple<int, string>>( new Tuple<int, string>( 1, "1" ), command, comparer ) );
            var item2 = new HierarchicalItem<Tuple<int, string>>( new Tuple<int, string>( 1, "2" ), command, comparer );
            item1[0].Add( item2 );

            Assert.Equal( item1.Value.Item1, item2.Value.Item1 );
            Assert.NotEqual( item1.Depth, item2.Depth );
            Assert.NotEqual( item1.GetHashCode(), item2.GetHashCode() );
        }
        public void WhenValueAndDepthOfTwoItemsAreUnequalTheyShouldYieldDifferentHashCodes()
        {
            var comparer = new DynamicComparer<Tuple<int, string>>( tuple => tuple.Item1.GetHashCode() );
            var command = new Command<string>( Console.WriteLine );
            var item1 = new HierarchicalItem<Tuple<int, string>>( new Tuple<int, string>( 2, "0" ), command, comparer );
            item1.Add( new HierarchicalItem<Tuple<int, string>>( new Tuple<int, string>( 1, "1" ), command, comparer ) );
            var item2 = new HierarchicalItem<Tuple<int, string>>( new Tuple<int, string>( 0, "2" ), command, comparer );
            item1[0].Add( item2 );

            Assert.NotEqual( item1.Depth, item2.Depth );
            Assert.NotEqual( item1.GetHashCode(), item2.GetHashCode() );
        }
        protected override IEnumerable <IEventInfo> GetEventInfos(TimeLineVisualizationState state, HierarchicalItem hierarchicalItem)
        {
            if (!hierarchicalItem.IsExpanded)
            {
                return(base.GetEventInfos(state, hierarchicalItem));
            }

            return(Enumerable.Empty <IEventInfo>());
        }
Example #31
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));
        }