Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / Orcas / SP / wpf / src / Core / CSharp / System / Windows / Media / Animation / ClockController.cs / 1 / ClockController.cs
//------------------------------------------------------------------------------
// Microsoft Windows Client Platform
// Copyright (c) Microsoft Corporation, 2004
//
// File: ClockController.cs
//-----------------------------------------------------------------------------
using MS.Internal;
using MS.Utility;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Threading;
using System.Windows;
using System.Windows.Media.Composition;
using System.Windows.Markup;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows.Media.Animation
{
///
/// Provides access to interactive methods for a given Clock.
///
public sealed class ClockController : DispatcherObject
{
#region Data
private Clock _owner;
#endregion // Data
#region Constructors
///
/// Creates an instance of ClockController.
///
///
/// The Clock that owns this collection.
///
internal ClockController(Clock owner)
{
Debug.Assert(owner != null, "ClockController must have a non-null owner.");
_owner = owner;
}
#endregion // Constructors
#region Methods
///
/// Schedules a begin at the next tick.
///
///
/// If the Clock is not enabled then this method has no effect.
///
/// This method has no effect on the timing tree until the next time
/// a tick is processed. As a side-effect, the appropriate events will also
/// not be raised until then.
///
// Internally, Begin works similarly to Seek, in that it preschedules a seek in
// the Clock to the zero position.
public void Begin()
{
_owner.InternalBegin();
}
///
/// Moves this clock to the end of its active period and then performs
/// whatever behavior is specified by the FillBehavior property.
///
///
/// This method only has an effect if the Clock's CurrentState is ClockState.Active.
/// This method has no effect on the timing tree until the next time
/// a tick is processed. As a side-effect, the appropriate events will also
/// not be raised until then.
///
// Internally, SkipToFill works similarly to Seek, in that it preschedules a seek in
// the Clock to the Fill position.
public void SkipToFill()
{
_owner.InternalSkipToFill();
}
///
/// Pauses the Clock and its children.
///
///
/// This method stops this Clock from moving. As a side effect,
/// the Clocks's children are also paused. The Clock remains
/// paused until one of the following events take place:
///
/// -
/// The Clock is allowed to continue with a call to the
///
/// -
/// The Clock is restarted or ended with a call to the
///
/// -
/// The Clock is restarted due to a scheduled begin time.
///
/// -
/// The Clock is removed from the timing tree.
///
///
///
/// This method has no effect if the Clock is not active, or is currently paused.
///
///
/// Allows a Clock to progress again after a call to
///
/// Resuming a Clock also automatically resumes all of the Clock's children.
///
/// This method has no effect if the Clock is not active and in the paused
/// state. In addition, only a Clock that was previously explicitly paused with
/// a call to
///
/// For more details, see the remarks for the
///
///
/// Seeks a Clock to a new position.
///
///
/// The seek offset, measured in the Clock's simple time frame of
/// reference. The meaning of this parameter depends on the value of the origin parameter.
///
///
/// The meaning of the offset parameter. See the
/// If the Clock is a container, its children's Clocks are also updated accordingly.
///
/// The seek is measured in the Clock's simple time frame of reference, meaning that the
/// actual wall-clock playback time skipped (or replayed) may be different than that specified
/// by the offset parameter, if time manipulations from the Speed, Acceleration or Deceleration
/// properties are in effect for this Clock.
///
/// The seek operation may only span the current simple duration of the Clock. Seeking to a
/// time earlier than the begin time positions the Clock at the begin point, whereas
/// seeking beyond the end simply puts the Clock at the end point.
///
public void Seek(TimeSpan offset, TimeSeekOrigin origin)
{
// IF YOU CHANGE THIS CODE:
// This code is very similar to that in SeekAlignedToLastTick and is duplicated
// in each method so that exceptions will be thrown from the public
// method the user has called. You probably need to change both methods.
if (!TimeEnumHelper.IsValidTimeSeekOrigin(origin))
{
throw new InvalidEnumArgumentException(SR.Get(SRID.Enum_Invalid, "TimeSeekOrigin"));
}
if (origin == TimeSeekOrigin.Duration)
{
Duration duration = _owner.ResolvedDuration;
if (!duration.HasTimeSpan)
{
// Can't seek relative to the Duration if it has been specified as Forever or if
// it has not yet been resolved.
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationIndefinite));
}
else
{
offset = offset + duration.TimeSpan;
}
}
// Any offset greater than zero is OK here. If it's past the effective
// duration it means execute the FillBehavior.
if (offset < TimeSpan.Zero)
{
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationNegative));
}
_owner.InternalSeek(offset);
}
///
/// Process all information that occured until now
///
public void SeekAlignedToLastTick(TimeSpan offset, TimeSeekOrigin origin)
{
// IF YOU CHANGE THIS CODE:
// This code is very similar to that in Seek and is duplicated
// in each method so that exceptions will be thrown from the public
// method the user has called. You probably need to change both methods.
if (!TimeEnumHelper.IsValidTimeSeekOrigin(origin))
{
throw new InvalidEnumArgumentException(SR.Get(SRID.Enum_Invalid, "TimeSeekOrigin"));
}
if (origin == TimeSeekOrigin.Duration)
{
Duration duration = _owner.ResolvedDuration;
if (!duration.HasTimeSpan)
{
// Can't seek relative to the Duration if it has been specified as Forevor or if
// it has not yet been resolved.
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationIndefinite));
}
else
{
offset = offset + duration.TimeSpan;
}
}
// Any offset greater than zero is OK here. If it's past the effective
// duration it means execute the FillBehavior.
if (offset < TimeSpan.Zero)
{
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationNegative));
}
_owner.InternalSeekAlignedToLastTick(offset);
}
///
/// Interactively stops the Clock.
///
///
/// This takes the Clock out of its active or fill period and leaves it
/// in the off state. It may be reactivated with an interactive Begin().
///
public void Stop()
{
_owner.InternalStop();
}
///
/// Interactively moves the Clock into a Completed state, fires Remove event.
///
///
/// This takes the Clock out of its active or fill period and leaves it
/// in the off state. It may be reactivated with an interactive Begin().
///
public void Remove()
{
_owner.InternalRemove();
}
#endregion // Methods
#region Properties
///
/// Returns the Clock controlled by this ClockController class.
///
public Clock Clock
{
get
{
return _owner;
}
}
///
/// Returns or sets the interactive speed for the Clock.
///
public double SpeedRatio
{
get
{
return _owner.InternalGetSpeedRatio();
}
set
{
if (value < 0 || value > double.MaxValue || double.IsNaN(value))
{
throw new ArgumentException(SR.Get(SRID.Timing_InvalidArgFinitePositive), "value");
}
_owner.InternalSetSpeedRatio(value);
}
}
#endregion // Properties
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
// Microsoft Windows Client Platform
// Copyright (c) Microsoft Corporation, 2004
//
// File: ClockController.cs
//-----------------------------------------------------------------------------
using MS.Internal;
using MS.Utility;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Threading;
using System.Windows;
using System.Windows.Media.Composition;
using System.Windows.Markup;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows.Media.Animation
{
///
/// Provides access to interactive methods for a given Clock.
///
public sealed class ClockController : DispatcherObject
{
#region Data
private Clock _owner;
#endregion // Data
#region Constructors
///
/// Creates an instance of ClockController.
///
///
/// The Clock that owns this collection.
///
internal ClockController(Clock owner)
{
Debug.Assert(owner != null, "ClockController must have a non-null owner.");
_owner = owner;
}
#endregion // Constructors
#region Methods
///
/// Schedules a begin at the next tick.
///
///
/// If the Clock is not enabled then this method has no effect.
///
/// This method has no effect on the timing tree until the next time
/// a tick is processed. As a side-effect, the appropriate events will also
/// not be raised until then.
///
// Internally, Begin works similarly to Seek, in that it preschedules a seek in
// the Clock to the zero position.
public void Begin()
{
_owner.InternalBegin();
}
///
/// Moves this clock to the end of its active period and then performs
/// whatever behavior is specified by the FillBehavior property.
///
///
/// This method only has an effect if the Clock's CurrentState is ClockState.Active.
/// This method has no effect on the timing tree until the next time
/// a tick is processed. As a side-effect, the appropriate events will also
/// not be raised until then.
///
// Internally, SkipToFill works similarly to Seek, in that it preschedules a seek in
// the Clock to the Fill position.
public void SkipToFill()
{
_owner.InternalSkipToFill();
}
///
/// Pauses the Clock and its children.
///
///
/// This method stops this Clock from moving. As a side effect,
/// the Clocks's children are also paused. The Clock remains
/// paused until one of the following events take place:
///
/// -
/// The Clock is allowed to continue with a call to the
///
/// -
/// The Clock is restarted or ended with a call to the
///
/// -
/// The Clock is restarted due to a scheduled begin time.
///
/// -
/// The Clock is removed from the timing tree.
///
///
///
/// This method has no effect if the Clock is not active, or is currently paused.
///
///
/// Allows a Clock to progress again after a call to
///
/// Resuming a Clock also automatically resumes all of the Clock's children.
///
/// This method has no effect if the Clock is not active and in the paused
/// state. In addition, only a Clock that was previously explicitly paused with
/// a call to
///
/// For more details, see the remarks for the
///
///
/// Seeks a Clock to a new position.
///
///
/// The seek offset, measured in the Clock's simple time frame of
/// reference. The meaning of this parameter depends on the value of the origin parameter.
///
///
/// The meaning of the offset parameter. See the
/// If the Clock is a container, its children's Clocks are also updated accordingly.
///
/// The seek is measured in the Clock's simple time frame of reference, meaning that the
/// actual wall-clock playback time skipped (or replayed) may be different than that specified
/// by the offset parameter, if time manipulations from the Speed, Acceleration or Deceleration
/// properties are in effect for this Clock.
///
/// The seek operation may only span the current simple duration of the Clock. Seeking to a
/// time earlier than the begin time positions the Clock at the begin point, whereas
/// seeking beyond the end simply puts the Clock at the end point.
///
public void Seek(TimeSpan offset, TimeSeekOrigin origin)
{
// IF YOU CHANGE THIS CODE:
// This code is very similar to that in SeekAlignedToLastTick and is duplicated
// in each method so that exceptions will be thrown from the public
// method the user has called. You probably need to change both methods.
if (!TimeEnumHelper.IsValidTimeSeekOrigin(origin))
{
throw new InvalidEnumArgumentException(SR.Get(SRID.Enum_Invalid, "TimeSeekOrigin"));
}
if (origin == TimeSeekOrigin.Duration)
{
Duration duration = _owner.ResolvedDuration;
if (!duration.HasTimeSpan)
{
// Can't seek relative to the Duration if it has been specified as Forever or if
// it has not yet been resolved.
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationIndefinite));
}
else
{
offset = offset + duration.TimeSpan;
}
}
// Any offset greater than zero is OK here. If it's past the effective
// duration it means execute the FillBehavior.
if (offset < TimeSpan.Zero)
{
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationNegative));
}
_owner.InternalSeek(offset);
}
///
/// Process all information that occured until now
///
public void SeekAlignedToLastTick(TimeSpan offset, TimeSeekOrigin origin)
{
// IF YOU CHANGE THIS CODE:
// This code is very similar to that in Seek and is duplicated
// in each method so that exceptions will be thrown from the public
// method the user has called. You probably need to change both methods.
if (!TimeEnumHelper.IsValidTimeSeekOrigin(origin))
{
throw new InvalidEnumArgumentException(SR.Get(SRID.Enum_Invalid, "TimeSeekOrigin"));
}
if (origin == TimeSeekOrigin.Duration)
{
Duration duration = _owner.ResolvedDuration;
if (!duration.HasTimeSpan)
{
// Can't seek relative to the Duration if it has been specified as Forevor or if
// it has not yet been resolved.
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationIndefinite));
}
else
{
offset = offset + duration.TimeSpan;
}
}
// Any offset greater than zero is OK here. If it's past the effective
// duration it means execute the FillBehavior.
if (offset < TimeSpan.Zero)
{
throw new InvalidOperationException(SR.Get(SRID.Timing_SeekDestinationNegative));
}
_owner.InternalSeekAlignedToLastTick(offset);
}
///
/// Interactively stops the Clock.
///
///
/// This takes the Clock out of its active or fill period and leaves it
/// in the off state. It may be reactivated with an interactive Begin().
///
public void Stop()
{
_owner.InternalStop();
}
///
/// Interactively moves the Clock into a Completed state, fires Remove event.
///
///
/// This takes the Clock out of its active or fill period and leaves it
/// in the off state. It may be reactivated with an interactive Begin().
///
public void Remove()
{
_owner.InternalRemove();
}
#endregion // Methods
#region Properties
///
/// Returns the Clock controlled by this ClockController class.
///
public Clock Clock
{
get
{
return _owner;
}
}
///
/// Returns or sets the interactive speed for the Clock.
///
public double SpeedRatio
{
get
{
return _owner.InternalGetSpeedRatio();
}
set
{
if (value < 0 || value > double.MaxValue || double.IsNaN(value))
{
throw new ArgumentException(SR.Get(SRID.Timing_InvalidArgFinitePositive), "value");
}
_owner.InternalSetSpeedRatio(value);
}
}
#endregion // Properties
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- HttpModuleCollection.cs
- PeerEndPoint.cs
- OrderedDictionaryStateHelper.cs
- CSharpCodeProvider.cs
- SqlDependencyUtils.cs
- MissingManifestResourceException.cs
- InstanceKeyView.cs
- _BufferOffsetSize.cs
- HostAdapter.cs
- Model3D.cs
- SizeConverter.cs
- LineSegment.cs
- DataGridColumn.cs
- DocumentOutline.cs
- ExpressionWriter.cs
- AllMembershipCondition.cs
- HttpRequest.cs
- Expression.DebuggerProxy.cs
- SpeechRecognizer.cs
- InProcStateClientManager.cs
- IntSecurity.cs
- ObjectTokenCategory.cs
- AgileSafeNativeMemoryHandle.cs
- ZipIOCentralDirectoryDigitalSignature.cs
- Int32Collection.cs
- IdentityReference.cs
- Error.cs
- MimeFormatExtensions.cs
- ListViewCommandEventArgs.cs
- DiscoveryMessageSequence11.cs
- AmbiguousMatchException.cs
- LinearGradientBrush.cs
- ColorDialog.cs
- StringPropertyBuilder.cs
- GridViewUpdateEventArgs.cs
- CodeTypeConstructor.cs
- RC2CryptoServiceProvider.cs
- PolyLineSegmentFigureLogic.cs
- StringWriter.cs
- Int32Collection.cs
- GeometryModel3D.cs
- XmlReflectionMember.cs
- xmlsaver.cs
- PEFileReader.cs
- WebConfigurationHostFileChange.cs
- Brushes.cs
- IPipelineRuntime.cs
- QueryStack.cs
- DataTableTypeConverter.cs
- EventHandlerList.cs
- WebPartConnectionsConnectVerb.cs
- FixedStringLookup.cs
- FaultContractInfo.cs
- InvalidOleVariantTypeException.cs
- PkcsMisc.cs
- VirtualPathProvider.cs
- SafeThemeHandle.cs
- IdentityReference.cs
- SqlProvider.cs
- ECDiffieHellman.cs
- SuppressIldasmAttribute.cs
- TagPrefixInfo.cs
- DateTimeConverter.cs
- XmlParserContext.cs
- ToolStripDesignerUtils.cs
- XamlToRtfParser.cs
- __TransparentProxy.cs
- Vertex.cs
- DirectoryGroupQuery.cs
- TextBox.cs
- HttpStreamFormatter.cs
- BlurEffect.cs
- MemoryStream.cs
- DetailsViewRowCollection.cs
- WindowsFormsHost.cs
- XamlDesignerSerializationManager.cs
- WindowsSecurityTokenAuthenticator.cs
- ContentPlaceHolder.cs
- TagNameToTypeMapper.cs
- PipeStream.cs
- ReadOnlyMetadataCollection.cs
- PropertyInformationCollection.cs
- SmtpCommands.cs
- PublisherMembershipCondition.cs
- DriveNotFoundException.cs
- OverflowException.cs
- DetailsViewDeletedEventArgs.cs
- PngBitmapDecoder.cs
- XmlNamespaceMapping.cs
- ControlPropertyNameConverter.cs
- FixedElement.cs
- SqlWorkflowInstanceStore.cs
- GroupStyle.cs
- _AcceptOverlappedAsyncResult.cs
- BuildProviderAppliesToAttribute.cs
- XmlSchemaSimpleTypeList.cs
- DSASignatureFormatter.cs
- CacheAxisQuery.cs
- ObjectStateEntry.cs
- ProfileProvider.cs