ApplicationContext.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / WinForms / Managed / System / WinForms / ApplicationContext.cs / 1305376 / ApplicationContext.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Windows.Forms { 
    using System; 
    using System.Diagnostics;
    using System.ComponentModel; 

    /// 
    /// 
    ///    ApplicationContext provides contextual information about an application 
    ///    thread. Specifically this allows an application author to redifine what
    ///    circurmstances cause a message loop to exit. By default the application 
    ///    context listens to the close event on the mainForm, then exits the 
    ///    thread's message loop.
    ///  
    public class ApplicationContext : IDisposable {
        Form mainForm;
        object userData;
 
        /// 
        ///  
        ///     Creates a new ApplicationContext with no mainForm. 
        /// 
        public ApplicationContext() : this(null) { 
        }

        /// 
        ///  
        ///     Creates a new ApplicationContext with the specified mainForm.
        ///     If OnMainFormClosed is not overriden, the thread's message 
        ///     loop will be terminated when mainForm is closed. 
        /// 
        public ApplicationContext(Form mainForm) { 
            this.MainForm = mainForm;
        }

        ///  
        ~ApplicationContext() {
            Dispose(false); 
        } 

        ///  
        /// 
        ///     Determines the mainForm for this context. This may be changed
        ///     at anytime.
        ///     If OnMainFormClosed is not overriden, the thread's message 
        ///     loop will be terminated when mainForm is closed.
        ///  
        public Form MainForm { 
            get {
                return mainForm; 
            }
            set {
                EventHandler onClose = new EventHandler(OnMainFormDestroy);
                if (mainForm != null) { 
                    mainForm.HandleDestroyed -= onClose;
                } 
 
                mainForm = value;
 
                if (mainForm != null) {
                    mainForm.HandleDestroyed += onClose;
                }
            } 
        }
 
        ///  
        [
        SRCategory(SR.CatData), 
        Localizable(false),
        Bindable(true),
        SRDescription(SR.ControlTagDescr),
        DefaultValue(null), 
        TypeConverter(typeof(StringConverter)),
        ] 
        public object Tag { 
            get {
                return userData; 
            }
            set {
                userData = value;
            } 
        }
 
        ///  
        /// 
        ///     Is raised when the thread's message loop should be terminated. 
        ///     This is raised by calling ExitThread.
        /// 
        public event EventHandler ThreadExit;
 
        /// 
        ///  
        ///     Disposes the context. This should dispose the mainForm. This is 
        ///     called immediately after the thread's message loop is terminated.
        ///     Application will dispose all forms on this thread by default. 
        /// 
        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this); 
        }
 
        ///  
        protected virtual void Dispose(bool disposing) {
            if (disposing) { 
                if (mainForm != null) {
                    if (!mainForm.IsDisposed) {
                        mainForm.Dispose();
                    } 
                    mainForm = null;
                } 
            } 
        }
 
        /// 
        /// 
        ///     Causes the thread's message loop to be terminated. This
        ///     will call ExitThreadCore. 
        /// 
        public void ExitThread() { 
            ExitThreadCore(); 
        }
 
        /// 
        /// 
        ///     Causes the thread's message loop to be terminated.
        ///  
        protected virtual void ExitThreadCore() {
            if (ThreadExit != null) { 
                ThreadExit(this, EventArgs.Empty); 
            }
        } 

        /// 
        /// 
        ///     Called when the mainForm is closed. The default implementation 
        ///     of this will call ExitThreadCore.
        ///  
        protected virtual void OnMainFormClosed(object sender, EventArgs e) { 
            ExitThreadCore();
        } 

        /// 
        ///     Called when the mainForm is closed. The default implementation
        ///     of this will call ExitThreadCore. 
        /// 
        private void OnMainFormDestroy(object sender, EventArgs e) { 
            Form form = (Form)sender; 
            if (!form.RecreatingHandle) {
                form.HandleDestroyed -= new EventHandler(OnMainFormDestroy); 
                OnMainFormClosed(sender, e);
            }
        }
    } 
}
 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

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