protected bool ShouldDisplayAsZero(TimelineItem child)
{
DateTime?childStartDate = GetStartDate(child);
DateTime?childEndDate = GetEndDate(child);
bool displayAsZero;
if (!(childStartDate.HasValue && childEndDate.HasValue))
{
displayAsZero = false;
}
else if (childStartDate.HasValue && childEndDate.HasValue)
{
TimeSpan duration = childEndDate.Value - childStartDate.Value;
displayAsZero = (duration.Ticks <
TickTimeSpan.Ticks * MinimumDisplayMultiplier);
}
else
{
// Only start or end time exist, display as zero.
displayAsZero = true;
}
return(displayAsZero);
}
public void BringItemIntoView(object item)
{
TimelineItem container = ContainerFromItem(item);
if (container != null)
{
Nullable <long> start = TimelineCompactPanel.GetStartTick(container);
if (start.HasValue)
{
GoToTick(start.Value);
}
}
}
public void BringIntoView(
TimelineControlBringIntoViewMode mode, object dataItem)
{
TimelineItem container = ContainerFromItem(dataItem);
if (container != null)
{
Nullable <DateTime> start = TimelineCompactPanel.GetStartDate(container);
Nullable <DateTime> end = TimelineCompactPanel.GetEndDate(container);
if (IsSetZoomToFit(mode) && start.HasValue && end.HasValue)
{
TimeSpan duration = end.Value - start.Value;
double pixelPerTick = (ActualWidth / 2) / duration.Ticks;
TimeSpan newTickTimeSpan = TimeSpan.FromTicks((long)(1D / pixelPerTick));
if (newTickTimeSpan.TotalMinutes < 1)
{
newTickTimeSpan = TimeSpan.FromMinutes(1);
}
if (newTickTimeSpan < TickTimeSpan)
{
TickTimeSpan = newTickTimeSpan;
}
else
{
if (ActualWidth / 2 < duration.Ticks * Timeline.GetPixelsPerTick(this))
{
TickTimeSpan = newTickTimeSpan;
}
}
WpfUtility.WaitForPriority(DispatcherPriority.Background);
}
if (IsSetCurrentTime(mode))
{
if (start.HasValue)
{
CurrentTime = start.Value;
}
else if (end.HasValue)
{
CurrentTime = end.Value;
}
}
}
}
protected TimelineItem FindChildByDaya(object dep)
{
foreach (UIElement element in Children)
{
TimelineItem priorItem = element as TimelineItem;
if (priorItem != null)
{
if (object.Equals(priorItem.DataContext, dep))
{
return(priorItem);
}
}
}
return(null);
}
private Rect CalcChildRectForDisplayAsZero(TimelineItem child, int childRowIndex)
{
DateTime?childStartDate = GetStartDate(child);
DateTime?childEndDate = GetEndDate(child);
DateTime centerDate;
if (MinimumDate == null || MaximumDate == null)
{
return(Rect.Empty);
}
if (!(childStartDate.HasValue && childEndDate.HasValue))
{
// Patch?
centerDate = MinimumDate.Value;
}
else if (childStartDate.HasValue && childEndDate.HasValue)
{
TimeSpan duration = childEndDate.Value - childStartDate.Value;
centerDate = childStartDate.Value.Add(
TimeSpan.FromTicks(duration.Ticks / 2));
}
else if (childStartDate.HasValue)
{
centerDate = childStartDate.Value;
}
else if (childEndDate.HasValue)
{
centerDate = childEndDate.Value;
}
else
{
throw new Exception("Invalid state of TimelineItem values");
}
double offset = (centerDate - MinimumDate.Value).Ticks * PixelsPerTick;
double width = 20;
double childTopOffset = childRowIndex * RowHeight +
childRowIndex * RowVerticalMargin;
return(new Rect(offset, childTopOffset, width, RowHeight));
}
protected Rect CalcChildRect(TimelineItem child, int childRowIndex)
{
if (/*child.Visibility == Visibility.Collapsed || */ child.IsCollapsed)
{
return(Rect.Empty);
}
Rect desiredSize;
if (child.IsDisplayAsZero)
{
desiredSize = CalcChildRectForDisplayAsZero(child, childRowIndex);
}
else
{
desiredSize = CalcChildRectByDuration(child, childRowIndex);
}
return(desiredSize);
}
private Rect CalcChildRectForDisplayAsZero(TimelineItem child, int childRowIndex)
{
long?childStartTick = GetStartTick(child);
long?childEndTick = GetEndTick(child);
long centerTick;
if (MinimumTick == null || MaximumTick == null)
{
return(Rect.Empty);
}
if (!(childStartTick.HasValue && childEndTick.HasValue))
{
// Patch?
centerTick = MinimumTick.Value;
}
else if (childStartTick.HasValue && childEndTick.HasValue)
{
long duration = childEndTick.Value - childStartTick.Value;
centerTick = childStartTick.Value + (duration / 2);
}
else if (childStartTick.HasValue)
{
centerTick = childStartTick.Value;
}
else if (childEndTick.HasValue)
{
centerTick = childEndTick.Value;
}
else
{
throw new Exception("Invalid state of TimelineItem values");
}
double offset = (centerTick - MinimumTick.Value) * PixelsPerTick;
double width = 20;
double childTopOffset = childRowIndex * RowHeight + childRowIndex * RowVerticalMargin;
return(new Rect(offset, childTopOffset, width, RowHeight));
}
private Rect CalcChildRectByDuration(TimelineItem child, int childRowIndex)
{
if (GetStartTick(child) == null || GetEndTick(child) == null || MinimumTick == null)
{
return(Rect.Empty);
}
long childStartTick = GetStartTick(child) ?? MinimumTick.Value;
long childEndTick = GetEndTick(child) ?? MinimumTick.Value;
if (childEndTick < childStartTick)
{
childEndTick = childStartTick;
}
long childDuration = childEndTick - childStartTick;
double offset = (childStartTick - MinimumTick.Value) * PixelsPerTick;
double width = childDuration * PixelsPerTick;
double childTopOffset = childRowIndex * RowHeight + childRowIndex * RowVerticalMargin;
return(new Rect(offset, childTopOffset, width, RowHeight));
}
private Rect CalcChildRectByDuration(TimelineItem child, int childRowIndex)
{
if (GetStartDate(child) == null || GetEndDate(child) == null || MinimumDate == null)
{
return(Rect.Empty);
}
DateTime childStartDate = GetStartDate(child) ?? MinimumDate.Value;
DateTime childEndDate = GetEndDate(child) ?? MinimumDate.Value;
if (childEndDate < childStartDate)
{
childEndDate = childStartDate;
}
TimeSpan childDuration = childEndDate - childStartDate;
double offset = (childStartDate - MinimumDate.Value).Ticks * PixelsPerTick;
double width = childDuration.Ticks * PixelsPerTick;
double childTopOffset = childRowIndex * RowHeight +
childRowIndex * RowVerticalMargin;
return(new Rect(offset, childTopOffset, width, RowHeight));
}
protected override void PrepareContainerForItemOverride(
DependencyObject element, object item)
{
base.PrepareContainerForItemOverride(element, item);
if (Timeline != null)
{
object fromItem = GetFromItem(element);
object toItem = GetToItem(element);
if (fromItem != null && toItem != null)
{
TimelineItem tlFromItem = Timeline.ContainerFromItem(fromItem);
TimelineItem tlToItem = Timeline.ContainerFromItem(toItem);
if (tlFromItem != null && tlToItem != null)
{
Connection conn = (Connection)element;
conn.SourceItem = tlFromItem;
conn.SinkItem = tlToItem;
}
}
}
}
private static void IsDisplayAsZeroChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
TimelineItem item = (TimelineItem)o;
item.OnPropertyChanged("IsDisplayAsZero");
}
private static void IsCollapsedChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
TimelineItem item = (TimelineItem)o;
item.OnPropertyChanged("IsCollapsed");
}
protected override Size MeasureOverride(Size availableSize)
{
rowsCount = -1;
List <UIElement> measuredChildren = new List <UIElement>();
Dictionary <int, int> logicalToActualMap = new Dictionary <int, int>();
var q =
from c in Children.OfType <UIElement>()
let row = GetRowIndex(c)
orderby row
select new { Child = c, Row = row };
int nextActualRowIndex = 0;
foreach (var childAndRow in q)
{
ClearActualRowIndex(childAndRow.Child);
childAndRow.Child.ClearValue(UIElement.VisibilityProperty);
TimelineItem tlChild = (TimelineItem)childAndRow.Child;
tlChild.IsDisplayAsZero = ShouldDisplayAsZero(tlChild);
tlChild.ApplyTemplate();
Rect calcChildSize = CalcChildRect(tlChild, nextActualRowIndex);
childAndRow.Child.Measure(calcChildSize.Size);
if (tlChild.IsCollapsed)
{
childAndRow.Child.Visibility = Visibility.Collapsed;
}
else
{
int actualRowIndex;
if (!logicalToActualMap.TryGetValue(childAndRow.Row, out actualRowIndex))
{
actualRowIndex = nextActualRowIndex++;
logicalToActualMap.Add(childAndRow.Row, actualRowIndex);
}
SetActualRowIndex(childAndRow.Child, actualRowIndex);
SetChildRow(childAndRow.Child, measuredChildren);
measuredChildren.Add(childAndRow.Child);
if (IsChildHasNoStartAndEndTime(childAndRow.Child))
{
childAndRow.Child.Visibility = Visibility.Hidden;
}
}
}
TimeSpan totalTimeSpan = TimeSpan.Zero;
if (MaximumDate.HasValue && MinimumDate.HasValue)
{
totalTimeSpan = MaximumDate.Value - MinimumDate.Value;
}
double totalWidth = Math.Max(0, totalTimeSpan.Ticks * PixelsPerTick);
double totalHeight = Math.Max(0,
nextActualRowIndex * RowHeight + nextActualRowIndex * RowVerticalMargin);
return(totalWidth <= 0 || totalHeight <= 0 ? Size.Empty : new Size(totalWidth, totalHeight));
}
