public bool isFadeType(TourEvent.Type type)
{
if (type == TourEvent.Type.fadeInHighlight ||
type == TourEvent.Type.fadeOutHighlight ||
type == TourEvent.Type.fadeInMedia ||
type == TourEvent.Type.fadeOutMedia ||
type == TourEvent.Type.fadeInMSI ||
type == TourEvent.Type.fadeOutMSI ||
type == TourEvent.Type.fadeInPath ||
type == TourEvent.Type.fadeOutPath)
return true;
return false;
}
public void insertTourEvent(TourEvent te, Timeline timeline, double beginTime)
{
foreach (timelineInfo ti in timeLineList)
{
if (ti.timeline.Equals(timeline))
{
addTourEvent(ti, te, ti.lengthSV, beginTime, te.duration);
}
}
}
public void addTourEvent(timelineInfo timelineInfoStruct, TourEvent tourEvent, ScatterView timelineSV, double beginTime, double duration)
{
ScatterViewItem currentSVI = new ScatterViewItem();
currentSVI.MinWidth = 10; // don't want it to disappear, but still need it to be touchable (even if resolution is as low as 1024 x 768)
currentSVI.MinHeight = 10;
currentSVI.Width = duration * (timelineWidth / timelineLength);
currentSVI.Height = timelineHeight - 7;
currentSVI.Background = new SolidColorBrush(Colors.Transparent);
currentSVI.Orientation = 0;
currentSVI.CanRotate = false;
currentSVI.Deceleration = double.NaN; // disables inertia
currentSVI.Center = new Point((beginTime * (timelineWidth / timelineLength)) + (currentSVI.Width / 2), (timelineHeight / 2) - 2);
currentSVI.Opacity = .7;
currentSVI.ContainerManipulationCompleted += new ContainerManipulationCompletedEventHandler(tourEventSVI_ContainerManipulationCompleted);
currentSVI.PreviewTouchUp += new EventHandler<TouchEventArgs>(tourEventSVI_PreviewTouchUp);
currentSVI.PreviewMouseUp += new MouseButtonEventHandler(tourEventSVI_PreviewTouchUp);
currentSVI.PreviewMouseDown += tourEventSVI_PreviewMouseDown;
DependencyPropertyDescriptor dpd1 = DependencyPropertyDescriptor.FromProperty(ScatterViewItem.CenterProperty, typeof(ScatterViewItem));
dpd1.AddValueChanged(currentSVI, tourEventCenterChanged);
tourEventInfo currentAnimInfo = new tourEventInfo();
currentAnimInfo.timelineInfoStruct = timelineInfoStruct;
currentAnimInfo.beginTime = beginTime;
currentAnimInfo.tourEvent = tourEvent;
currentAnimInfo.centerY = (timelineHeight / 2) - 2;
currentAnimInfo.centerX = (beginTime * (timelineWidth / timelineLength)) + (currentSVI.Width / 2);
currentAnimInfo.originalLoc = beginTime * (timelineWidth / timelineLength);
Rectangle r = new Rectangle();
r.Width = currentSVI.Width;
r.Height = currentSVI.Height;
Timeline timeline = timelineInfoStruct.timeline;
if (tourEvent != null)
{
LinearGradientBrush fadeInBrush = new LinearGradientBrush();
fadeInBrush.StartPoint = new Point(0, 0);
fadeInBrush.EndPoint = new Point(1, 0);
fadeInBrush.GradientStops.Add(new GradientStop(Colors.Transparent, 0.0));
fadeInBrush.GradientStops.Add(new GradientStop((Color)System.Windows.Media.ColorConverter.ConvertFromString("#245c4f"), 0.7));
fadeInBrush.GradientStops.Add(new GradientStop((Color)System.Windows.Media.ColorConverter.ConvertFromString("#245c4f"), 1.0));
LinearGradientBrush fadeOutBrush = new LinearGradientBrush();
fadeOutBrush.StartPoint = new Point(0, 0);
fadeOutBrush.EndPoint = new Point(1, 0);
fadeOutBrush.GradientStops.Add(new GradientStop(Colors.Transparent, 1.0));
fadeOutBrush.GradientStops.Add(new GradientStop((Color)System.Windows.Media.ColorConverter.ConvertFromString("#245c4f"), 0.0));
fadeOutBrush.GradientStops.Add(new GradientStop((Color)System.Windows.Media.ColorConverter.ConvertFromString("#245c4f"), 0.3));
switch (tourEvent.type)
{
case TourEvent.Type.fadeInMedia:
tourSystem.registerDockableItem((tourEvent as FadeInMediaEvent).media, timeline);
r.Fill = fadeInBrush;
break;
case TourEvent.Type.fadeOutMedia:
tourSystem.registerDockableItem((tourEvent as FadeOutMediaEvent).media, timeline);
r.Fill = fadeOutBrush;
break;
case TourEvent.Type.zoomMedia:
tourSystem.registerDockableItem((tourEvent as ZoomMediaEvent).media, timeline);
r.Fill = (Brush)(new BrushConverter().ConvertFrom("#245c4f"));
break;
case TourEvent.Type.fadeInPath:
r.Fill = fadeInBrush;
break;
case TourEvent.Type.fadeOutPath:
r.Fill = fadeOutBrush;
break;
case TourEvent.Type.fadeInHighlight:
r.Fill = fadeInBrush;
break;
case TourEvent.Type.fadeOutHighlight:
r.Fill = fadeOutBrush;
break;
case TourEvent.Type.zoomMSI:
tourSystem.registerMSI((tourEvent as ZoomMSIEvent).msi, timeline);
r.Fill = (Brush)(new BrushConverter().ConvertFrom("#245c4f"));
break;
default:
r.Fill = (Brush)(new BrushConverter().ConvertFrom("#245c4f"));
break;
}
}
else
{
r.Fill = (Brush)(new BrushConverter().ConvertFrom("#245c4f"));
}
currentSVI.Content = r;
currentAnimInfo.r = r;
currentSVI.Tag = currentAnimInfo;
if (tourEvent == null)
currentSVI.IsManipulationEnabled = false;
currentSVI.PreviewMouseWheel +=new MouseWheelEventHandler(currentSVI_PreviewMouseWheel);
currentSVI.SizeChanged += new SizeChangedEventHandler(tourEventSVI_SizeChanged);
timelineSV.Items.Add(currentSVI);
}
public void addTimelineAndEventPostInit(Timeline timeline, BiDictionary<double, TourEvent> tourTL_dict, String title, TourEvent te, double beginTime, double duration)
{
TourAuthoringUI.timelineInfo tli = addTimeline(timeline, tourTL_dict, title, getNextPos());
addTourEvent(tli, te, tli.lengthSV, beginTime, duration);
timelineCount += 1;
updateTLSize();
}
public void addAudioEvent(timelineInfo timelineInfoStruct, TourEvent tourEvent, ScatterView timelineSV, double beginTime, double duration)
{
ScatterViewItem currentSVI = new ScatterViewItem();
currentSVI.MinWidth = 10; // don't want it to disappear, but still need it to be touchable (even if resolution is as low as 1024 x 768)
currentSVI.MinHeight = 10;
currentSVI.Width = duration * (timelineWidth / timelineLength);
currentSVI.Height = timelineHeight - 7;
currentSVI.Background = new SolidColorBrush(Colors.Transparent);
currentSVI.Orientation = 0;
currentSVI.CanRotate = false;
currentSVI.Deceleration = double.NaN; // disables inertia
currentSVI.Center = new Point((beginTime * (timelineWidth / timelineLength)) + (currentSVI.Width / 2), (timelineHeight / 2) - 2);
currentSVI.Opacity = .7;
currentSVI.ContainerManipulationCompleted += new ContainerManipulationCompletedEventHandler(tourAudioEventSVI_ContainerManipulationCompleted);
currentSVI.PreviewTouchUp += new EventHandler<TouchEventArgs>(tourEventSVI_PreviewTouchUp);
currentSVI.PreviewMouseUp += new MouseButtonEventHandler(tourEventSVI_PreviewTouchUp);
currentSVI.PreviewTouchUp += new EventHandler<TouchEventArgs>(tourAudioEventSVI_PreviewTouchUp);
currentSVI.PreviewMouseUp += new MouseButtonEventHandler(tourAudioEventSVI_PreviewTouchUp);
currentSVI.SizeChanged += new SizeChangedEventHandler(tourEventSVI_SizeChanged);
currentSVI.PreviewMouseWheel += new MouseWheelEventHandler(currentAudioSVI_PreviewMouseWheel);
DependencyPropertyDescriptor dpd1 = DependencyPropertyDescriptor.FromProperty(ScatterViewItem.CenterProperty, typeof(ScatterViewItem));
dpd1.AddValueChanged(currentSVI, tourAudioEventCenterChanged);
tourEventInfo currentAnimInfo = new tourEventInfo();
currentAnimInfo.timelineInfoStruct = timelineInfoStruct;
currentAnimInfo.beginTime = beginTime;
currentAnimInfo.tourEvent = tourEvent;
currentAnimInfo.centerY = (timelineHeight / 2) - 2;
currentAnimInfo.centerX = (beginTime * (timelineWidth / timelineLength)) + (currentSVI.Width / 2);
currentAnimInfo.originalLoc = beginTime * (timelineWidth / timelineLength);
Rectangle r = new Rectangle();
r.Width = currentSVI.Width;
r.Height = currentSVI.Height;
r.Fill = (Brush)(new BrushConverter().ConvertFrom("#245c4f"));
currentSVI.Content = r;
currentAnimInfo.r = r;
currentSVI.Tag = currentAnimInfo;
timelineSV.Items.Add(currentSVI);
}
/// <summary>
/// Adding of animations for each TourEvent during loading of tourDict --> tourStoryboard
/// </summary>
/// <param name="tourParallelTL"></param>
/// <param name="tourEvent"></param>
/// <param name="timerCount"></param>
public void addAnim(TourParallelTL tourParallelTL, TourEvent tourEvent, double timerCount)
{
switch (tourEvent.type)
{
case TourEvent.Type.fadeInMedia:
FadeInMediaEvent fadeInMediaEvent = (FadeInMediaEvent)tourEvent;
// used to use MSI points, but now using screen points -- see artwork mode documentation in Google Doc
Point mediaPoint = new Point();
mediaPoint.X = fadeInMediaEvent.fadeInMediaToScreenPointX;
mediaPoint.Y = fadeInMediaEvent.fadeInMediaToScreenPointY;
double initialScale = fadeInMediaEvent.absoluteScale;
DockableItem fadeInMediaItem = fadeInMediaEvent.media;
fadeInMediaItem.ApplyAnimationClock(DockableItem.CenterProperty, null);
fadeInMediaItem.Center = mediaPoint;
fadeInMediaItem.Width = fadeInMediaItem.image.Source.Width * initialScale;
fadeInMediaItem.Height = fadeInMediaItem.image.Source.Height * initialScale;
fadeInMediaItem.Orientation = 0;
DoubleAnimation fadeInMediaWidth = new DoubleAnimation(fadeInMediaItem.Width, fadeInMediaItem.Width, new Duration(TimeSpan.FromSeconds(0.0)));
Storyboard.SetTarget(fadeInMediaWidth, fadeInMediaItem);
Storyboard.SetTargetProperty(fadeInMediaWidth, new PropertyPath(DockableItem.WidthProperty));
fadeInMediaWidth.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeInMediaWidth);
DoubleAnimation fadeInMediaHeight = new DoubleAnimation(fadeInMediaItem.Height, fadeInMediaItem.Height, new Duration(TimeSpan.FromSeconds(0.0)));
Storyboard.SetTarget(fadeInMediaHeight, fadeInMediaItem);
Storyboard.SetTargetProperty(fadeInMediaHeight, new PropertyPath(DockableItem.HeightProperty));
fadeInMediaHeight.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeInMediaHeight);
PointAnimation fadeInMediaCenter = new PointAnimation(fadeInMediaItem.Center, fadeInMediaItem.Center, new Duration(TimeSpan.FromSeconds(0.0)));
Storyboard.SetTarget(fadeInMediaCenter, fadeInMediaItem);
Storyboard.SetTargetProperty(fadeInMediaCenter, new PropertyPath(DockableItem.CenterProperty));
fadeInMediaCenter.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeInMediaCenter);
ObjectAnimationUsingKeyFrames fadeInMediaAnim_vis = new ObjectAnimationUsingKeyFrames();
fadeInMediaAnim_vis.Duration = new TimeSpan(0, 0, 0);
DiscreteObjectKeyFrame fadeInMediaAnim_vis_kf1 = new DiscreteObjectKeyFrame(Visibility.Visible, new TimeSpan(0, 0, 0));
fadeInMediaAnim_vis.KeyFrames.Add(fadeInMediaAnim_vis_kf1);
Storyboard.SetTarget(fadeInMediaAnim_vis, fadeInMediaItem);
Storyboard.SetTargetProperty(fadeInMediaAnim_vis, new PropertyPath(DockableItem.VisibilityProperty));
fadeInMediaAnim_vis.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeInMediaAnim_vis);
DoubleAnimation fadeInMediaAnim = new DoubleAnimation(0.0, 1.0, new Duration(TimeSpan.FromSeconds(fadeInMediaEvent.duration)));
Storyboard.SetTarget(fadeInMediaAnim, fadeInMediaItem);
Storyboard.SetTargetProperty(fadeInMediaAnim, new PropertyPath(DockableItem.OpacityProperty));
fadeInMediaAnim.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeInMediaAnim);
break;
case TourEvent.Type.fadeOutMedia:
FadeOutMediaEvent fadeOutMediaEvent = (FadeOutMediaEvent)tourEvent;
DockableItem fadeOutMediaItem = fadeOutMediaEvent.media;
fadeOutMediaItem.ApplyAnimationClock(DockableItem.CenterProperty, null);
DoubleAnimation fadeOutMediaAnim = new DoubleAnimation(1.0, 0.0, new Duration(TimeSpan.FromSeconds(fadeOutMediaEvent.duration)));
Storyboard.SetTarget(fadeOutMediaAnim, fadeOutMediaItem);
Storyboard.SetTargetProperty(fadeOutMediaAnim, new PropertyPath(DockableItem.OpacityProperty));
fadeOutMediaAnim.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeOutMediaAnim);
ObjectAnimationUsingKeyFrames fadeOutMediaAnim_vis = new ObjectAnimationUsingKeyFrames();
fadeOutMediaAnim_vis.Duration = new TimeSpan(0, 0, 0);
DiscreteObjectKeyFrame fadeOutMediaAnim_vis_kf1 = new DiscreteObjectKeyFrame(Visibility.Hidden, new TimeSpan(0, 0, 0));
fadeOutMediaAnim_vis.KeyFrames.Add(fadeOutMediaAnim_vis_kf1);
Storyboard.SetTarget(fadeOutMediaAnim_vis, fadeOutMediaItem);
Storyboard.SetTargetProperty(fadeOutMediaAnim_vis, new PropertyPath(DockableItem.VisibilityProperty));
fadeOutMediaAnim_vis.BeginTime = TimeSpan.FromSeconds(timerCount + fadeOutMediaEvent.duration);
tourParallelTL.Children.Add(fadeOutMediaAnim_vis);
break;
case TourEvent.Type.zoomMedia:
ZoomMediaEvent zoomMediaEvent = (ZoomMediaEvent)tourEvent;
DockableItem zoomMediaItem = zoomMediaEvent.media;
zoomMediaItem.ApplyAnimationClock(DockableItem.CenterProperty, null);
double targetMediaScale = zoomMediaEvent.absoluteScale;
DoubleAnimation zoomWidth = new DoubleAnimation(zoomMediaItem.image.Source.Width * targetMediaScale, new Duration(TimeSpan.FromSeconds(zoomMediaEvent.duration)));
Storyboard.SetTarget(zoomWidth, zoomMediaItem);
Storyboard.SetTargetProperty(zoomWidth, new PropertyPath(DockableItem.WidthProperty));
zoomWidth.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(zoomWidth);
DoubleAnimation zoomHeight = new DoubleAnimation(zoomMediaItem.image.Source.Height * targetMediaScale, new Duration(TimeSpan.FromSeconds(zoomMediaEvent.duration)));
Storyboard.SetTarget(zoomHeight, zoomMediaItem);
Storyboard.SetTargetProperty(zoomHeight, new PropertyPath(DockableItem.HeightProperty));
zoomHeight.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(zoomHeight);
// used to use MSI points, but now using screen points -- see artwork mode documentation in Google Doc
Point zoomEndPoint = new Point();
zoomEndPoint.X = zoomMediaEvent.zoomMediaToScreenPointX;
zoomEndPoint.Y = zoomMediaEvent.zoomMediaToScreenPointY;
PointAnimation zoomMediaPan = new PointAnimation(zoomEndPoint, new Duration(TimeSpan.FromSeconds(zoomMediaEvent.duration)), FillBehavior.HoldEnd);
Storyboard.SetTarget(zoomMediaPan, zoomMediaItem);
Storyboard.SetTargetProperty(zoomMediaPan, new PropertyPath(DockableItem.CenterProperty));
zoomMediaPan.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(zoomMediaPan);
break;
case TourEvent.Type.zoomMSI:
ZoomMSIEvent zoomMSIEvent = (ZoomMSIEvent)tourEvent;
double targetMSIScale = zoomMSIEvent.absoluteScale;
Point zoomToMSIPoint = new Point(zoomMSIEvent.zoomToMSIPointX, zoomMSIEvent.zoomToMSIPointY);
// new
ZoomableCanvas zoomMSI_canvas = zoomMSIEvent.msi.GetZoomableCanvas;
targetMSIScale = zoomMSIEvent.msi.ClampTargetScale(targetMSIScale);
Point targetOffset = new Point(zoomToMSIPoint.X, zoomToMSIPoint.Y);
PointAnimation zoomMSI_pan = new PointAnimation(targetOffset, new Duration(TimeSpan.FromSeconds(zoomMSIEvent.duration)));
Storyboard.SetTarget(zoomMSI_pan, zoomMSI_canvas);
Storyboard.SetTargetProperty(zoomMSI_pan, new PropertyPath(ZoomableCanvas.OffsetProperty));
zoomMSI_pan.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(zoomMSI_pan);
DoubleAnimation zoomMSI_scale = new DoubleAnimation(targetMSIScale, new Duration(TimeSpan.FromSeconds(zoomMSIEvent.duration)));
zoomMSI_scale.CurrentStateInvalidated += new EventHandler(ZoomMSI_scale_CurrentStateInvalidated);
Storyboard.SetTarget(zoomMSI_scale, zoomMSI_canvas);
Storyboard.SetTargetProperty(zoomMSI_scale, new PropertyPath(ZoomableCanvas.ScaleProperty));
zoomMSI_scale.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(zoomMSI_scale);
break;
case TourEvent.Type.fadeInPath:
FadeInPathEvent fadeInPathEvent = (FadeInPathEvent)tourEvent;
// used to use MSI points, but now using screen points -- see artwork mode documentation in Google Doc
SurfaceInkCanvas fadeInPathItem = fadeInPathEvent.inkCanvas;
fadeInPathItem.Opacity = 0.0;
ObjectAnimationUsingKeyFrames fadeInPathAnim_vis = new ObjectAnimationUsingKeyFrames();
fadeInPathAnim_vis.Duration = new TimeSpan(0, 0, 0);
DiscreteObjectKeyFrame fadeInPathAnim_vis_kf1 = new DiscreteObjectKeyFrame(Visibility.Visible, new TimeSpan(0, 0, 0));
fadeInPathAnim_vis.KeyFrames.Add(fadeInPathAnim_vis_kf1);
Storyboard.SetTarget(fadeInPathAnim_vis, fadeInPathItem);
Storyboard.SetTargetProperty(fadeInPathAnim_vis, new PropertyPath(DockableItem.VisibilityProperty));
fadeInPathAnim_vis.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeInPathAnim_vis);
fadeInPathAnim_vis.FillBehavior = FillBehavior.Stop;
DoubleAnimation fadeInPathAnim = new DoubleAnimation(0.0, 1.0, new Duration(TimeSpan.FromSeconds(fadeInPathEvent.duration)));
Storyboard.SetTarget(fadeInPathAnim, fadeInPathItem);
Storyboard.SetTargetProperty(fadeInPathAnim, new PropertyPath(DockableItem.OpacityProperty));
fadeInPathAnim.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeInPathAnim);
//fadeInPathAnim.FillBehavior = FillBehavior.Stop;
break;
case TourEvent.Type.fadeOutPath:
FadeOutPathEvent fadeOutPathEvent = (FadeOutPathEvent)tourEvent;
SurfaceInkCanvas fadeOutPathItem = fadeOutPathEvent.inkCanvas;
DoubleAnimation fadeOutPathAnim = new DoubleAnimation(1.0, 0.0, new Duration(TimeSpan.FromSeconds(fadeOutPathEvent.duration)));
Storyboard.SetTarget(fadeOutPathAnim, fadeOutPathItem);
Storyboard.SetTargetProperty(fadeOutPathAnim, new PropertyPath(DockableItem.OpacityProperty));
fadeOutPathAnim.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeOutPathAnim);
ObjectAnimationUsingKeyFrames fadeOutPathAnim_vis = new ObjectAnimationUsingKeyFrames();
fadeOutPathAnim_vis.Duration = new TimeSpan(0, 0, 0);
DiscreteObjectKeyFrame fadeOutPathAnim_vis_kf1 = new DiscreteObjectKeyFrame(Visibility.Hidden, new TimeSpan(0, 0, 0));
fadeOutPathAnim_vis.KeyFrames.Add(fadeOutPathAnim_vis_kf1);
Storyboard.SetTarget(fadeOutPathAnim_vis, fadeOutPathItem);
Storyboard.SetTargetProperty(fadeOutPathAnim_vis, new PropertyPath(DockableItem.VisibilityProperty));
fadeOutPathAnim_vis.BeginTime = TimeSpan.FromSeconds(timerCount + fadeOutPathEvent.duration);
tourParallelTL.Children.Add(fadeOutPathAnim_vis);
break;
case TourEvent.Type.fadeInHighlight:
FadeInHighlightEvent fadeInHighlightEvent = (FadeInHighlightEvent)tourEvent;
// used to use MSI points, but now using screen points -- see artwork mode documentation in Google Doc
SurfaceInkCanvas fadeInHighlightItem = fadeInHighlightEvent.inkCanvas;
fadeInHighlightItem.Opacity = 0.0;
ObjectAnimationUsingKeyFrames fadeInHighlightAnim_vis = new ObjectAnimationUsingKeyFrames();
fadeInHighlightAnim_vis.Duration = new TimeSpan(0, 0, 0);
DiscreteObjectKeyFrame fadeInHighlightAnim_vis_kf1 = new DiscreteObjectKeyFrame(Visibility.Visible, new TimeSpan(0, 0, 0));
fadeInHighlightAnim_vis.KeyFrames.Add(fadeInHighlightAnim_vis_kf1);
Storyboard.SetTarget(fadeInHighlightAnim_vis, fadeInHighlightItem);
Storyboard.SetTargetProperty(fadeInHighlightAnim_vis, new PropertyPath(DockableItem.VisibilityProperty));
fadeInHighlightAnim_vis.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeInHighlightAnim_vis);
fadeInHighlightAnim_vis.FillBehavior = FillBehavior.Stop;
DoubleAnimation fadeInHighlightAnim = new DoubleAnimation(0.0, fadeInHighlightEvent.opacity, new Duration(TimeSpan.FromSeconds(fadeInHighlightEvent.duration)));
Storyboard.SetTarget(fadeInHighlightAnim, fadeInHighlightItem);
Storyboard.SetTargetProperty(fadeInHighlightAnim, new PropertyPath(DockableItem.OpacityProperty));
fadeInHighlightAnim.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeInHighlightAnim);
break;
case TourEvent.Type.fadeOutHighlight:
FadeOutHighlightEvent fadeOutHighlightEvent = (FadeOutHighlightEvent)tourEvent;
SurfaceInkCanvas fadeOutHighlightItem = fadeOutHighlightEvent.inkCanvas;
DoubleAnimation fadeOutHighlightAnim = new DoubleAnimation(fadeOutHighlightEvent.opacity, 0.0, new Duration(TimeSpan.FromSeconds(fadeOutHighlightEvent.duration)));
Storyboard.SetTarget(fadeOutHighlightAnim, fadeOutHighlightItem);
Storyboard.SetTargetProperty(fadeOutHighlightAnim, new PropertyPath(DockableItem.OpacityProperty));
fadeOutHighlightAnim.BeginTime = TimeSpan.FromSeconds(timerCount);
tourParallelTL.Children.Add(fadeOutHighlightAnim);
ObjectAnimationUsingKeyFrames fadeOutHighlightAnim_vis = new ObjectAnimationUsingKeyFrames();
fadeOutHighlightAnim_vis.Duration = new TimeSpan(0, 0, 0);
DiscreteObjectKeyFrame fadeOutHighlightAnim_vis_kf1 = new DiscreteObjectKeyFrame(Visibility.Hidden, new TimeSpan(0, 0, 0));
fadeOutHighlightAnim_vis.KeyFrames.Add(fadeOutHighlightAnim_vis_kf1);
Storyboard.SetTarget(fadeOutHighlightAnim_vis, fadeOutHighlightItem);
Storyboard.SetTargetProperty(fadeOutHighlightAnim_vis, new PropertyPath(DockableItem.VisibilityProperty));
fadeOutHighlightAnim_vis.BeginTime = TimeSpan.FromSeconds(timerCount + fadeOutHighlightEvent.duration);
tourParallelTL.Children.Add(fadeOutHighlightAnim_vis);
break;
default:
break;
}
}