Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / 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
- PenThread.cs
- Line.cs
- IsolatedStoragePermission.cs
- SHA1Managed.cs
- cookiecontainer.cs
- ComEventsMethod.cs
- ResourceProviderFactory.cs
- UnsafeNativeMethods.cs
- StringConverter.cs
- MergeFailedEvent.cs
- MetadataItemCollectionFactory.cs
- XPathBinder.cs
- ImpersonateTokenRef.cs
- Resources.Designer.cs
- PeerReferralPolicy.cs
- QueryOptionExpression.cs
- EntityContainerRelationshipSet.cs
- Terminate.cs
- WebPartHelpVerb.cs
- SiteMapDataSource.cs
- HttpCookieCollection.cs
- EventProviderWriter.cs
- ThicknessKeyFrameCollection.cs
- DataTableMapping.cs
- ParseNumbers.cs
- DataGridRelationshipRow.cs
- KeyValuePair.cs
- ComPlusDiagnosticTraceRecords.cs
- DBAsyncResult.cs
- LoginUtil.cs
- DataGridViewCellCollection.cs
- WorkflowDesignerMessageFilter.cs
- ArrayTypeMismatchException.cs
- DataPointer.cs
- TableHeaderCell.cs
- QilXmlReader.cs
- TextAutomationPeer.cs
- WinInetCache.cs
- InternalConfigRoot.cs
- SystemIPv6InterfaceProperties.cs
- RadioButtonList.cs
- TypeElement.cs
- DBCommandBuilder.cs
- EditorZoneBase.cs
- Encoder.cs
- dbdatarecord.cs
- TerminateWorkflow.cs
- LineBreakRecord.cs
- EdmEntityTypeAttribute.cs
- Condition.cs
- WindowInteropHelper.cs
- MetadataCollection.cs
- StorageBasedPackageProperties.cs
- TextRangeEditLists.cs
- DesignerActionVerbItem.cs
- NetSectionGroup.cs
- Vector3DAnimation.cs
- SpellerStatusTable.cs
- XPathDocumentBuilder.cs
- ObjectDataSourceStatusEventArgs.cs
- Variant.cs
- ControlBindingsCollection.cs
- BindingMemberInfo.cs
- AesManaged.cs
- Rect3DConverter.cs
- mongolianshape.cs
- sqlinternaltransaction.cs
- XmlSerializer.cs
- ObjRef.cs
- WebZoneDesigner.cs
- Inflater.cs
- TableRow.cs
- DynamicDocumentPaginator.cs
- HTTP_SERVICE_CONFIG_URLACL_KEY.cs
- JsonWriterDelegator.cs
- XMLSyntaxException.cs
- PlacementWorkspace.cs
- AttributeQuery.cs
- PolicyImporterElement.cs
- Rect3DConverter.cs
- BStrWrapper.cs
- ByteAnimationBase.cs
- EntityViewGenerationAttribute.cs
- QueryBranchOp.cs
- BigInt.cs
- SemanticResultKey.cs
- PnrpPermission.cs
- MemberMemberBinding.cs
- SerialPort.cs
- UnsignedPublishLicense.cs
- VariableQuery.cs
- ObjectCloneHelper.cs
- PerformanceCountersElement.cs
- ListControlConvertEventArgs.cs
- EncryptedData.cs
- MenuCommandsChangedEventArgs.cs
- CodeNamespace.cs
- Message.cs
- WebPartZoneCollection.cs
- SettingsPropertyWrongTypeException.cs