PageFunction.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / 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:      [....]     Moved over to WCP dir. Filled in comments and created generic based class 
//  04/29/04:      [....]    Style enabled
//  05/13/04:      [....]    Moved most of the code to PageFunctionBase 
// 
//---------------------------------------------------------------------------
 
using System;
using System.Windows.Threading;
using System.Collections;
using System.Diagnostics; 
using System.IO;
using System.Globalization; 
using System.Runtime.Serialization.Formatters.Binary; 
using System.Security.Permissions;
 
using MS.Internal;
using MS.Internal.AppModel;
using MS.Internal.Utility;
using MS.Utility; 

using System.Windows; 
using System.Windows.Controls; 
using System.Windows.Media;
using System.Windows.Markup; 

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

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK