Code:
/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / wpf / src / Framework / System / Windows / Navigation / PageFunction.cs / 1 / PageFunction.cs
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description:
// PageFunctions are the "atom" of Structured Navigation,
// this is the base element class from which the developer derives
// from to enable returning results to a caller.
//
// History:
// ??/10/01: michdav Created
// 05/09/03: marka Moved over to WCP dir. Filled in comments and created generic based class
// 04/29/04: sujalp Style enabled
// 05/13/04: sujalp Moved most of the code to PageFunctionBase
//
//---------------------------------------------------------------------------
using System;
using System.Diagnostics;
using System.Windows.Controls;
using MS.Internal.AppModel;
namespace System.Windows.Navigation
{
///
/// Abstract base class for the generic PageFunction class.
///
public abstract class PageFunctionBase : Page
{
#region Constructors
///
/// PageFunctionBase constructor
///
protected PageFunctionBase()
{
// Make a new GUID for this ID, set the parent ID to 0-0-0-0-0
PageFunctionId = Guid.NewGuid();
ParentPageFunctionId = Guid.Empty;
}
#endregion Constructors
#region Public Properties
///
/// When set to true, the pagefunction with this property set and all child page functions will get removed from the journal.
/// This allows easy building of "transactioned" UI. If a series of steps have been completed, and it doesn't make sense to hit the back button and submit that transaction again,
/// setting this property enables those series of steps to be removed from the journal.
///
///
/// Examples abound of "transactioned UI" buying a book from an ecommerce application, selling stock, creating a user account.
///
public bool RemoveFromJournal
{
get
{
return _fRemoveFromJournal;
}
set
{
_fRemoveFromJournal = value;
}
}
#endregion Public Properties
#region Protected Methods
///
/// This method is called when a PageFunction is first navigated to.
/// It is not called when a Pagefunction resumes.
///
///
/// Typically a developer will write some initialization code in their Start method,
/// or they may decide to invoke a child PageFunction.
///
protected virtual void Start()
{
}
/*
///
/// To be used by derived classes to raise strongly types return events. Must be overriden.
///
// protected abstract void RaiseTypedReturnEvent(Delegate d, object returnEventArgs);
*/
#endregion Protected Methods
#region Internal Methods
// An internal method which is used to invoke the protected Start() method by
// other parts of the PageFunction code base.
internal void CallStart()
{
Start();
}
///
/// A Pagefunction calls this method to signal that it is completed and the ReturnEventArgs
/// will be supplied to the listener on Return ( and that listener will be unsuspended).
///
internal void _OnReturnUnTyped(object o)
{
if (_finish != null)
{
_finish(this, o);
}
}
internal void _AddEventHandler(Delegate d)
{
// This is where the parent-child relationship is established. If
// PageFunction A attaches one of its methods to PageFunction B's
// Return event, then A must be B's parent.
PageFunctionBase parent = d.Target as PageFunctionBase;
if (parent != null)
{
ParentPageFunctionId = parent.PageFunctionId;
}
_returnHandler = Delegate.Combine(_returnHandler, d);
}
internal void _RemoveEventHandler(Delegate d)
{
_returnHandler = Delegate.Remove(_returnHandler, d);
}
internal void _DetachEvents()
{
_returnHandler = null;
}
//
// Raise the event on the _returnHandler
//
internal void _OnFinish(object returnEventArgs)
{
RaiseTypedEventArgs args = new RaiseTypedEventArgs(_returnHandler, returnEventArgs);
RaiseTypedEvent(this, args);
//RaiseTypedReturnEvent(_returnHandler, returnEventArgs);
}
#endregion Internal Methods
#region Internal Properties
///
/// This is the GUID for this PageFunction. It will be used as its childrens'
/// ParentPageFunctionId.
///
internal Guid PageFunctionId
{
get { return _pageFunctionId; }
set { _pageFunctionId = value; }
}
///
/// If this PageFunction is a child PageFunction, this will be the GUID of its
/// parent PageFunction. If this is Guid.Empty, then the parent is NOT a
/// PageFunction.
///
internal Guid ParentPageFunctionId
{
get { return _parentPageFunctionId; }
set { _parentPageFunctionId = value; }
}
internal Delegate _Return
{
get { return _returnHandler; }
}
///
/// Whether the PF is being resumed after a child PF returns OR due to journal navigation
/// (Go Back/Fwd)
///
internal bool _Resume
{
get { return _resume; }
set { _resume = value; }
}
internal ReturnEventSaver _Saver
{
get { return _saverInfo; }
set { _saverInfo = value; }
}
#endregion Internal Properties
#region Internal Events
//
// The FinishEventHandler is used to communicate between the NavigationService and the ending Pagefunction
//
internal FinishEventHandler FinishHandler
{
get { return _finish; }
set { _finish = value; }
}
internal event EventToRaiseTypedEvent RaiseTypedEvent;
#endregion
#region Private Fields
private Guid _pageFunctionId;
private Guid _parentPageFunctionId;
private bool _fRemoveFromJournal = true; // new default, to make PFs behave more like functions
private bool _resume;
private ReturnEventSaver _saverInfo; // keeps track of Parent caller's Return Event Info
private FinishEventHandler _finish;
private Delegate _returnHandler; // the delegate for the Return event
#endregion Private Fields
}
internal delegate void EventToRaiseTypedEvent(PageFunctionBase sender, RaiseTypedEventArgs args);
internal class RaiseTypedEventArgs : System.EventArgs
{
internal RaiseTypedEventArgs(Delegate d, object o)
{
D = d;
O = o;
}
internal Delegate D;
internal Object O;
}
///
/// A callback handler used to receive a ReturnEventArgs of type T
///
public delegate void ReturnEventHandler(object sender, ReturnEventArgs e);
///
/// PageFunctions are the "atom" of Structured Navigation,
/// this is the base element class from which the developer derives
/// from to enable returning results to a caller.
///
///
/// Right now Pagefunctions are non-cls compliant owing to their use of generics. It is expected in the LH timeframe that
/// all CLS languages will support generics.
///
public class PageFunction : PageFunctionBase
{
#region Constructors
///
/// Pagefunction constructor
///
public PageFunction()
{
RaiseTypedEvent += new EventToRaiseTypedEvent(RaiseTypedReturnEvent);
}
#endregion Constructors
#region Protected Methods
///
/// A Pagefunction calls this method to signal that it is completed and the ReturnEventArgs
/// will be supplied to the listener on Return ( and that listener will be unsuspended).
///
protected virtual void OnReturn(ReturnEventArgs e)
{
_OnReturnUnTyped(e);
}
///
/// Used to raise a strongly typed return event. Sealed since nobody should have the need to override as
/// all derived types of this generic type will automatically get the strongly typed version from this
/// generic version.
///
internal void RaiseTypedReturnEvent(PageFunctionBase b, RaiseTypedEventArgs args)
{
Delegate d = args.D;
object returnEventArgs = args.O;
if (d != null)
{
ReturnEventArgs ra = returnEventArgs as ReturnEventArgs;
Debug.Assert((returnEventArgs == null) || (ra != null));
ReturnEventHandler eh = d as ReturnEventHandler;
Debug.Assert(eh != null);
eh(this, ra);
}
}
#endregion Protected Methods
#region Public Events
///
/// This is the event to which a caller will listen to get results returned.
///
public event ReturnEventHandler Return
{
// We need to provide a way to surface out
// the listeners to the event
// So we override add/remove and keep track of it here.
add
{
_AddEventHandler((Delegate)value);
}
remove
{
_RemoveEventHandler((Delegate)value);
}
}
#endregion Public Events
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//----------------------------------------------------------------------------
//
//
// Copyright (C) Microsoft Corporation. All rights reserved.
//
//
// Description:
// PageFunctions are the "atom" of Structured Navigation,
// this is the base element class from which the developer derives
// from to enable returning results to a caller.
//
// History:
// ??/10/01: michdav Created
// 05/09/03: marka Moved over to WCP dir. Filled in comments and created generic based class
// 04/29/04: sujalp Style enabled
// 05/13/04: sujalp Moved most of the code to PageFunctionBase
//
//---------------------------------------------------------------------------
using System;
using System.Diagnostics;
using System.Windows.Controls;
using MS.Internal.AppModel;
namespace System.Windows.Navigation
{
///
/// Abstract base class for the generic PageFunction class.
///
public abstract class PageFunctionBase : Page
{
#region Constructors
///
/// PageFunctionBase constructor
///
protected PageFunctionBase()
{
// Make a new GUID for this ID, set the parent ID to 0-0-0-0-0
PageFunctionId = Guid.NewGuid();
ParentPageFunctionId = Guid.Empty;
}
#endregion Constructors
#region Public Properties
///
/// When set to true, the pagefunction with this property set and all child page functions will get removed from the journal.
/// This allows easy building of "transactioned" UI. If a series of steps have been completed, and it doesn't make sense to hit the back button and submit that transaction again,
/// setting this property enables those series of steps to be removed from the journal.
///
///
/// Examples abound of "transactioned UI" buying a book from an ecommerce application, selling stock, creating a user account.
///
public bool RemoveFromJournal
{
get
{
return _fRemoveFromJournal;
}
set
{
_fRemoveFromJournal = value;
}
}
#endregion Public Properties
#region Protected Methods
///
/// This method is called when a PageFunction is first navigated to.
/// It is not called when a Pagefunction resumes.
///
///
/// Typically a developer will write some initialization code in their Start method,
/// or they may decide to invoke a child PageFunction.
///
protected virtual void Start()
{
}
/*
///
/// To be used by derived classes to raise strongly types return events. Must be overriden.
///
// protected abstract void RaiseTypedReturnEvent(Delegate d, object returnEventArgs);
*/
#endregion Protected Methods
#region Internal Methods
// An internal method which is used to invoke the protected Start() method by
// other parts of the PageFunction code base.
internal void CallStart()
{
Start();
}
///
/// A Pagefunction calls this method to signal that it is completed and the ReturnEventArgs
/// will be supplied to the listener on Return ( and that listener will be unsuspended).
///
internal void _OnReturnUnTyped(object o)
{
if (_finish != null)
{
_finish(this, o);
}
}
internal void _AddEventHandler(Delegate d)
{
// This is where the parent-child relationship is established. If
// PageFunction A attaches one of its methods to PageFunction B's
// Return event, then A must be B's parent.
PageFunctionBase parent = d.Target as PageFunctionBase;
if (parent != null)
{
ParentPageFunctionId = parent.PageFunctionId;
}
_returnHandler = Delegate.Combine(_returnHandler, d);
}
internal void _RemoveEventHandler(Delegate d)
{
_returnHandler = Delegate.Remove(_returnHandler, d);
}
internal void _DetachEvents()
{
_returnHandler = null;
}
//
// Raise the event on the _returnHandler
//
internal void _OnFinish(object returnEventArgs)
{
RaiseTypedEventArgs args = new RaiseTypedEventArgs(_returnHandler, returnEventArgs);
RaiseTypedEvent(this, args);
//RaiseTypedReturnEvent(_returnHandler, returnEventArgs);
}
#endregion Internal Methods
#region Internal Properties
///
/// This is the GUID for this PageFunction. It will be used as its childrens'
/// ParentPageFunctionId.
///
internal Guid PageFunctionId
{
get { return _pageFunctionId; }
set { _pageFunctionId = value; }
}
///
/// If this PageFunction is a child PageFunction, this will be the GUID of its
/// parent PageFunction. If this is Guid.Empty, then the parent is NOT a
/// PageFunction.
///
internal Guid ParentPageFunctionId
{
get { return _parentPageFunctionId; }
set { _parentPageFunctionId = value; }
}
internal Delegate _Return
{
get { return _returnHandler; }
}
///
/// Whether the PF is being resumed after a child PF returns OR due to journal navigation
/// (Go Back/Fwd)
///
internal bool _Resume
{
get { return _resume; }
set { _resume = value; }
}
internal ReturnEventSaver _Saver
{
get { return _saverInfo; }
set { _saverInfo = value; }
}
#endregion Internal Properties
#region Internal Events
//
// The FinishEventHandler is used to communicate between the NavigationService and the ending Pagefunction
//
internal FinishEventHandler FinishHandler
{
get { return _finish; }
set { _finish = value; }
}
internal event EventToRaiseTypedEvent RaiseTypedEvent;
#endregion
#region Private Fields
private Guid _pageFunctionId;
private Guid _parentPageFunctionId;
private bool _fRemoveFromJournal = true; // new default, to make PFs behave more like functions
private bool _resume;
private ReturnEventSaver _saverInfo; // keeps track of Parent caller's Return Event Info
private FinishEventHandler _finish;
private Delegate _returnHandler; // the delegate for the Return event
#endregion Private Fields
}
internal delegate void EventToRaiseTypedEvent(PageFunctionBase sender, RaiseTypedEventArgs args);
internal class RaiseTypedEventArgs : System.EventArgs
{
internal RaiseTypedEventArgs(Delegate d, object o)
{
D = d;
O = o;
}
internal Delegate D;
internal Object O;
}
///
/// A callback handler used to receive a ReturnEventArgs of type T
///
public delegate void ReturnEventHandler(object sender, ReturnEventArgs e);
///
/// PageFunctions are the "atom" of Structured Navigation,
/// this is the base element class from which the developer derives
/// from to enable returning results to a caller.
///
///
/// Right now Pagefunctions are non-cls compliant owing to their use of generics. It is expected in the LH timeframe that
/// all CLS languages will support generics.
///
public class PageFunction : PageFunctionBase
{
#region Constructors
///
/// Pagefunction constructor
///
public PageFunction()
{
RaiseTypedEvent += new EventToRaiseTypedEvent(RaiseTypedReturnEvent);
}
#endregion Constructors
#region Protected Methods
///
/// A Pagefunction calls this method to signal that it is completed and the ReturnEventArgs
/// will be supplied to the listener on Return ( and that listener will be unsuspended).
///
protected virtual void OnReturn(ReturnEventArgs e)
{
_OnReturnUnTyped(e);
}
///
/// Used to raise a strongly typed return event. Sealed since nobody should have the need to override as
/// all derived types of this generic type will automatically get the strongly typed version from this
/// generic version.
///
internal void RaiseTypedReturnEvent(PageFunctionBase b, RaiseTypedEventArgs args)
{
Delegate d = args.D;
object returnEventArgs = args.O;
if (d != null)
{
ReturnEventArgs ra = returnEventArgs as ReturnEventArgs;
Debug.Assert((returnEventArgs == null) || (ra != null));
ReturnEventHandler eh = d as ReturnEventHandler;
Debug.Assert(eh != null);
eh(this, ra);
}
}
#endregion Protected Methods
#region Public Events
///
/// This is the event to which a caller will listen to get results returned.
///
public event ReturnEventHandler Return
{
// We need to provide a way to surface out
// the listeners to the event
// So we override add/remove and keep track of it here.
add
{
_AddEventHandler((Delegate)value);
}
remove
{
_RemoveEventHandler((Delegate)value);
}
}
#endregion Public Events
}
}
// 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
- DataGridViewLayoutData.cs
- mactripleDES.cs
- BaseDataBoundControl.cs
- URL.cs
- DateTimeValueSerializerContext.cs
- XmlSchemaAnyAttribute.cs
- GeometryConverter.cs
- webclient.cs
- ComponentEditorForm.cs
- PropertyDescriptorComparer.cs
- PeerTransportSecuritySettings.cs
- RequiredFieldValidator.cs
- MissingSatelliteAssemblyException.cs
- WebScriptServiceHostFactory.cs
- SByteConverter.cs
- Color.cs
- XamlTypeMapper.cs
- MinimizableAttributeTypeConverter.cs
- FindCriteria11.cs
- DBSchemaRow.cs
- SmtpFailedRecipientsException.cs
- DiscoveryDocumentSearchPattern.cs
- HashStream.cs
- dbdatarecord.cs
- StartUpEventArgs.cs
- EncoderBestFitFallback.cs
- SortQueryOperator.cs
- EventLogPermissionAttribute.cs
- ObjectItemNoOpAssemblyLoader.cs
- SiteMapDataSource.cs
- IIS7WorkerRequest.cs
- ConfigurationValidatorBase.cs
- LicenseProviderAttribute.cs
- CatalogZoneBase.cs
- _ContextAwareResult.cs
- ListView.cs
- XmlCompatibilityReader.cs
- CodeGroup.cs
- SqlCharStream.cs
- SafeArrayRankMismatchException.cs
- ReversePositionQuery.cs
- ContainerSelectorBehavior.cs
- JsonFormatReaderGenerator.cs
- TypeForwardedFromAttribute.cs
- EnvelopedPkcs7.cs
- WebSysDescriptionAttribute.cs
- WorkflowApplicationCompletedException.cs
- TimeSpanFormat.cs
- DateTimeOffsetConverter.cs
- SystemParameters.cs
- DiscoveryRequestHandler.cs
- LineGeometry.cs
- DataTemplateKey.cs
- WebDisplayNameAttribute.cs
- TextOutput.cs
- OneOf.cs
- InputDevice.cs
- RoutedEvent.cs
- QilChoice.cs
- CommandValueSerializer.cs
- HashCodeCombiner.cs
- iisPickupDirectory.cs
- SqlBuilder.cs
- XmlText.cs
- TreeView.cs
- DataControlExtensions.cs
- ScalarType.cs
- XmlNodeChangedEventArgs.cs
- UndoEngine.cs
- EntityDataSourceChangedEventArgs.cs
- RetrieveVirtualItemEventArgs.cs
- BuildResult.cs
- BaseTemplateBuildProvider.cs
- MonthChangedEventArgs.cs
- ArraySubsetEnumerator.cs
- CellTreeNode.cs
- AssertSection.cs
- CompiledXpathExpr.cs
- TransactionProxy.cs
- SystemKeyConverter.cs
- PeerToPeerException.cs
- PropertyReference.cs
- MdImport.cs
- NetStream.cs
- Point.cs
- GenericEnumConverter.cs
- ParameterCollection.cs
- IFormattable.cs
- MethodAccessException.cs
- WhitespaceSignificantCollectionAttribute.cs
- XhtmlMobileTextWriter.cs
- WizardForm.cs
- BamlLocalizableResource.cs
- StrokeSerializer.cs
- DataMemberFieldEditor.cs
- WorkflowDefinitionContext.cs
- DbExpressionRules.cs
- _LocalDataStore.cs
- AuthStoreRoleProvider.cs
- PropertyPath.cs