Window.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / Orcas / QFE / wpf / src / Framework / System / Windows / Window.cs / 1 / Window.cs

                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// Description: Implements the base Avalon Window class 
// 
// History
//  06/12/02    MihaiI      Created 
//  06/12/03    hamidm      Added functionalities and moved to wcp tree
//
//---------------------------------------------------------------------------
using System; 
using System.Windows;
using System.Windows.Automation.Peers; 
using System.ComponentModel; 
using System.Windows.Threading;
using System.Windows.Media; 
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Markup;
using System.Windows.Input; 
using System.Windows.Documents;
using System.Windows.Interop; 
using System.Windows.Media.Imaging; 

using MS.Win32; 
using MS.Internal;
using MS.Internal.AppModel;
using MS.Internal.KnownBoxes;
using MS.Internal.PresentationFramework;                   // SecurityHelper 
using MS.Utility;
 
using System.Runtime.InteropServices; 
using System.Diagnostics;
using System.Security; 
using System.Security.Permissions;
using System.Collections;

//In order to avoid generating warnings about unknown message numbers and 
//unknown pragmas when compiling your C# source code with the actual C# compiler,
//you need to disable warnings 1634 and 1691. (Presharp Documentation) 
#pragma warning disable 1634, 1691 

namespace System.Windows 
{
    /// 
    ///
    ///  
    /// 
    /// Critical: In PartialTrust we want to not allow creation or inheritance of window 
    /// PublicOk: This has inheritance demand and constructor is blocked in partial trust 
    /// 
    [Localizability(LocalizationCategory.Ignore)] 
    [UIPermissionAttribute(SecurityAction.InheritanceDemand,Window=UIPermissionWindow.AllWindows)]
    public class Window: ContentControl, IWindowService
    {
        //--------------------------------------------------- 
        //
        // Constructors 
        // 
        //---------------------------------------------------
        #region Constructors 

        /// 
        ///     Initializes the dependency ids of this class
        ///  
        static Window()
        { 
            HeightProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnHeightChanged))); 
            MinHeightProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnMinHeightChanged)));
            MaxHeightProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnMaxHeightChanged))); 
            WidthProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnWidthChanged)));
            MinWidthProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnMinWidthChanged)));
            MaxWidthProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnMaxWidthChanged)));
 
            // override VisibilityProperty Metadata. For Window, Visibility.Visible means the Window is visible.
            // Visibility.Hidden and Visibility.Collapsed mean the Window is not visible. 
            // Visibility.Hidden and Visibility.Collapsed are treated the same. 
            // We default to Visibility.Collapsed since RenderSize returns (0,0) only for
            // collapsed elements and not for hidden. We want to return (0,0) when window is 
            // never shown.
            VisibilityProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(Visibility.Collapsed, new PropertyChangedCallback(_OnVisibilityChanged), new CoerceValueCallback(CoerceVisibility)));

            IsTabStopProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(BooleanBoxes.FalseBox)); 
            KeyboardNavigation.DirectionalNavigationProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(KeyboardNavigationMode.Cycle));
            KeyboardNavigation.TabNavigationProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(KeyboardNavigationMode.Cycle)); 
            KeyboardNavigation.ControlTabNavigationProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(KeyboardNavigationMode.Cycle)); 
            FocusManager.IsFocusScopeProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox));
 
            DefaultStyleKeyProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(typeof(Window)));
            _dType = DependencyObjectType.FromSystemTypeInternal(typeof(Window));

            FlowDirectionProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnFlowDirectionChanged))); 
            //
 
            RenderTransformProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(Transform.Identity, new PropertyChangedCallback(_OnRenderTransformChanged), new CoerceValueCallback(CoerceRenderTransform))); 
            ClipToBoundsProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(BooleanBoxes.FalseBox, new PropertyChangedCallback(_OnClipToBoundsChanged), new CoerceValueCallback(CoerceClipToBounds)));
        } 

        /// 
        ///     Constructs a window object
        ///  
        /// 
        ///     Automatic determination of current Dispatcher. Use alternative constructor 
        ///     that accepts a Dispatcher for best performance. 
        ///
        ///     Initializes the Width/Height, Top/Left properties to use windows 
        ///     default. Updates Application object properties if inside app.
        ///
        ///     Also, window style is set to WS_CHILD inside CreateSourceWindow
        ///     for browser hosted case 
        ///
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        ///  
        /// 
        /// Critical: We explicitly demand all window permission currently Window creation is not available in Internet Zone. 
        ///     _ownerHandle and _dialogOwnerHandle fields are initialized when this .ctor gets called.
        /// PublicOK: The only scenarios where we're currently going to enable creation of Windows is with RootBrowserWindow.
        ///     This code has a demand.
        ///  
        [SecurityCritical]
        public Window() 
        { 
            SecurityHelper.DemandUnmanagedCode();
            _inTrustedSubWindow = false; 
            Initialize();
        }

        ///  
        ///     Constructs a window object
        ///  
        ///  
        ///     Automatic determination of current Dispatcher. Use alternative constructor
        ///     that accepts a Dispatcher for best performance. 
        ///
        ///     Initializes the Width/Height, Top/Left properties to use windows
        ///     default. Updates Application object properties if inside app.
        /// 
        ///     Also, window style is set to WS_CHILD inside CreateSourceWindow
        ///     for browser hosted case 
        /// 
        ///     This method currently requires full trust to run.
        ///  
        /// 
        /// Critical - The only scenarios where we're currently going to enable creation of Windows is with RootBrowserWindow.
        ///     Do not ever call it from anywhere else. This is only for RBW scenario!!!
        ///     _ownerHandle and _dialogOwnerHandle fields are initialized when this .ctor gets called. 
        /// 
        [SecurityCritical] 
        internal Window(bool inRbw):base() 
        {
            if (inRbw) 
            {
                _inTrustedSubWindow = true;
            }
            else 
            {
                _inTrustedSubWindow = false; 
                SecurityHelper.DemandUnmanagedCode(); 
            }
            Initialize(); 

        }
        #endregion Constructors
 
        //----------------------------------------------------
        // 
        // Public Methods 
        //
        //--------------------------------------------------- 
        #region Public Methods

        /// 
        ///     Show the window 
        /// 
        ///  
        ///     Calling Show on window is the same as setting the 
        ///     Visibility property to Visibility.Visible.
        ///  
        public void Show()
        {
            VerifyContextAndObjectState();
            VerifyCanShow(); 
            VerifyNotClosing();
            VerifyConsistencyWithAllowsTransparency(); 
 
            // Update the property value only.  Do not do anything further in
            // _OnVisibilityInvalidate since we will synchronously call ShowHelper 
            // from here.
            UpdateVisibilityProperty(Visibility.Visible);

            ShowHelper(BooleanBoxes.TrueBox); 
        }
 
        ///  
        ///     Hide the window
        ///  
        /// 
        ///     Calling Hide on window is the same as setting the
        ///     Visibility property to Visibility.Hidden
        ///      
        public void Hide()
        { 
            VerifyContextAndObjectState(); 

            if (_disposed == true) 
            {
                return;
            }
 
            // set Visibility to Hidden even if _isVisible is false since
            // _isVisible can be false b/c of Visibility = Collapsed and Hide() 
            // should change Visibility to Hidden. 
            //
            // Update the property value only.  Do not do anything further in 
            // _OnVisibilityInvalidate since we will synchronously call ShowHelper
            // from here.
            UpdateVisibilityProperty(Visibility.Hidden);
 
            ShowHelper(BooleanBoxes.FalseBox);
        } 
 
        /// 
        ///     Closes the Window 
        /// 
        /// 
        ///     Window fires the Closing event before it closes. If the
        ///     user cancels the closing event, the window is not closed. 
        ///     Otherwise, the window is closed and the Closed event is
        ///     fired. 
        /// 
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API.
        ///  
        ///
        ///  PublicOK: This API Demands UIPermission with AllWindows access
        ///  Critical: calls critical code (InternalClose)
        /// 
        [SecurityCritical ]
        public void Close() 
        { 
            // this call ends up throwing an exception if Close
            // is not allowed 
            VerifyApiSupported();
            SecurityHelper.DemandUIWindowPermission();
            VerifyContextAndObjectState();
            InternalClose(false, false); 
        }
 
        ///  
        ///     Kick off the Window's MoveWindow loop
        ///  
        /// 
        ///     To enable custom chrome on Windows. First check if this is the Left MouseButton.
        ///     Will throw exception if it's not, otherwise, will kick off the Windows's MoveWindow loop.
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        /// 
        /// 
        ///     Critical - as this code performs an elevation via the calls to SendMessage. 
        ///     PublicOk - as there is a demand for all windows permission.
        ///     We explicitly demand unamnaged code permission - as there's no valid scenario for this in the SEE. 
        ///
        [SecurityCritical]
        public void DragMove()
        { 

            // this call ends up throwing an exception if dragmove 
            // is not allowed 
            VerifyApiSupported();
            SecurityHelper.DemandUIWindowPermission(); 
            VerifyContextAndObjectState();

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            {
                return; 
            } 

            // Mouse.LeftButton actually reflects the primary button user is using. 
            // So we don't need to check whether the button has been swapped here.
            if (Mouse.LeftButton == MouseButtonState.Pressed)
            {
                if (WindowState == WindowState.Normal) 
                {
                    // SendMessage's return value is dependent on the message send.  WM_SYSCOMMAND 
                    // and WM_LBUTTONUP return value just signify whether the WndProc handled the 
                    // message or not, so they are not interesting
#pragma warning disable 6523 
                    UnsafeNativeMethods.SendMessage( CriticalHandle, NativeMethods.WM_SYSCOMMAND, (IntPtr)NativeMethods.SC_MOUSEMOVE, IntPtr.Zero);
                    UnsafeNativeMethods.SendMessage( CriticalHandle, NativeMethods.WM_LBUTTONUP, IntPtr.Zero, IntPtr.Zero);
#pragma warning restore 6523
                } 
            }
            else 
            { 
                throw new InvalidOperationException(SR.Get(SRID.DragMoveFail));
            } 

        }

        ///  
        ///     Shows the window as a modal window
        ///  
        /// bool? 
        /// 
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        /// 
        /// 
        /// Critical: This code causes unmamanged code elevation in the call to GetWindowLong
        ///           which has a SUC on it. There is also a call to SetFocus which returns a window handle. 
        ///           It also accesses _dialogOwnerHandle, _dialogPreviousActiveHandle and _ownerHandle.
        /// PublicOK: There is a demand in the code 
        ///  
        [SecurityCritical ]
        public Nullable ShowDialog() 
        {

            // this call ends up throwing an exception if dragmove
            // is not allowed 
            VerifyApiSupported();
            SecurityHelper.DemandUnrestrictedUIPermission(); 
            VerifyContextAndObjectState(); 
            VerifyCanShow();
            VerifyNotClosing(); 
            VerifyConsistencyWithAllowsTransparency();

            if ( _isVisible == true )
            { 
                throw new InvalidOperationException(SR.Get(SRID.ShowDialogOnVisible));
            } 
            else if ( _showingAsDialog == true ) 
            {
                throw new InvalidOperationException(SR.Get(SRID.ShowDialogOnModal)); 
            }

            _dialogOwnerHandle = _ownerHandle;
 
            // verify owner handle is window
            if (UnsafeNativeMethods.IsWindow( new HandleRef( null, _dialogOwnerHandle ) ) != true) 
            { 
                _dialogOwnerHandle = IntPtr.Zero;
            } 


            // remember the current active window;
            // this is used when dialog creation fails or dialog closes, we set the active window back to this one. 
            _dialogPreviousActiveHandle = UnsafeNativeMethods.GetActiveWindow();
 
            // if owner window is not specified, we get the current active window on this thread's 
            // message queue as the owner.
            if (_dialogOwnerHandle == IntPtr.Zero) 
            {
                _dialogOwnerHandle = _dialogPreviousActiveHandle;
            }
 
            // If hwndOwner == HWNDESKTOP, change it to NULL.  This way the desktop
            // (and all its children) won't be disabled if the dialog is modal. 
            if ((_dialogOwnerHandle != IntPtr.Zero) && 
                (_dialogOwnerHandle == UnsafeNativeMethods.GetDesktopWindow()))
            { 
                _dialogOwnerHandle = IntPtr.Zero;
            }

            // if dialog owner is not null, get the top level window (case where dialog owner is a 
            // child window), and save it's state regarding enabled and active window
            if (_dialogOwnerHandle != IntPtr.Zero) 
            { 
                // get the top level window from the dialog owner handle
                int style = 0; 

                while (_dialogOwnerHandle != IntPtr.Zero)
                {
                    style = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, _dialogOwnerHandle), NativeMethods.GWL_STYLE); 
                    if ((style & NativeMethods.WS_CHILD) == NativeMethods.WS_CHILD)
                    { 
                        _dialogOwnerHandle = UnsafeNativeMethods.GetParent(new HandleRef(null, _dialogOwnerHandle)); 
                    }
                    else 
                    {
                        break;
                    }
                } 
            }
 
            Debug.Assert(_threadWindowHandles == null, "_threadWindowHandles must be null before enumerating the thread windows"); 

            // NOTE: hamidm -- 01/22/04 
            // _threadWindowHandles is created here.  This reference is nulled out in EnableThreadWindows
            // when it is called with a true parameter.  Please do not null it out anywhere else.
            // EnableThreadWindow(true) is called when dialog is going away.  Once dialog is closed and
            // thread windows have been enabled, then there no need to keep the array list around. 
            // Please see
            _threadWindowHandles = new ArrayList(); 
            //Get visible and enabled windows in the thread 
            // If the callback function returns true for all windows in the thread, the return value is true.
            // If the callback function returns false on any enumerated window, or if there are no windows 
            // found in the thread, the return value is false.
            // No need for use to actually check the return value.
#pragma warning disable 6523
            UnsafeNativeMethods.EnumThreadWindows(SafeNativeMethods.GetCurrentThreadId(), 
                                                  new NativeMethods.EnumThreadWindowsCallback(ThreadWindowsCallback),
                                                  NativeMethods.NullHandleRef); 
#pragma warning enable 6523 
            //disable those windows
            EnableThreadWindows(false); 

            IntPtr hWndCapture = SafeNativeMethods.GetCapture();
            if (hWndCapture != IntPtr.Zero)
            { 
                //
                // NOTE: hamidm -- 7/14/04 
                // EnableWindow(false) (called from EnableThreadWindows(false) 
                // sends WM_CANCELMODE to the window, so we don't need
                // to send it again.  However, if we change our impl 
                // of dialog such that we don't disable all windows on the
                // thread, then we would need this call. Keeping this code here
                // until we finish the Dialog task # 18498
 
                // UnsafeNativeMethods.SendMessage(hWndCapture,
                //                                NativeMethods.WM_CANCELMODE, 
                //                                IntPtr.Zero, 
                //                                IntPtr.Zero);
 
                // hWndCapture = UnsafeNativeMethods.GetCapture();
                // if (hWndCapture != IntPtr.Zero)
                // {
                    // PS # 862892 
                    // WCP: Investigate whether ReleaseCapture is needed in ShowDialog
                    SafeNativeMethods.ReleaseCapture(); 
                // } 
            }
 
            // Ensure Dialog RoutedCommand is registered with CommandManager
            EnsureDialogCommand();

            try 
            {
                _showingAsDialog = true; 
                Show(); 
            }
            catch 
            {
                // NOTE: hamidm 01/22/04
                // See
 

 
 

 



 

 
 

 



 

 
 

                if (_threadWindowHandles != null) 
                {
                    // Some exception case. Re-enable the windows that were disabled
                    EnableThreadWindows(true);
                } 

                // Activate the previously active window. 
                // This code/logic came from User. 
                if ( (_dialogPreviousActiveHandle != IntPtr.Zero) &&
                    (UnsafeNativeMethods.IsWindow(new HandleRef(null, _dialogPreviousActiveHandle)) == true)) 
                {
                    // SetFocus fails if the input hwnd is not a Window or if the Window is not on the
                    // calling thread.
                    // 
                    // Furthermore, this code path is executed when an exception occurs when we try to
                    // show the window.  Here we are doing the minimum possible to restore state of 
                    // the avalon window object.  Hence, if for some reason, we are not able to 
                    // SetFocus to the window that previously had focus, we don't care as that failure
                    // is not important enought to warrant throwing an exception. 
                    UnsafeNativeMethods.TrySetFocus(new HandleRef(null, _dialogPreviousActiveHandle), ref _dialogPreviousActiveHandle);
                }

                // clears _showingAsDialog and accelerators related fields 
                ClearShowKeyboardCueState();
                _showingAsDialog = false; 
 
                // using catch and throw instead of catch(Exception e) throw e;  since the former
                // gives the complete call stack upto the offending method where the exception is thrown 
                throw;
            }
            finally
            { 
                // If the owner window belongs to another thread, the reactivation
                // of the owner may have failed within DestroyWindow().  Therefore, 
                // if the current thread is in the foreground and the owner is not 
                // in the foreground we can safely set the foreground back
                // to the owner. 
#if FIGURE_OUT
                TODO: hamidm  7/18/2003
                PS: 862826
                // WCP Dialog: Figure out what to do when reactivating the owner window 
                // which is in another thread.
                if (_dialogOwnerHandle != IntPtr.Zero) 
                { 
                    if (IsCurrentThreadForeground() &&
                        !IsInForegroundQueue(hwndOwner)) 
                    {
                        NtUserSetForegroundWindow(hwndOwner);
                    }
                } 
#endif //FIGURE_OUT
                _showingAsDialog = false; 
            } 
            return _dialogResult;
        } 


        /// 
        ///     This method tries to activate the Window. 
        /// 
        ///  
        ///     This method calls SetForegroundWindow on the hWnd, thus the rules for SetForegroundWindow 
        ///     apply to this method.
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        /// 
        /// bool -- indicating whether the window was activated or not
        ///
        ///     Critical as this code performs an elevation in the call to SetForegroundWindow. 
        ///     PublicOk - there is a demand in the code. Any caller will require
        ///                     all window code permissions. 
        /// 
        [SecurityCritical]
        public bool Activate() 
        {

            // this call ends up throwing an exception if Activate
            // is not allowed 
            VerifyApiSupported();
            // 
            // Demand AllWindows code permission. 
            // There be a more appropriate less-restrictive permission - but this should suffice for now.
            // 
            SecurityHelper.DemandUIWindowPermission();
            VerifyContextAndObjectState();

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            { 
                return false; 
            }
 
            return UnsafeNativeMethods.SetForegroundWindow(new HandleRef(null, CriticalHandle));
        }
        #region LogicalTree
        ///  
        ///     Returns enumerator to logical children
        ///  
        protected internal override IEnumerator LogicalChildren 
        {
            get 
            {
                // Don't use UIElementCollection because we don't have a reference to content's visual parent;
                // window has style and user can change it.
                return new SingleChildEnumerator(this.Content); 
            }
        } 
 
        #endregion LogicalTree
 
        #region static public method

        /// 
        /// Gets Window in which the given DependecyObject is hosted in. 
        /// 
        /// Returns the Window the given dependencyObject is hosted in. 
        /// Window 
        public static Window GetWindow(DependencyObject dependencyObject)
        { 
            if (dependencyObject == null)
            {
                throw new ArgumentNullException("dependencyObject");
            } 

            // Window.IWindowServiceProperty is an internal inheritable dependency property 
            // Normally this value is set to the root Window element, all the element 
            // inside the window view will get this value through property inheritance mechanism.
 
            return dependencyObject.GetValue(Window.IWindowServiceProperty) as Window;
        }

        #endregion static public method 

        #endregion Public Methods 
        //---------------------------------------------------- 
        //
        // Public Properties 
        //
        //----------------------------------------------------
        #region Public Properties
 
        /// 
        /// DependencyProperty for AllowsTransparency 
        ///  
        public static readonly DependencyProperty AllowsTransparencyProperty =
                DependencyProperty.Register( 
                        "AllowsTransparency",
                        typeof(bool),
                        typeof(Window),
                        new FrameworkPropertyMetadata( 
                                BooleanBoxes.FalseBox,
                                new PropertyChangedCallback(OnAllowsTransparencyChanged), 
                                new CoerceValueCallback(CoerceAllowsTransparency))); 

        ///  
        /// Whether or not the Window uses per-pixel opacity
        /// 
        public bool AllowsTransparency
        { 
            get { return (bool)GetValue(AllowsTransparencyProperty); }
            set { SetValue(AllowsTransparencyProperty, BooleanBoxes.Box(value)); } 
        } 

        private static void OnAllowsTransparencyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
        }

        private static object CoerceAllowsTransparency(DependencyObject d, object value) 
        {
            value = VerifyAccessCoercion(d, value); 
 
            if (!((Window) d).IsSourceWindowNull)
            { 
                throw new InvalidOperationException(SR.Get(SRID.ChangeNotAllowedAfterShow));
            }

            return value; 
        }
 
        ///  
        ///     The DependencyProperty for TitleProperty.
        ///     Flags:              None 
        ///     Default Value:      String.Empty
        /// 
        public static readonly DependencyProperty TitleProperty =
                DependencyProperty.Register("Title", typeof(String), typeof(Window), 
                        new FrameworkPropertyMetadata(String.Empty,
                                new PropertyChangedCallback(_OnTitleChanged)), 
                        new ValidateValueCallback(_ValidateText)); 
        /// 
        ///     The data that will be displayed as the title of the window. 
        ///     Hosts are free to display the title in any manner that they
        ///     want.  For example, the browser may display the title set via
        ///     the Title property somewhere besides the caption bar
        ///  
        [Localizability(LocalizationCategory.Title)]
        public string Title 
        { 
            get
            { 
                VerifyContextAndObjectState();

                return (String)GetValue(TitleProperty);
            } 
            set
            { 
                VerifyContextAndObjectState(); 

                SetValue(TitleProperty, value); 
            }
        }

        ///  
        ///     The DependencyProperty for Icon
        ///     Flags:              None 
        ///     Default Value:      None 
        /// 
        public static readonly DependencyProperty IconProperty = 
                DependencyProperty.Register(
                        "Icon",
                        typeof(ImageSource),
                        typeof(Window), 
                        new FrameworkPropertyMetadata(
                                new PropertyChangedCallback(_OnIconChanged), 
                                new CoerceValueCallback(VerifyAccessCoercion))); 

        ///  
        ///     Sets the Icon of the Window
        /// 
        /// 
        ///     Following is the precedence for displaying the icon: 
        ///
        ///     1) Use ImageSource provided by the Icon property.  If Icon property is 
        ///     null, see 2 below. 
        ///     2) If Icon Property is not set, then use the Application icon
        ///     embedded in the exe.  Querying Icon property returns null. 
        ///     3) If no icon is embedded in the exe, then we set IntPtr.Zero
        ///     as the icon and Win32 displays its default icon.  Querying Icon
        ///     property returns null.
        /// 
        ///     If Icon property is set, Window does not dispose that object when it
        ///     is closed. 
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        /// 
        ///  
        ///     Critical: This code causes icon value to be set. This in turn causes property invalidation
        ///               which will access unsafe native methods.
        ///     PublicOK: There exists a demand , safe to expose
        ///  
        public ImageSource Icon
        { 
            get 
            {
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing
                // Icon is not allowed
                VerifyApiSupported(); 

                return (ImageSource) GetValue(IconProperty); 
            } 

            [SecurityCritical] 
            set
            {
                // this call ends up throwing an exception if accessing
                // Icon is not allowed 
                VerifyApiSupported();
                SecurityHelper.DemandUIWindowPermission(); 
                VerifyContextAndObjectState(); 

                SetValue(IconProperty, value); 
            }
        }

        ///  
        ///     The DependencyProperty for SizeToContentProperty.
        ///     Flags:              None 
        ///     Default Value:      "SizeToContent.Manual" 
        /// 
        public static readonly DependencyProperty SizeToContentProperty = 
                DependencyProperty.Register("SizeToContent",
                        typeof(SizeToContent),
                        typeof(Window),
                        new FrameworkPropertyMetadata( 
                                SizeToContent.Manual,
                                new PropertyChangedCallback(_OnSizeToContentChanged)), 
                        new ValidateValueCallback(_ValidateSizeToContentCallback)); 

        ///  
        /// Auto size Window to its content's size
        /// 
        /// 
        /// 1. SizeToContent can be applied to Width Height independently 
        /// 2. After SizeToContent is set, setting Width/Height does not take affect if that
        ///    dimension is sizing to content. 
        /// 3. SizeToContent is turned off (restored to SizeToContent.Manual) if user starts to 
        ///    interact with window in terms of size
        ///  
        /// 
        /// Default value is SizeToContent.Manual
        /// 
        public SizeToContent SizeToContent 
        {
            get 
            { 
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // SizeToContent is not allowed
                VerifyApiSupported();
 
                return (SizeToContent) GetValue(SizeToContentProperty);
            } 
            set 
            {
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing
                // SizeToContent is not allowed
                VerifyApiSupported(); 

                SetValue(SizeToContentProperty, value); 
            } 
        }
 
        /// 
        /// DependencyProperty for  property.
        /// 
 
        public static readonly DependencyProperty TopProperty =
                Canvas.TopProperty.AddOwner(typeof(Window), 
                        new FrameworkPropertyMetadata( 
                                Double.NaN,
                                new PropertyChangedCallback(_OnTopChanged), 
                                new CoerceValueCallback(CoerceTop)));

        /// 
        ///     Position for Top of the host window 
        /// 
        ///  
        ///     The following values are valid: 
        ///     Positive Doubles: sets the top location to the specified value
        ///     NaN: indicates to use the system default value. This 
        ///     is the default for Top property
        ///     PositiveInfinity, NegativeInfinity: These are invalid inputs.
        /// 
        ///  
        [TypeConverter("System.Windows.LengthConverter, PresentationFramework, Version=" + Microsoft.Internal.BuildInfo.WCP_VERSION + ", Culture=neutral, PublicKeyToken=" + Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_TOKEN + ", Custom=null")]
        public double Top 
        { 
            get
            { 
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing Top
                // is not allowed 
                VerifyApiSupported();
                return (double)GetValue(TopProperty); 
            } 
            set
            { 
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing Top
                // is not allowed 
                VerifyApiSupported();
 
                // we don't do an if check here to see if the new value is the same 
                // as the current Top value b/c the current value maybe as a result
                // of user resizing which means the the local value of Top has not 
                // been written to.  So, if window.Top is explicitly set now we want
                // to write to the local value.  We do make this if check in Top
                // property invalidation callback for optimization
                SetValue(TopProperty, value); 
            }
        } 
 
        /// 
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty LeftProperty =
                Canvas.LeftProperty.AddOwner(typeof(Window),
                        new FrameworkPropertyMetadata( 
                                Double.NaN,
                                new PropertyChangedCallback(_OnLeftChanged), 
                                new CoerceValueCallback(CoerceLeft))); 

        ///  
        ///     Position for Left edge of  coordinate of the host window
        /// 
        /// 
        ///     The following values are valid: 
        ///     Positive Doubles: sets the top location to the specified value
        ///     NaN: indicates to use the system default value. This 
        ///     is the default for Top property 
        ///     PositiveInfinity, NegativeInfinity: These are invalid inputs.
        ///  
        /// 
        [TypeConverter("System.Windows.LengthConverter, PresentationFramework, Version=" + Microsoft.Internal.BuildInfo.WCP_VERSION + ", Culture=neutral, PublicKeyToken=" + Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_TOKEN + ", Custom=null")]
        public double Left
        { 
            get
            { 
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing left 
                // is not allowed
                VerifyApiSupported();
                return (double)GetValue(LeftProperty);
            } 
            set
            { 
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing left 
                // is not allowed
                VerifyApiSupported();

                // we don't do an if check here to see if the new value is the same 
                // as the current Left value b/c the current value maybe as a result
                // of user resizing which means the the local value of Left has not 
                // been written to.  So, if window.Left is explicitly set now we want 
                // to write to the local value.  We do make this if check in Left
                // property invalidation callback for optimization 
                SetValue(LeftProperty, value);
            }
        }
 
        /// 
        ///     This property returns the restoring rectangle of the window.  This information 
        ///     can be used to track a users size and position preferences when the 
        ///     Window is maximized or minimized.
        /// 
        ///     If RestoreBounds is queried before the Window has been shown or after it has
        ///     been closed, it will return Rect.Empty.
        /// 
        ///  
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API.
        ///  
        ///  
        ///     Critical: This code accesses Handle and calls critical method GetNormalRectLogicalUnits
        ///     PublicOK: This code only works under RBW code path , this operation is ok since 
        ///     RBW window is bound to the restrictions of its parent window which is the browser
        /// 

        public Rect RestoreBounds 
        {
            [SecurityCritical ] 
            get 
            {
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing RestoreBounds
                // is not allowed
                VerifyApiSupported(); 

                if (!_inTrustedSubWindow) 
                { 
                    SecurityHelper.DemandUIWindowPermission();
                } 

                // either before calling show or after closing AND
                // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
                if (IsSourceWindowNull || IsCompositionTargetInvalid) 
                {
                    return Rect.Empty; 
                } 

                return GetNormalRectLogicalUnits(CriticalHandle); 
            }
        }

        ///  
        ///     This enum can have following values
        ///         Manual (default) 
        ///         CenterScreen 
        ///         CenterOwner
        /// 
        ///     If the WindowStartupLocation is WindowStartupLocation.Manual then
        ///     Top and Left properites are used to position the window.
        ///     This property is used only before window creation. Once the window is
        ///     created hiding it and showing it will not take this property into account. 
        /// 
        ///  
        ///     WindowStartupLocation is used to position the window only it it is set to 
        ///     WindowStartupLocation.CenterScreen or WindowStartupLocation.CenterOwner,
        ///     otherwise Top/Left is used.  Furthermore, if determining the location 
        ///     of the window is not possible when WindowStartupLocation is set to
        ///     WindowStartupLocation.CenterScreen or WindowStartupLocation.Owner, then
        ///     Top/Left is used instead.
        ///  
        [DefaultValue(WindowStartupLocation.Manual)]
        public WindowStartupLocation WindowStartupLocation 
        { 
            get
            { 
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing
                // WindowStartupLocation is not allowed 
                VerifyApiSupported();
 
                return _windowStartupLocation; 
            }
 
            set
            {
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // WindowStartupLocation is not allowed 
                VerifyApiSupported(); 

                //validate WindowStartupLocation enum 
                if (!IsValidWindowStartupLocation(value))
                {
                    throw new InvalidEnumArgumentException("value", (int)value, typeof( WindowStartupLocation ));
                } 
                _windowStartupLocation = value;
            } 
        } 

        ///  
        ///     The DependencyProperty for ShowInTaskbarProperty.
        ///     Flags:              None
        ///     Default Value:      true
        ///  
        public static readonly DependencyProperty ShowInTaskbarProperty =
                DependencyProperty.Register("ShowInTaskbar", 
                        typeof(bool), 
                        typeof(Window),
                        new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, 
                                new PropertyChangedCallback(_OnShowInTaskbarChanged),
                                new CoerceValueCallback(VerifyAccessCoercion)));

        /// 
        ///     Determines if the window should show up in the system taskbar.
        ///     This also determines if the window appears in the Alt-Tab list. 
        /// 
        public bool ShowInTaskbar
        { 
            get
            {
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // ShowInTaskbar is not allowed 
                VerifyApiSupported(); 

                return (bool) GetValue(ShowInTaskbarProperty); 
            }
            set
            {
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing 
                // ShowInTaskbar is not allowed 
                VerifyApiSupported();
 
                SetValue(ShowInTaskbarProperty, BooleanBoxes.Box(value));
            }
        }
 
        /// 
        ///     The key needed set a read-only property. 
        ///  
        private static readonly DependencyPropertyKey IsActivePropertyKey
            = DependencyProperty.RegisterReadOnly("IsActive", typeof(bool), typeof(Window), 
                                          new FrameworkPropertyMetadata(BooleanBoxes.FalseBox));

        /// 
        ///     The DependencyProperty for IsActive. 
        ///     Flags:              None
        ///     Default Value:      True 
        ///     Read-Only:          true 
        /// 
        public static readonly DependencyProperty IsActiveProperty 
            = IsActivePropertyKey.DependencyProperty;

        /// 
        /// IsActive property. It indicates whether the Window is active. 
        /// The title bar will have the active theme. The active window will be
        /// the topmost of all top-level windows that don't explicitly set the TopMost property or style. 
        /// If a window is active, focus is within the window. 
        /// 
        public bool IsActive 
        {
            get
            {
                VerifyContextAndObjectState(); 
                return (bool)GetValue(IsActiveProperty);
            } 
        } 

        ///  
        ///     This set the owner for the property of the current window.
        ///     If the window has owner and the owner is minimized then
        ///     owned window is also minimized. Owner window can never be
        ///     over owned window. Owned window is NOT modal. So user can 
        ///     still interact with owner window. This property can not be
        ///     set of the top level window. 
        ///  
        ///
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        ///
        ///
        /// Critical - _ownerWindow is accessed, SetParentHandle is called.
        /// PublicOK - get/set protected by Demand's. 
        ///
        [DefaultValue(null)] 
        public Window Owner 
        {
            [SecurityCritical ] 
            get
            {
                // this call ends up throwing an exception if accessing Owner
                // is not allowed 
                VerifyApiSupported();
                SecurityHelper.DemandUIWindowPermission(); 
                VerifyContextAndObjectState(); 
                return _ownerWindow;
            } 
            [SecurityCritical]
            set
            {
                // this call ends up throwing an exception if accessing Owner 
                // is not allowed
                VerifyApiSupported(); 
                SecurityHelper.DemandUIWindowPermission(); 
                VerifyContextAndObjectState();
                if (value == this) 
                {
                    throw new ArgumentException(SR.Get(SRID.CannotSetOwnerToItself));
                }
 
                if ( _showingAsDialog == true )
                { 
                    throw new InvalidOperationException(SR.Get(SRID.CantSetOwnerAfterDialogIsShown)); 
                }
 
                if (value != null && value.IsSourceWindowNull == true)
                {
                    throw new InvalidOperationException(SR.Get(SRID.CantSetOwnerWhosHwndIsNotCreated));
                } 

                if ( _ownerWindow == value ) 
                { 
                    return;
                } 

                // Check to see if value is already a child of this window.
                // If yes, throw Exception
 
                if (value != null)
                { 
                    WindowCollection ownedWindows = OwnedWindows; 
                    for (int i = 0; i < ownedWindows.Count; i++)
                    { 
                        if (ownedWindows[i] == value)
                        {
                            throw new ArgumentException(SR.Get(SRID.CircularOwnerChild, value, this));
                        } 
                    }
                } 
 
                // Update OwnerWindows of the previous owner
                if (_ownerWindow != null) 
                {
                    // using OwnedWindowsInternl b/c we want to modifying the
                    // underlying collection
                    _ownerWindow.OwnedWindowsInternal.Remove(this); 
                }
 
 
                // Update parent handle. If value is null, then make parent
                // handle IntPtr.Zero 
                _ownerWindow = value;
                SetParentHandle(_ownerWindow != null ? _ownerWindow.CriticalHandle: IntPtr.Zero);

                // Update OwnerWindows of the new owner 
                if (_ownerWindow != null)
                { 
                    // using OwnedWindowsInternl b/c we want to modifying the 
                    // underlying collection
                    _ownerWindow.OwnedWindowsInternal.Add(this); 
                }
            }
        }
 
        /// This code checks to see if the owner property is null
        /// True if the window is null , false other wise 
        ///  
        ///     Critical: This code is critical since it acceses owner which is critical data
        ///     TreatAsSafe: Since this exposes no critical data 
        /// 
        private bool IsOwnerNull
        {
            [SecurityCritical,SecurityTreatAsSafe] 
            get
            { 
                return (_ownerWindow == null); 
            }
 
        }
        /// 
        ///     This is a collection of windows that are owned by current window.
        ///  
        // This collection is a copy of the original one to avoid synchronizing issues.
        // DO-NOT USE THIS PROPERY IF YOU MEAN TO MODIFY THE UNDERLYING COLLECTION.  USE 
        // OwnedWindowsInternal PROPERTY FOR MODIFYING THE UNDERLYING DATASTRUCTURE. 
        public WindowCollection OwnedWindows
        { 
            get
            {
                VerifyContextAndObjectState();
                return OwnedWindowsInternal.Clone(); 
            }
        } 
 
        /// 
        /// Sets/gets DialogResult 
        /// 
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), TypeConverter(typeof(DialogResultConverter))]
        public Nullable DialogResult
        { 
            get
            { 
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing 
                // DialogResult is not allowed
                VerifyApiSupported();

                return _dialogResult; 
            }
            set 
            { 
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // DialogResult is not allowed
                VerifyApiSupported();
 
                if (_showingAsDialog == true)
                { 
                    // This value should be set only after the window is created and shown as dialog. 

                    // When _showingAsDialog is set, _sourceWindow must be set too. 
                    Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull cannot be true when _showingAsDialog is true");

                    // 03/03/2006 -- hamidm
                    // Fix for 1388606 Close Dialog Window should not return null 
                    //
                    // According to the new design, setting DialogResult to its current value will not have any effect. 
                    if (_dialogResult != value) 
                    {
                        _dialogResult = value; 

                        // if DialogResult is set from within a Closing event then
                        // the window is in the closing state.  Thus, if we call
                        // Close() again from here we go into an infinite loop. 
                        //
                        // Note: Windows OS bug # 934500 Setting DialogResult 
                        // on the Closing EventHandler of a Dialog causes StackOverFlowException 

                        if(_isClosing == false) 
                        {
                            Close();
                        }
                    } 
                }
                else 
                { 
                    throw new InvalidOperationException(SR.Get(SRID.DialogResultMustBeSetAfterShowDialog));
 
                }
            }
        }
 
        /// 
        ///     The DependencyProperty for WindowStyleProperty. 
        ///     Flags:              None 
        ///     Default Value:      WindowStyle.SingleBorderWindow
        ///  
        public static readonly DependencyProperty WindowStyleProperty =
                DependencyProperty.Register("WindowStyle", typeof(WindowStyle), typeof(Window),
                        new FrameworkPropertyMetadata(
                                WindowStyle.SingleBorderWindow, 
                                new PropertyChangedCallback(_OnWindowStyleChanged),
                                new CoerceValueCallback(CoerceWindowStyle)), 
                        new ValidateValueCallback(_ValidateWindowStyleCallback)); 

        ///  
        ///     Defines the visual style of the window (3DBorderWindow,
        ///     SingleBorderWindow, ToolWindow, none).
        /// 
        ///  
        ///     Default will be SingleBorderWindow.
        ///  
        public WindowStyle WindowStyle 
        {
            get 
            {
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing 
                // WindowStyle is not allowed
                VerifyApiSupported(); 
 
                return (WindowStyle) GetValue(WindowStyleProperty);
            } 
            set
            {
                VerifyContextAndObjectState();
                // this call ends up throwing an exception if accessing 
                // WindowStyle is not allowed
                VerifyApiSupported(); 
 
                SetValue(WindowStyleProperty, value);
            } 
        }

        private static object CoerceWindowStyle(DependencyObject d, object value)
        { 
            value = VerifyAccessCoercion(d, value);
 
            if (!((Window)d).IsSourceWindowNull) 
            {
                ((Window)d).VerifyConsistencyWithAllowsTransparency(); 
            }

            return value;
        } 

        ///  
        ///     The DependencyProperty for WindowStateProperty. 
        ///     Flags:              None
        ///     Default Value:      WindowState.Normal 
        /// 
        public static readonly DependencyProperty WindowStateProperty =
                DependencyProperty.Register("WindowState", typeof(WindowState), typeof(Window),
                        new FrameworkPropertyMetadata( 
                                WindowState.Normal,
                                FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, 
                                new PropertyChangedCallback(_OnWindowStateChanged), 
                                new CoerceValueCallback(VerifyAccessCoercion)),
                        new ValidateValueCallback(_ValidateWindowStateCallback)); 

        /// 
        ///     Current state of the window.  Valid options are Maximized, Minimized,
        ///     or Normal.  The host window may choose to ignore a request to change 
        ///     the current window state.
        ///  
        public WindowState WindowState 
        {
            get 
            {
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing 
                // WindowState is not allowed
                VerifyApiSupported(); 
 
                return (WindowState) GetValue(WindowStateProperty);
            } 
            set
            {
                VerifyContextAndObjectState();
                // this call ends up throwing an exception if accessing 
                // WindowState is not allowed
                VerifyApiSupported(); 
 
                SetValue(WindowStateProperty, value);
            } 
        }

        /// 
        ///     The DependencyProperty for the ResizeMode property. 
        ///     Flags:                  AffectsMeasure
        ///     Default Value:      false 
        ///  
        public static readonly DependencyProperty ResizeModeProperty =
                DependencyProperty.Register("ResizeMode", typeof(ResizeMode), typeof(Window), 
                        new FrameworkPropertyMetadata(ResizeMode.CanResize,
                                FrameworkPropertyMetadataOptions.AffectsMeasure,
                                new PropertyChangedCallback(_OnResizeModeChanged),
                                new CoerceValueCallback(VerifyAccessCoercion)), 
                        new ValidateValueCallback(_ValidateResizeModeCallback));
 
        ///  
        ///     Current state of the window.  Valid options are Maximized, Minimized,
        ///     or Normal.  The host window may choose to ignore a request to change 
        ///     the current window state.
        /// 
        public ResizeMode ResizeMode
        { 
            get
            { 
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing 
                // ResizeMode is not allowed
                VerifyApiSupported();

                return ((ResizeMode) GetValue(ResizeModeProperty)); 
            }
            set 
            { 
                VerifyContextAndObjectState();
                // this call ends up throwing an exception if accessing 
                // ResizeMode is not allowed
                VerifyApiSupported();

                SetValue(ResizeModeProperty, value); 
            }
        } 
 
        /// 
        ///     The DependencyProperty for TopmostProperty. 
        ///     Flags:              None
        ///     Default Value:      false
        /// 
        public static readonly DependencyProperty TopmostProperty = 
                DependencyProperty.Register("Topmost",
                        typeof(bool), 
                        typeof(Window), 
                        new FrameworkPropertyMetadata(BooleanBoxes.FalseBox,
                                new PropertyChangedCallback(_OnTopmostChanged), 
                                new CoerceValueCallback(VerifyAccessCoercion)));

        /// 
        ///     Determines if this window is always on the top. 
        /// 
        public bool Topmost 
        { 
            get
            { 
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing
                // Topmost is not allowed 
                VerifyApiSupported();
 
                return (bool) GetValue(TopmostProperty); 
            }
            set 
            {
                VerifyContextAndObjectState();
                // this call ends up throwing an exception if accessing
                // Topmost is not allowed 
                VerifyApiSupported();
 
                SetValue(TopmostProperty, BooleanBoxes.Box(value)); 
            }
        } 

        public static readonly DependencyProperty ShowActivatedProperty =
                DependencyProperty.Register("ShowActivated",
                        typeof(bool), 
                        typeof(Window),
                        new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, 
                                null, 
                                new CoerceValueCallback(VerifyAccessCoercion)));
 
        /// 
        ///     Determines if this window is activated when shown (default = true).
        /// 
        ///  
        ///     Not supported for RBW.
        ///  
        public bool ShowActivated 
        {
            get 
            {
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing 
                // ShowActivated is not allowed
                VerifyApiSupported(); 
 
                return (bool)GetValue(ShowActivatedProperty);
            } 
            set
            {
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // ShowActivated is not allowed 
                VerifyApiSupported(); 

                SetValue(ShowActivatedProperty, BooleanBoxes.Box(value)); 
            }
        }

        #endregion Public Properties 

        //--------------------------------------------------- 
        // 
        // Public Events
        // 
        //----------------------------------------------------
        #region Public Events

        ///  
        ///     This event is raised after the window source is created before it is shown
        ///  
        public event EventHandler SourceInitialized 
        {
            add { Events.AddHandler(EVENT_SOURCEINITIALIZED, value); } 
            remove { Events.RemoveHandler(EVENT_SOURCEINITIALIZED, value); }
        }

        ///  
        ///     This event is raised when the window is activated
        ///  
        public event EventHandler Activated 
        {
            add { Events.AddHandler(EVENT_ACTIVATED, value); } 
            remove { Events.RemoveHandler(EVENT_ACTIVATED, value); }
        }

        ///  
        ///     This event is raised when the window is deactivated
        ///  
        public event EventHandler Deactivated 
        {
            add { Events.AddHandler(EVENT_DEACTIVATED, value); } 
            remove { Events.RemoveHandler(EVENT_DEACTIVATED, value); }
        }

        ///  
        ///     This event is raised when the window state is changed
        ///  
        public event EventHandler StateChanged 
        {
            add { Events.AddHandler(EVENT_STATECHANGED, value); } 
            remove { Events.RemoveHandler(EVENT_STATECHANGED, value); }
        }

        ///  
        ///     This event is raised when the window location is changed
        ///  
        public event EventHandler LocationChanged 
        {
            add { Events.AddHandler(EVENT_LOCATIONCHANGED, value); } 
            remove { Events.RemoveHandler(EVENT_LOCATIONCHANGED, value); }
        }

        ///  
        ///     This event is raised before the window is closed
        ///  
        ///  
        ///     The user can set the CancelEventArg.Cancel property to true to prevent
        ///     the window from closing. However, if the Applicaiton is shutting down 
        ///     the window closing cannot be cancelled
        /// 
        public event CancelEventHandler Closing
        { 
            add { Events.AddHandler(EVENT_CLOSING, value); }
            remove { Events.RemoveHandler(EVENT_CLOSING, value); } 
        } 

        ///  
        ///     This event is raised when the window is closed.
        /// 
        public event EventHandler Closed
        { 
            add { Events.AddHandler(EVENT_CLOSED, value); }
            remove { Events.RemoveHandler(EVENT_CLOSED, value); } 
        } 

        ///  
        ///     This event is raised when the window and its content is rendered.
        /// 
        public event EventHandler ContentRendered
        { 
            add { Events.AddHandler(EVENT_CONTENTRENDERED, value); }
            remove { Events.RemoveHandler(EVENT_CONTENTRENDERED, value); } 
        } 

        #endregion Public Events 

        //---------------------------------------------------
        //
        // Protected Methods 
        //
        //--------------------------------------------------- 
        #region Protected Methods 

        ///  
        /// Creates AutomationPeer ()
        /// 
        protected override AutomationPeer OnCreateAutomationPeer()
        { 
            return new WindowAutomationPeer(this);
        } 
 
        /// 
        /// OnVisualParentChanged is called when the parent of the Visual is changed. 
        /// 
        /// Old parent or null if the Visual did not have a parent before.
        protected internal sealed override void OnVisualParentChanged(DependencyObject oldParent)
        { 
            VerifyContextAndObjectState();
            base.OnVisualParentChanged(oldParent); 
 
            // Checking for Visual parent here covers all the scenarios
            // including the following: 

            // Window w1 = new Window();
            // Window w2 = new WIndow();
            // w1.Show(); 
            // w2.Show();
            // w1.VisualChildren.Add(w2); 
 

            // Window w1 = new Window(); 
            // Window w2 = new WIndow();
            // w1.Show();
            // w1.VisualChildren.Add(w2);
            //  w2.Show(); 

            if ( VisualTreeHelper.GetParent(this) != null ) 
            { 
                throw new InvalidOperationException(SR.Get(SRID.WindowMustBeRoot));
            } 
        }

        /// 
        ///     Measurement override. Implements content sizing logic. 
        /// 
        ///  
        ///     Deducts the frame size from the constraint and then passes it on 
        ///     to it's child.  Only supports one Visual child (just like control)
        ///  
        protected override Size MeasureOverride(Size availableSize)
        {
            VerifyContextAndObjectState();
 
            // hamidm: WOSB 1330752 Window content should respect Window's Max/Min size
            // setting in a SizeToContent Window. 
            // 
            // Take Min/Max[Width/Height] into consideration.  The logic here is similar to
            // that used in FE.MeasureCore but is limited to Min/Max restriction.  Furthermore, 
            // we have our own version of MinMax struct called WindowMinMax that takes
            // SizeToContent into account when calculating the min/max values for height/width.
            //
            // We don't do anything special in ArrangeOverride the Arrange size is guaranteed 
            // to be the available hwnd size which should be atleast as big as the desired size.
 
            Size frameworkAvailableSize = new Size(availableSize.Width, availableSize.Height); 

            WindowMinMax mm = GetWindowMinMax(); 

            frameworkAvailableSize.Width  = Math.Max(mm.minWidth,  Math.Min(frameworkAvailableSize.Width, mm.maxWidth));
            frameworkAvailableSize.Height = Math.Max(mm.minHeight, Math.Min(frameworkAvailableSize.Height, mm.maxHeight));
 
            //  call to specific layout to measure
            Size desiredSize = MeasureOverrideHelper(frameworkAvailableSize); 
 
            //  maximize desiredSize with user provided min size
            desiredSize = new Size( 
                Math.Max(desiredSize.Width, mm.minWidth),
                Math.Max(desiredSize.Height, mm.minHeight));

            return desiredSize; 
        }
 
        ///  
        ///     ArrangeOverride allows for the customization of the positioning of children.
        ///  
        /// 
        ///     Deducts the frame size of the window from the constraint and then
        ///     arranges it's child.  Supports only one child.
        ///  
        protected override Size ArrangeOverride(Size arrangeBounds)
        { 
            VerifyContextAndObjectState(); 

            // hamidm: WOSB 1330752 Window content should respect Window's Max/Min size 
            // setting in a SizeToContent Window.

            // We don't do anything special in ArrangeCore regarding min/max size since
            // for BypassLayoutPolicies (Avalon Window case), the Arrange size is guaranteed 
            // to be the available hwnd size which should be atleast as big as the desired size.
 
 
            // Three primary cases
            //      1) hwnd does not exist  -- don't do anything 
            //      1a) CompositionTarget is invalid -- don't do anything
            //      2) Child visual exists  -- arrange child at arrangeBounds - window frame size
            //      3) No Child visual      -- don't do anything
 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            { 
                return arrangeBounds;
            } 

            if (this.VisualChildrenCount > 0)
            {
                UIElement child = this.GetVisualChild(0) as UIElement; 
                if (child != null)
                { 
                    // Find out the size of the window frame x. 
                    // (constraint - x) is the size we pass onto
                    // our child 
                    Size frameSize = GetHwndNonClientAreaSizeInMeasureUnits();

                    // In some instances (constraint size - frame size) can be negative. One instance
                    // is when window is set to minimized before layout has happened.  Apparently, Win32 
                    // gives a rect(-32000, -32000, -31840, -31975) for GetWindowRect when hwnd is
                    // minimized.  However, when we calculate the frame size we get width = 8 and 
                    // height = 28!!!  Here, we will take the max of zero and the difference b/w the 
                    // hwnd size and the frame size
                    // 
                    // PS Windows OS Bug: 955861

                    Size childArrangeBounds = new Size();
                    childArrangeBounds.Width = Math.Max(0.0, arrangeBounds.Width - frameSize.Width); 
                    childArrangeBounds.Height = Math.Max(0.0, arrangeBounds.Height - frameSize.Height);
 
                    child.Arrange(new Rect(childArrangeBounds)); 

                    // Windows OS bug # 928719, 953458 
                    // The default impl of FlowDirection is that it adds a transform on the element
                    // on whom the FlowDirection property is RlTb.  However, transforms work only if
                    // there is a parent visual.  In the window case, we are the root and thus this
                    // does not work.  Thus, we add the same transform to our child, if our 
                    // FlowDireciton = Rltb.
                    if (FlowDirection == FlowDirection.RightToLeft) 
                    { 
                        InternalSetLayoutTransform(child, new MatrixTransform(-1.0, 0.0, 0.0, 1.0, childArrangeBounds.Width, 0.0));
                    } 

                }
            }
            return arrangeBounds; 
        }
 
        ///  
        ///     This method is invoked when the Content property changes.
        ///  
        /// The old value of the Content property.
        /// The new value of the Content property.
        protected override void OnContentChanged(object oldContent, object newContent)
        { 
            base.OnContentChanged(oldContent, newContent);
 
            // hamidm 01/12/2005 
            // WOSB 1010151 FxCop: ConstructorsShouldNotCallBaseClassVirtualMethods::
            // System.Windows (presentationframework.dll 2 violation) 
            //
            // We can't set IWS property in the cctor since it results
            // in calling some virtual.  So, as an alternative we set it
            // when content is changed and when we set the root visual. 
            // We set it here, b/c once window has logical children, they
            // can query for inherited IWS property. 
            SetIWindowService(); 

            // We post a dispatcher work item to fire ContentRendered 
            // only if this is Loaded in the tree.  If not, we will
            // post it from the LoadedHandler.  This guarantees that
            // we don't fire ContentRendered on a subtree that is not
            // connected to a PresentationSource 
            if (IsLoaded == true)
            { 
                PostContentRendered(); 
            }
            else 
            {
                // _postContentRenderedFromLoadedHandler == true means
                // that we deferred to the Loaded event to PostConetentRendered
                // for the previous content change and Loaded has not fired yet. 
                // Thus we don't want to hook up another event handler
                if (_postContentRenderedFromLoadedHandler == false) 
                { 
                    this.Loaded += new RoutedEventHandler(LoadedHandler);
                    _postContentRenderedFromLoadedHandler = true; 
                }
            }
        }
 
        /// 
        ///     This even fires after the window source is created before it is shown. This event is non cancelable and is 
        ///     for user infromational purposes 
        /// 
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass
        ///     the event. If you override this method - you need to call Base.OnSourceInitialized(...) for
        ///     the corresponding event to be raised. 
        /// 
        ///  
        protected virtual void OnSourceInitialized(EventArgs e) 
        {
            VerifyContextAndObjectState(); 
            EventHandler handler = (EventHandler)Events[EVENT_SOURCEINITIALIZED];
            if (handler != null) handler(this, e);
        }
 
        /// 
        ///     This even fires when window is activated. This event is non cancelable and is 
        ///     for user infromational purposes 
        /// 
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass
        ///     the event. If you override this method - you need to call Base.OnClosed(...) for
        ///     the corresponding event to be raised. 
        /// 
        ///  
        protected virtual void OnActivated(EventArgs e) 
        {
            VerifyContextAndObjectState(); 
            EventHandler handler = (EventHandler)Events[EVENT_ACTIVATED];
            if (handler != null) handler(this, e);
        }
 
        /// 
        ///     This even fires when window is deactivated. This event is non cancelable and is 
        ///     for user infromational purposes 
        /// 
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass
        ///     the event. If you override this method - you need to call Base.OnClosed(...) for
        ///     the corresponding event to be raised. 
        /// 
        protected virtual void OnDeactivated(EventArgs e) 
        { 
            VerifyContextAndObjectState();
            EventHandler handler = (EventHandler)Events[EVENT_DEACTIVATED]; 
            if (handler != null) handler(this, e);
        }

        ///  
        ///     This even fires when window state is changed. This event is non
        ///     cancelable and is for user infromational purposes 
        ///  
        /// 
        ///     This method follows the .Net programming guideline of having a protected virtual 
        ///     method that raises an event, to provide a convenience for developers
        ///     that subclass the event. If you override this method - you need to call
        ///     Base.OnClosed(...) for the corresponding event to be raised.
        ///  
        protected virtual void OnStateChanged(EventArgs e)
        { 
            VerifyContextAndObjectState(); 
            EventHandler handler = (EventHandler)Events[EVENT_STATECHANGED];
            if (handler != null) handler(this, e); 
        }

        /// 
        ///     This event fires when window location changes. This event is not 
        ///     cancelable and is for user infromational purposes
        ///  
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass 
        ///     the event. If you override this method - you need to call Base.OnClosed(...) for
        ///     the corresponding event to be raised.
        /// 
        protected virtual void OnLocationChanged(EventArgs e) 
        {
            VerifyContextAndObjectState(); 
            EventHandler handler = (EventHandler)Events[EVENT_LOCATIONCHANGED]; 
            if (handler != null) handler(this, e);
        } 

        /// 
        ///     This event fires when window is Closing. This event is cancelable and thus the
        ///     user can set the CancelEventArgs.Cancel property to true to dismiss window 
        ///     closing
        ///  
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass 
        ///     the event. If you override this method - you need to call Base.OnClosing(...) for
        ///     the corresponding event to be raised.
        /// 
        protected virtual void OnClosing(CancelEventArgs e) 
        {
            VerifyContextAndObjectState(); 
            CancelEventHandler handler = (CancelEventHandler)Events[EVENT_CLOSING]; 
            if (handler != null) handler(this, e);
        } 

        /// 
        ///     This event fires when window is closed. This event is non cancelable and is
        ///     for user infromational purposes 
        /// 
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual 
        ///     method that raises an event, to provide a convenience for developers that subclass
        ///     the event. If you override this method - you need to call Base.OnClosed(...) for 
        ///     the corresponding event to be raised.
        /// 
        protected virtual void OnClosed(EventArgs e)
        { 
            VerifyContextAndObjectState();
            EventHandler handler = (EventHandler)Events[EVENT_CLOSED]; 
            if (handler != null) handler(this, e); 
        }
 
        /// 
        ///     This override fires the ContentRendered event.
        /// 
        ///  
        protected virtual void OnContentRendered(EventArgs e)
        { 
            VerifyContextAndObjectState(); 

            // After the content is rendered we want to check if there is an element that needs to be focused 
            // If there is - set focus to it
            DependencyObject doContent = Content as DependencyObject;
            if (doContent != null)
            { 
                IInputElement focusedElement = FocusManager.GetFocusedElement(doContent) as IInputElement;
                if (focusedElement != null) 
                    focusedElement.Focus(); 
            }
 
            EventHandler handler = (EventHandler)Events[EVENT_CONTENTRENDERED];
            if (handler != null) handler(this, e);
        }
        #endregion Protected Methods 

        //--------------------------------------------------- 
        // 
        // Internal Methods
        // 
        //----------------------------------------------------
        #region Internal Methods
        ///
        ///     Critical - calls a method that elevates - CompositionTarget 
        ///     TreatAsSafe - We only use the CompositionTarget to do device to logical unit conversion.
        /// 
        [SecurityCritical, SecurityTreatAsSafe] 
        internal Point DeviceToLogicalUnits(Point ptDeviceUnits)
        { 
            Invariant.Assert(IsCompositionTargetInvalid == false, "IsCompositionTargetInvalid is supposed to be false here");
            Point ptLogicalUnits = _swh.CompositionTarget.TransformFromDevice.Transform(ptDeviceUnits);
            return ptLogicalUnits;
        } 

        /// 
        ///     Critical - calls a method that elevates - CompositionTarget 
        ///     TreatAsSafe - We only use the CompositionTarget to do logical to device unit conversion.
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        internal Point LogicalToDeviceUnits(Point ptLogicalUnits)
        {
            Invariant.Assert(IsCompositionTargetInvalid == false, "IsCompositionTargetInvalid is supposed to be false here"); 
            Point ptDeviceUnits = _swh.CompositionTarget.TransformToDevice.Transform(ptLogicalUnits);
            return ptDeviceUnits; 
        } 

        internal static bool VisibilityToBool(Visibility v) 
        {
            switch (v)
            {
                case Visibility.Visible: 
                    return true;
                case Visibility.Hidden: 
                case Visibility.Collapsed: 
                    return false;
                default: 
                    return false;
            }
        }
 
        /// 
        ///     Called by ResizeGrip control to set its reference in the Window object 
        ///  
        /// 
        ///     RBW doesn't need ResizeGrip and hence it doesn't do 
        ///     anything in this virtual
        /// 
        internal virtual void SetResizeGripControl(Control ctrl)
        { 
            _resizeGripControl = ctrl;
        } 
 
        internal virtual void ClearResizeGripControl(Control oldCtrl)
        { 
            if (oldCtrl == _resizeGripControl)
            {
                _resizeGripControl = null;
            } 
        }
 
        internal virtual void TryClearingMainWindow() 
        {
            if (IsInsideApp && this == App.MainWindow) 
            {
                App.MainWindow = null;
            }
        } 

        ///  
        ///     Send a WM_CLOSE message to close the window. When the WM_CLOSE message is 
        ///     processed by the WindowFilterMessage function, the Closing event is fired.
        ///     Closing event is cancelable and thus can dismiss window closing. 
        /// 
        /// Specifies whether the app should shutdown or not
        /// Specifies whether cancelling closing should be ignored 
        /// 
        ///     Critical - as this code calls UnsafeSendMessage that has a SUC.
        /// 
        [SecurityCritical] 
        internal void InternalClose(bool shutdown, bool ignoreCancel)
        { 
            VerifyNotClosing();

            if (_disposed == true)
            { 
                return;
            } 
 
            _appShuttingDown = shutdown;
            _ignoreCancel = ignoreCancel; 

            if ( IsSourceWindowNull )
            {
                _isClosing = true; 

                // Event handler exception continuality: if exception occurs in Closing event handler, the 
                // cleanup action is to finish closing. 
                CancelEventArgs e = new CancelEventArgs(false);
                try 
                {
                    OnClosing(e);
                }
                catch 
                {
                    CloseWindowBeforeShow(); 
                    throw; 
                }
 
                if (ShouldCloseWindow(e.Cancel))
                {
                    CloseWindowBeforeShow();
                } 
                else
                { 
                    _isClosing = false; 
                    // 03/14/2006 -- hamidm
                    // WOSB 1560557 Dialog does not close with ESC key after it has been cancelled 
                    //
                    // No need to reset DialogResult to null here since source window is null.  That means
                    // that ShowDialog has not been called and thus no need to worry about DialogResult.
                } 
            }
            else 
            { 
                // close window synchronously
 
                // We demand for UIPermission AllWindows at the public API, Window.Close(), level.
                // It can be called when shutting down the app.
                // The public entry to that code path Application.Shutdown is
                // also protected with a demand for UIPermission with AllWindow access 

                // SendMessage's return value is dependent on the message send.  WM_CLOSE 
                // return value just signify whether the WndProc handled the 
                // message or not, so it is not interesting
#pragma warning disable 6523 
                UnsafeNativeMethods.UnsafeSendMessage(CriticalHandle, NativeMethods.WM_CLOSE, new IntPtr(), new IntPtr());
#pragma warning enable 6523
            }
        } 

        // NOTE: hamidm  05/18/03 -- PS # 843776 
        // We fire Closing and Closed envent even if the hwnd is not 
        // created yet i.e. window is not shown.
        /// 
        ///     Critical: Calls critical code: Window.InternalDispose
        ///
        [SecurityCritical]
        private void CloseWindowBeforeShow() 
        {
            InternalDispose(); 
 
            // raise Closed event
            OnClosed(EventArgs.Empty); 
        }

        ///
        ///     Critical - as this accesses critical data. 
        ///     TreatAsSafe - as this function just tests to see whether _sourceWindow has been created.
        ///                          Ok to expose publically. Equivalent to is Window visible. 
        /// 
        internal bool IsSourceWindowNull
        { 
            [ SecurityCritical, SecurityTreatAsSafe ]
            get
            {
                if ( _swh != null ) 
                {
                    return _swh.IsSourceWindowNull; 
                } 
                return true;
            } 
        }

        ///
        ///     Critical - as this accesses critical data. 
        ///     TreatAsSafe - as this function just tests to see whether CompositionTarget is valid.
        ///                          Ok to expose publically. 
        /// 
        internal bool IsCompositionTargetInvalid
        { 
            [ SecurityCritical, SecurityTreatAsSafe ]
            get
            {
                if (_swh != null) 
                {
                    return _swh.IsCompositionTargetInvalid; 
                } 
                return true;
            } 
        }

        internal NativeMethods.RECT WorkAreaBoundsForNearestMonitor
        { 
            get
            { 
                Debug.Assert( _swh != null ); 
                return _swh.WorkAreaBoundsForNearestMonitor;
            } 
        }

        internal Size WindowSize
        { 
            get
            { 
                Debug.Assert( _swh != null ); 
                return _swh.WindowSize;
            } 
        }

        // This is currently exposed just for DRTs.
        // PLEASE NOTE THAT IF YOU ARE CALLING THIS WITHIN AVALON CODE - YOU ARE CALLING A SECURITY 

 
 

 
        internal HwndSource HwndSourceWindow
        {
            [SecurityCritical, SecurityTreatAsSafe ]
            get 
            {
                SecurityHelper.DemandUIWindowPermission(); 
 
                if ( _swh != null )
                    return _swh.HwndSourceWindow; 
                else
                    return null;
            }
        } 

        // 
 

 



 

        // NOTE: added on 10/03/02 
        // We should set our _hwndSource reference to null here. 
        // Else, if the hwndSource is not null, users can call
        // public APIs that use hwndSource and it will fail 

        /// 
        ///     can be used by internal derived class
        ///  
        ///
        ///     Critical: It calls critical code: Window.UpdateWindowListsOnClose and it 
        ///     is used to dispose of the native handles which link demands in safe handle 
        ///
        [SecurityCritical] 
        private void InternalDispose()
        {
            _disposed = true;
 
            // UpdateWindowLists here instead of in WM_CLOSE for 2 reasons.
            // 1. WM_CLOSE is not fired for child window. An example would be RootBrowserWindow (bug 1754467). 
            // 2. It is not fired as a result of calling Dispose directly on HwndSource (HwndSource distroy the window). 
            UpdateWindowListsOnClose();
 
#if DISPOSE
            // detach all events
            if (_events != null)
            { 
                _events.Dispose();
                _events = null; 
            } 
#endif
            // NOTE: hamidm 
            // This InternalDispose method is called while
            // processing WM_DESTROY msg. Once we're done
            // processing this msg, HwndWrapper does it's processing.
            // We don't need to dispose _swh here b/c 
            // HwndWrapper fires the hwndDisposed event while
            // processing WM_DESTROY msg. HwndSource listens to 
            // this event and disposes itself i.e. the CompositionTarget etc. 
            // If we call dispose here, HwndWrapper.Dispose sends
            // a WM_DESTROY msg and it is a duplicate msg. 

            // According to .NET guidelines, Dispose() should
            // never throw, but we're doing try/finally to be
            // on the safe side.  We cannot afford to exit 
            // this method in an inconsistent state where
            // variables are not nulled out. 
            try 
            {
                ClearSourceWindow(); 

                if ( _hiddenWindow != null )
                {
                    _hiddenWindow.Dispose(); 
                }
 
                if (_defaultLargeIconHandle != null) 
                {
                    _defaultLargeIconHandle.Dispose(); 
                }

                if (_defaultSmallIconHandle != null)
                { 
                    _defaultSmallIconHandle.Dispose();
                } 
 
                if (_currentLargeIconHandle != null)
                { 
                    _currentLargeIconHandle.Dispose();
                }

                if (_currentSmallIconHandle != null) 
                {
                    _currentSmallIconHandle.Dispose(); 
                } 
            }
            finally 
            {
                _hiddenWindow = null;
                _defaultLargeIconHandle = null;
                _defaultSmallIconHandle = null; 
                _currentLargeIconHandle = null;
                _currentSmallIconHandle = null; 
 
                _isClosing = false;
            } 
        }

        /// 
        ///     This is a callback called to set the window Visual. It is called after 
        ///     the source window has been created.
        ///  
        internal override void OnAncestorChanged() 
        {
            base.OnAncestorChanged(); 
            if (Parent != null)
            {
                throw new InvalidOperationException(SR.Get(SRID.WindowMustBeRoot));
            } 
        }
 
        ///  
        ///     Initializes the _style and _styleEx bits.
        ///  
        //CASRemoval:[StrongNameIdentityPermissionAttribute(SecurityAction.InheritanceDemand, PublicKey=Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)]
        internal virtual void CreateAllStyle()
        {
            // we don't need to set to WS_OVERLAPPEDWINDOW since all the styles are set 
            // manually depending on window properties.
            // 
            // We always have the sysmenu 
            // If the Window has a Caption, then this also
            // shows the icon and the close box 

            _Style = NativeMethods.WS_CLIPCHILDREN | NativeMethods.WS_SYSMENU;
            _StyleEx = 0;
 
            CreateWindowStyle();
            CreateWindowState(); 
 
            // do all the other checks and update style bits
 
            // Visibility bits
            if ( _isVisible )
            {
                _Style |= NativeMethods.WS_VISIBLE; 
            }
 
            SetTaskbarStatus(); 
            CreateTopmost();
            CreateResizibility(); 
            CreateRtl();
        }

        ///  
        ///     Create the window
        ///     Virtual so that subclasses ( currently only RootBrowserWindow) - may assert for HwndSource creation. 
        ///  
        /// 
        ///     This methods does the following: 
        ///     CalculateLocation of the window:
        ///         Calculates location of window. If either Top/Left is CW_USEDEFAULT,
        ///         we have to make sure that window displays on the screen. Details in
        ///         the methods. 
        ///
        ///     Calculate size: 
        ///         Calculates size. If either one of Width/Height is set, then we 
        ///         create a window with both set to default and then resizing it
        ///         to the set value 
        ///
        ///     Update Properties:
        ///         After the hwnd is created, we updated our property values for various
        ///         properties 
        /// 
        /// 
        ///     Critical - as this method accesses critical data and creates a window which it stores locally 
        ///
        [SecurityCritical] 
        internal virtual void CreateSourceWindowImpl()
        {
            // we need to cache initial requested top and left as the very first thing
            // since updating the styles etc (as for borderless case below) fires 
            // WM_MOVE and update Top/Left.  Also, for RBW case, Top/Left is returned
            // as 0,0 since they are inconsequential. 
 
            double requestedTop = 0;
            double requestedLeft = 0; 
            double requestedWidth = 0;
            double requestedHeight = 0;

            GetRequestedDimensions(ref requestedLeft, ref requestedTop, ref requestedWidth, ref requestedHeight); 

            using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd)) 
            { 
                // set window style and styleEx bits
                // CreateAllStyle is internal virtual. RBW overrides it to set style to WS_CHILD and 
                // set parent handle
                CreateAllStyle();

                // create the Win32 Window 
                HwndSourceParameters param = new HwndSourceParameters(Title, NativeMethods.CW_USEDEFAULT, NativeMethods.CW_USEDEFAULT);
                param.UsesPerPixelOpacity = AllowsTransparency; 
                param.WindowStyle = _Style; 
                param.ExtendedWindowStyle = _StyleEx;
                param.ParentWindow = _ownerHandle; 
                param.AdjustSizingForNonClientArea = true;
                param.HwndSourceHook = new HwndSourceHook(WindowFilterMessage); // hook to process window messages

 
                // HwndSource disposes itself when HwndWrapper process the WM_DESTROY message.
                // Window sends WM_CLOSE (which in turn sends WM_DESTROY) to the hwnd when 
                // Window.Close() is called.  Thus, this HwndSource created by window is always 
                // disposed by HwndSource itself
#pragma warning disable 56518 
                HwndSource source = new HwndSource(param);
#pragma warning enable 56518
                _swh = new SourceWindowHelper(source);
                source.SizeToContentChanged += new EventHandler(OnSourceSizeToContentChanged); 

                // since we created the window with the style, mark 
                // sm as not dirty so that we don't unneccessarialy update 
                // the Win32 style bits.
                sm.Dirty = false; 

                // NOTE: hamidm
                // HwndSource COULD ADD STYLE/STYLEEX BITS TO THE ONES SUPPLIED. TODAY,
                // HwndSource ADDS WS_CLIPCHILDREN TO THE STYLE WHICH MAY NOT 
                // BE REFLECTED IN OUR CACHED STYLE BITS.  IF WE WERE
                // TO UPDATE THE WIN32 SYTLE, THE STYLES ADDED BY HWNDSOURCE 
                // WOULD BE LOST.  IF IN THE 

 



 
                // Since RBW cannot access WindowStyle, hence it overrides
                // this virtual and does nothing it it. 
                CorrectStyleForBorderlessWindowCase(); 

            } // end using StyleManager 

            // We don't do anything that uses the Window styles below so we might as
            // well close the using so that we update the new style to the hwnd.
            // This change was made for WOSB 1051710 where SizeToContent.WidthAndHeight borderless 
            // windows where actually bigger than the content size.  This was b/c of
            // the fact that we didn't update the style of the hwnd before setting 
            // the RootVisual which inturn calls MeasureOverride on Window from 
            // where we calculating the non-client area size using the stale
            // style bits from the hwnd. 

            // Add Disposed event handler
            _swh.AddDisposedHandler ( new EventHandler(OnSourceWindowDisposed) );
 
            // Sub classes can have different intialization. RBW does very minimalistic
            // stuff in its override 
            SetupInitialState(requestedTop, requestedLeft, requestedWidth, requestedHeight); 

            // Fire SourceInitialized event 
            OnSourceInitialized(EventArgs.Empty);
        }

        private void OnSourceSizeToContentChanged(object sender, EventArgs args) 
        {
            SizeToContent = HwndSourceSizeToContent; 
        } 

        internal virtual void CorrectStyleForBorderlessWindowCase() 
        {
            // We create an OverLapped window for which user adds WS_CAPTION
            // to the passed in style.  If we were creating a borderless window,
            // remove WS_CAPTION from the hwnd. 
            //
            // We should really be using WS_POPUP for borderless windows, but 
            // there's a bug with default sizing where user creates the popup 
            // window with 0,0 size.
            // 

            using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd))
            {
                if (WindowStyle == WindowStyle.None) 
                {
                    _Style = _swh.StyleFromHwnd; 
                    _Style &= ~NativeMethods.WS_CAPTION; 
                }
            } 
        }

        internal virtual void GetRequestedDimensions(ref double requestedLeft, ref double requestedTop, ref double requestedWidth, ref double requestedHeight)
        { 
            requestedTop = this.Top;
            requestedLeft = this.Left; 
            requestedWidth = this.Width; 
            requestedHeight = this.Height;
        } 

        ///
        ///     Critical - as this method accesses critical data (CriticalHandle) and
        ///                 resizes/repositions the window 
        ///     It also calls critical method (SetRootVisual)
        /// 
        [SecurityCritical] 
        internal virtual void SetupInitialState(double requestedTop, double requestedLeft, double requestedWidth, double requestedHeight)
        { 
            // Push the current SizeToContent value to HwndSource after it's created. Initial [....] up.
            HwndSourceSizeToContent = (SizeToContent) GetValue(SizeToContentProperty);
            UpdateIcon();
 
            NativeMethods.RECT rc = WindowBounds;
            Size sizeDeviceUnits = new Size(rc.right - rc.left, rc.bottom - rc.top); 
            double xDeviceUnits = rc.left; 
            double yDeviceUnits = rc.top;
 
            bool updateHwndPlacement = false;

            // This code is absolutely necessary here.  This is the initial [....] up
            // for Left/Top.  We don't do this in WM_MOVE if sourceWindow is 
            // null (it is null b/c the call to create HwndSource has not returned at the point)
            // and we are not listening to WM_CREATE either.  The reasons for not 
            // doing so is b/c if sourceWindow is null, we can't get to the CompositionTarget 
            // to convert b/w device and logical pixels
            Point currentLocationLogicalUnits = DeviceToLogicalUnits(new Point(xDeviceUnits, yDeviceUnits)); 

            // Update our current hwnd ActualTop/ActualLeft values
            // The _actualLeft and _actualTop need to be updated before we coerce Top and Left.
            // See CoerceTop for more info. 
            _actualLeft = currentLocationLogicalUnits.X;
            _actualTop = currentLocationLogicalUnits.Y; 
            // Coerce Top and Left value to be the intial value used in CreateWindowEx. 
            try
            { 
                _updateHwndLocation = false;
                CoerceValue(TopProperty);
                CoerceValue(LeftProperty);
            } 
            finally
            { 
                _updateHwndLocation = true; 
            }
 
            Point requestedSizeDeviceUnits = LogicalToDeviceUnits(new Point(requestedWidth, requestedHeight));
            Point requestedLocationDeviceUnits = LogicalToDeviceUnits(new Point(requestedLeft, requestedTop));

            // if Width was specified and is not the same as the current width, then update it 
            if ((!DoubleUtil.IsNaN(requestedWidth)) && (!DoubleUtil.AreClose(sizeDeviceUnits.Width, requestedSizeDeviceUnits.X)))
            { 
                // at this stage, ActualWidth/Height is not set since 
                // layout has not happened (it happens when we set the
                // RootVisual of the HwndSource) 

                updateHwndPlacement = true;
                sizeDeviceUnits.Width = requestedSizeDeviceUnits.X;
 
                // SetWindowPlacement for Width/Height when Width/Height is set and WindowState is maximized/minimized.
                // No need to do it for Top/Left since that is taken care of in CoerceTop/Left. 
                // Width/Height is different from Top/Left. For the actual value, there are ActualWidth/Height. 
                // That is why the same Top/Left coerce logic won't work for Width/Height.
                if (WindowState != WindowState.Normal) 
                {
                    UpdateHwndRestoreBounds(requestedWidth, BoundsSpecified.Width);
                }
            } 

            // if Height was specified and is not the same as the current height, then update it 
            if (!DoubleUtil.IsNaN(requestedHeight) && (!DoubleUtil.AreClose(sizeDeviceUnits.Height, requestedSizeDeviceUnits.Y))) 
            {
                // at this stage, ActualWidth/Height is not set since 
                // layout has not happened (it happens when we set the
                // RootVisual of the HwndSource)

                updateHwndPlacement = true; 
                sizeDeviceUnits.Height = requestedSizeDeviceUnits.Y;
 
                // SetWindowPlacement for Width/Height when Width/Height is set and WindowState is maximized/minimized. 
                // No need to do it for Top/Left since that is taken care of in CoerceTop/Left.
                // Width/Height is different from Top/Left. For the actual value, there are ActualWidth/Height. 
                // That is why the same Top/Left coerce logic won't work for Width/Height.
                if (WindowState != WindowState.Normal)
                {
                    UpdateHwndRestoreBounds(requestedHeight, BoundsSpecified.Height); 
                }
            } 
 
            // if left was specified and is not the same as the current left, then update it
            if (!DoubleUtil.IsNaN(requestedLeft) && (!DoubleUtil.AreClose(xDeviceUnits, requestedLocationDeviceUnits.X))) 
            {
                updateHwndPlacement = true;
                xDeviceUnits = requestedLocationDeviceUnits.X;
            } 

            // if top was specified and is not the same as the current top, then update it 
            if (!DoubleUtil.IsNaN(requestedTop) && (!DoubleUtil.AreClose(yDeviceUnits, requestedLocationDeviceUnits.Y))) 
            {
                updateHwndPlacement = true; 
                yDeviceUnits = requestedLocationDeviceUnits.Y;
            }

            Point minSizeDeviceUnits = LogicalToDeviceUnits(new Point(MinWidth, MinHeight)); 
            Point maxSizeDeviceUnits = LogicalToDeviceUnits(new Point(MaxWidth, MaxHeight));
 
            // We need this here b/c when WM_GETMINMAXINFO is handled as a result of 
            // creating the hwnd, _swh is null and thus we cannot get to the CompositionTarget
            // to convert b/w device and logical units.  Thus, once the hwnd is created, we 
            // need to check to make sure that the hwnd is within the min/max boundaries.
            //
            // Here is idea it to detect if we are outside the min/max range and if yes, cause
            // a resize.  This resize will call WM_GETMINMAXINFO and that will further take 
            // care of the bounds
 
            if (!Double.IsPositiveInfinity(maxSizeDeviceUnits.X) && (sizeDeviceUnits.Width > maxSizeDeviceUnits.X)) 
            {
                updateHwndPlacement = true; 
                sizeDeviceUnits.Width = maxSizeDeviceUnits.X;
            }

            if (!Double.IsPositiveInfinity(minSizeDeviceUnits.Y) && (sizeDeviceUnits.Height > maxSizeDeviceUnits.Y)) 
            {
                updateHwndPlacement = true; 
                sizeDeviceUnits.Height = maxSizeDeviceUnits.Y; 
            }
 
            if (sizeDeviceUnits.Width < minSizeDeviceUnits.X)
            {
                updateHwndPlacement = true;
                sizeDeviceUnits.Width = minSizeDeviceUnits.X; 
            }
 
            if (sizeDeviceUnits.Height < minSizeDeviceUnits.Y) 
            {
                updateHwndPlacement = true; 
                sizeDeviceUnits.Height = minSizeDeviceUnits.Y;
            }

            // Now that we know the window Width/Height/Left/Top, we want to calculate 
            // the location based on WindowStartupLocation enum.  All inputs to
            // CalculateWindowLocation must be in DEVICE units.  It will return true, 
            // if it updated theinput values of left, top. 
            //
            updateHwndPlacement = (CalculateWindowLocation(ref xDeviceUnits, ref yDeviceUnits, sizeDeviceUnits)? true: updateHwndPlacement); 

            // We need to update the hwnd size before we set RootVisual b/c setting RootVisual
            // results in a Measure/Arrange/Layout and we want to set the correct hwnd size
            // now so that layout happens at the correct size. 
            //
            if (updateHwndPlacement == true) 
            { 
                if (WindowState == WindowState.Normal)
                { 
                    UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle),
                        new HandleRef(null, IntPtr.Zero),
                        DoubleUtil.DoubleToInt(xDeviceUnits),
                        DoubleUtil.DoubleToInt(yDeviceUnits), 
                        DoubleUtil.DoubleToInt(sizeDeviceUnits.Width),
                        DoubleUtil.DoubleToInt(sizeDeviceUnits.Height), 
                        NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE 
                        );
 
                    // The value of Top and Left is affected by WindowState and WindowStartupLocation.
                    // we need to coerce Top and Left whenever these deciding factors change.
                    // More info in CoerceTop.
                    try 
                    {
                        _updateHwndLocation = false; 
                        _updateStartupLocation = true; 
                        CoerceValue(TopProperty);
                        CoerceValue(LeftProperty); 
                    }
                    finally
                    {
                        _updateHwndLocation = true; 
                        _updateStartupLocation = false;
                    } 
                } 
            }
 
            SetRootVisual();

            // if SizeToContent, we would need to set the location again if
            // WSL is CenterOwner or CenterScreen b/c size may have changed 
            // after we set the RootVisual on HwndSource.
            if (SizeToContent != SizeToContent.Manual) 
            { 
                // inputs to CalculateWindowLocation must be in DEVICE units
                Point newSizeDeviceUnits = LogicalToDeviceUnits(new Point(this.ActualWidth, this.ActualHeight)); 
                if (CalculateWindowLocation(ref xDeviceUnits, ref yDeviceUnits, new Size(newSizeDeviceUnits.X, newSizeDeviceUnits.Y)))
                {
                    if (WindowState == WindowState.Normal)
                    { 
                        UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle),
                            new HandleRef(null, IntPtr.Zero), 
                            DoubleUtil.DoubleToInt(xDeviceUnits), 
                            DoubleUtil.DoubleToInt(yDeviceUnits),
                            0, 
                            0,
                            NativeMethods.SWP_NOSIZE | NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE
                            );
 
                        // The value of Top and Left is affected by WindowState and WindowStartupLocation.
                        // we need to coerce Top and Left whenever these deciding factors change. 
                        // More info in CoerceTop. 
                        try
                        { 
                            _updateHwndLocation = false;
                            _updateStartupLocation = true;
                            CoerceValue(TopProperty);
                            CoerceValue(LeftProperty); 
                        }
                        finally 
                        { 
                            _updateHwndLocation = true;
                            _updateStartupLocation = false; 
                        }
                    }
                }
            } 
        }
 
        /// 
        ///     Critical - as this method accesses critical method (_swh.RootVisual)
        /// 
        [SecurityCritical]
        internal void SetRootVisual()
        {
            // hamidm 01/12/2005 
            // WOSB 1010151 FxCop: ConstructorsShouldNotCallBaseClassVirtualMethods::
            // System.Windows (presentationframework.dll 2 violation) 
            // 
            // We can't set IWS property in the cctor since it results
            // in calling some virtual.  So, as an alternative we set it 
            // when content is changed and when we set the root visual.
            // We set it here, b/c once RootVisual is set, the visual tree
            // can/is created and visual children can query for inherited
            // IWS property. 
            SetIWindowService();
 
            // 
            // We are intentionally not merging the above SetWindowPos with the one below.  The reason is
            // that if Width or Height is set we initially create the hwnd with both as default win32 size 
            // and later (above call to SetWindowPos) resizes it to reflect the specified Width or Height.
            // After this is done, we set RootVisual which results in a layout with the correct size of
            // the hwnd.
            // 
            // If we merge the above call to SetWindowPos with the one below, then for the scenario where
            // Width or Height is set initially, we create the hwnd with win32 default size.  Setting RootVisual 
            // would cause layout to happen at that default size.  Now, we resize the window to reflect the 
            // specified size which will result in another layout.
            // 
            // The third option is to set RootVisual after doing all resizes.  This is not possible to do for
            // the SizeToContent case since we don't know the size of hwnd until RootVisual is set and layout
            // has happened.
            // 

            // set root visual  synchronously, shell request 
            if ( IsSourceWindowNull == false ) 
            {
                _swh.RootVisual = this; 
            }
        }

        ///  
        ///     Create the style bits depending on the WindowStyle property
        ///  
        ///  
        ///     This method does not clear the bits, so the style bits should be cleared
        ///     before calling this method 
        /// 
        private void CreateWindowStyle()
        {
            // Clear the style bits related to WindowStyle 
            _Style &= ~NativeMethods.WS_CAPTION;
            _StyleEx &= ~(NativeMethods.WS_EX_CLIENTEDGE | NativeMethods.WS_EX_TOOLWINDOW); 
 
            // WS_CAPTION == WS_BORDER | WS_DLGFRAME (0x00C00000L)
            // Thus no need to set/clear WS_BORDER when we are 
            // already seting/clearing WS_CAPTION
            switch (WindowStyle)
            {
                case WindowStyle.None: 
                    _Style &= (~NativeMethods.WS_CAPTION);
                    break; 
 
                case WindowStyle.SingleBorderWindow:
                    _Style |= NativeMethods.WS_CAPTION; 
                    break;

                case WindowStyle.ThreeDBorderWindow:
                    _Style |= NativeMethods.WS_CAPTION; 
                    _StyleEx |= NativeMethods.WS_EX_CLIENTEDGE;
                    break; 
 
                case WindowStyle.ToolWindow:
                    _Style |= NativeMethods.WS_CAPTION; 
                    _StyleEx |= NativeMethods.WS_EX_TOOLWINDOW;
                    break;
#if Never
                case WindowBorderStyle.Sizable: 
                    _startSettings.Style |= NativeMethods.WS_BORDER | NativeMethods.WS_THICKFRAME;
                    break; 
 
                case WindowBorderStyle.FixedDialog:
                    _startSettings.Style |= NativeMethods.WS_BORDER; 
                    _startSettings.StyleEx |= NativeMethods.WS_EX_DLGMODALFRAME;
                    break;
                case WindowBorderStyle.SizableToolWindow:
                    _startSettings.Style |= NativeMethods.WS_BORDER | NativeMethods.WS_THICKFRAME; 
                    _startSettings.StyleEx |= NativeMethods.WS_EX_TOOLWINDOW;
                    break; 
#endif 
            }
        } 

        // called as a result of title property changing to propagate it to the hwnd
        /// 
        ///     Critical: As this accesses Handle 
        ///     TreatAsSafe: There will be a demand from SetWindowText
        ///  
        [SecurityCritical,SecurityTreatAsSafe] 
        internal virtual void UpdateTitle(string title)
        { 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if ( IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            {
                UnsafeNativeMethods.SetWindowText(new HandleRef(this, CriticalHandle), title); 
            }
        } 
 
        // called as a result of Height/MinHeight/MaxHeight and Width/MinWidth/MaxWidth property changing to update the hwnd size
        ///  
        ///     Critical: This code accesses CriticalHandle
        ///     TreatAsSafe: This code only works under RBW code path , this operation is ok since
        ///     RBW window is bound to the restrictions of its parent window which is the browser
        ///  
        [SecurityCritical, SecurityTreatAsSafe]
        private void UpdateHwndSizeOnWidthHeightChange(double widthLogicalUnits, double heightLogicalUnits) 
        { 
            if (!_inTrustedSubWindow)
            { 
                 SecurityHelper.DemandUIWindowPermission();
            }
            Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull cannot be true when calling this function");
 
            Point ptDeviceUnits = LogicalToDeviceUnits(new Point(widthLogicalUnits, heightLogicalUnits));
            UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle), 
                        new HandleRef(null, IntPtr.Zero), 
                        0,
                        0, 
                        DoubleUtil.DoubleToInt(ptDeviceUnits.X),
                        DoubleUtil.DoubleToInt(ptDeviceUnits.Y),
                        NativeMethods.SWP_NOMOVE | NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE
                        ); 
        }
 
        // Activate or Deactivate window 
        internal void HandleActivate(bool windowActivated)
        { 
            // hamidm -- 12/10/04
            //
            // This method is called by WM_ACTIVATE msg hander for the stand alone
            // window case.  WM_ACTIVATE is sent twice when activating a minimized 
            // window by mouse click; once with window state minimized and then again
            // with window state normal.  Thus, we have the following if conditions 
            // to fire Activated/Deactivated events only if we're activating/deactivating 
            // the window and the window was previously deactivated/activated.
            // 
            // Please look at WOSB 990841 (Activated event fires twice on window when
            // you minimize and restore a window) on this issue.
            //
 
            // Event handler exception continuality: if exception occurs in Activated/Deactivated event handlers, our state will not be
            // corrupted because the state related to Activated/Deactivated, IsActive is set before the event is fired. 
            // Please check Event handler exception continuality if the logic changes. 
            if ((windowActivated == true) && (IsActive == false))
            { 
                SetValue(IsActivePropertyKey, BooleanBoxes.TrueBox);
                OnActivated(EventArgs.Empty);
            }
            else if ((windowActivated == false) && (IsActive == true)) 
            {
                SetValue(IsActivePropertyKey, BooleanBoxes.FalseBox); 
                OnDeactivated(EventArgs.Empty); 
            }
        } 

        internal virtual void UpdateHeight(double newHeight)
        {
            if (WindowState == WindowState.Normal) 
            {
                // We cannot save the current hwnd height in logical units in WmSizeChanged b/c the HwndSource 
                // might not be completely created at that time (when we call new HwndSource from CreateSourceWindowImpl) 
                // and DeviceToLogicalUnits fails.  Thus we convert to logical units here before we call
                // UpdateHwndSizeonWidthHeightChange since that expects logical units. 
                Point sizeLogicalUnits = DeviceToLogicalUnits(new Point(_currentHwndWidthDevicePixels, 0));
                UpdateHwndSizeOnWidthHeightChange(sizeLogicalUnits.X, newHeight);
            }
            else 
            {
                UpdateHwndRestoreBounds(newHeight, BoundsSpecified.Height); 
            } 
        }
 
        internal virtual void UpdateWidth(double newWidth)
        {
            if (WindowState == WindowState.Normal)
            { 
                // We cannot save the current hwnd width in logical units in WmSizeChanged b/c the HwndSource
                // might not be completely created at that time (when we call new HwndSource from CreateSourceWindowImpl) 
                // and DeviceToLogicalUnits fails.  Thus we convert to logical units here before we call 
                // UpdateHwndSizeonWidthHeightChange since that expects logical units.
                Point sizeLogicalUnits = DeviceToLogicalUnits(new Point(0, _currentHwndHeightDevicePixels)); 
                UpdateHwndSizeOnWidthHeightChange(newWidth, sizeLogicalUnits.Y);
            }
            else
            { 
                // set restore width
                UpdateHwndRestoreBounds(newWidth, BoundsSpecified.Width); 
            } 
        }
 
        ///
        /// Critical - This code is used to block off api in rbw
        /// TreatAsSafe - This is critical only because we want to track change
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        internal virtual void VerifyApiSupported() 
        { 
            // don't do anything here since we allow this API in Window.
            // Subclasses can throw exception in their override if 
            // they don't allow the api.
        }
        #endregion Internal Methods
 

        //---------------------------------------------- 
        // 
        // Internal Properties
        // 
        //----------------------------------------------
        #region Internal Properties

        internal bool IsDisposed 
        {
            get 
            { 
                return _disposed;
            } 
        }

        /// 
        /// This tells whether user has set Visible or not. It's currently used in Application 
        /// where if Visibility has not been set when the Window is navigated to, we set it to
        /// Visible 
        ///  
        internal bool IsVisibilitySet
        { 
            get
            {
                VerifyContextAndObjectState();
                return _isVisibilitySet; 
            }
        } 
 
        /// 
        ///     Exposes the hwnd of the window. This property is used by the WindowInteropHandler 
        ///     class
        /// 
        /// 
        ///     Critical: This code exposes handle 
        /// 
        internal IntPtr CriticalHandle 
        { 
            [SecurityCritical]
            get 
            {
                VerifyContextAndObjectState();
                if (_swh != null)
                { 
                    return _swh.CriticalHandle;
                } 
                else 
                return IntPtr.Zero;
            } 
        }

        /// 
        ///     Enables to get/set the owner handle for this window. This property is used by 
        ///     the WindowInteropHelper class
        ///  
        /// 
        ///     This API is currently not available for use in Internet Zone.
        /// 
        ///
        /// Critical - accesses _ownerHandle, calls SetParentHandle.
        /// TreatAsSafe - get/set protected by Demand's.
        /// 
        internal IntPtr OwnerHandle
        { 
            [SecurityCritical,SecurityTreatAsSafe] 
            get
            { 
                SecurityHelper.DemandUIWindowPermission();

                VerifyContextAndObjectState();
                return _ownerHandle; 
            }
            [SecurityCritical, SecurityTreatAsSafe] 
            set 
            {
                SecurityHelper.DemandUIWindowPermission(); 

                VerifyContextAndObjectState();

                if ( _showingAsDialog == true ) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.CantSetOwnerAfterDialogIsShown)); 
                } 

                if (_ownerHandle != value) 
                {
                    _ownerHandle = value;
                    SetParentHandle(value);
                } 
            }
        } 
 
        /// 
        ///     This is used by RBW to set the correct win32 style 
        /// 
        internal int Win32Style
        {
            get 
            {
                VerifyContextAndObjectState(); 
                return _Style; 
            }
            set 
            {
                VerifyContextAndObjectState();

                // The reason this is not wrapped by a manager is that it should never 
                // be invoked outside the scope on an already established manager.
                Debug.Assert(Manager != null, "HwndStyleManager must have a valid value here"); 
                _Style = value; 
            }
        } 

        /// 
        ///    Critical: This code causes style to be set and acceses a critical resource
        ///    TreatAsSafe: There exists a demand on set since SET is not safe 
        /// 
        internal int _Style 
        { 
            get
            { 
                if (Manager != null)
                {
                    return _styleDoNotUse.Value;
 
                }
                else if ( IsSourceWindowNull ) 
                { 
                    return _styleDoNotUse.Value;
 
                }
                else
                {
                    return _swh.StyleFromHwnd; 
                }
            } 
            [SecurityCritical,SecurityTreatAsSafe] 
            set
            { 
                SecurityHelper.DemandUIWindowPermission();
                _styleDoNotUse= new SecurityCriticalDataForSet(value);
                Manager.Dirty = true;
            } 
        }
 
        ///  
        ///    Critical: This code causes style to be set
        ///    TreatAsSafe: There exists a demand on set since SET is not safe 
        /// 
        internal int _StyleEx
        {
            get 
            {
                if (Manager != null) 
                { 
                    return _styleExDoNotUse.Value;
 
                }
                else if (IsSourceWindowNull == true  )
                {
                    return _styleExDoNotUse.Value; 

                } 
                else 
                {
                    return _swh.StyleExFromHwnd; 
                }
                }
            [SecurityCritical, SecurityTreatAsSafe]
            set 
            {
                SecurityHelper.DemandUIWindowPermission(); 
                _styleExDoNotUse= new SecurityCriticalDataForSet((int)value); 
                Manager.Dirty = true;
            } 
        }

        internal HwndStyleManager Manager
        { 
            get { return _manager; }
            set { _manager = value; } 
        } 

        bool IWindowService.UserResized 
        {
            get { return _userResized; }
        }
        #endregion Internal Properties 

        //---------------------------------------------- 
        // 
        // Internal Fields
        // 
        //----------------------------------------------
        #region Internal Fields

        ///  
        /// DialogCancel Command. It closes window if it's dialog and return false as the dialog value.
        ///  
        ///  
        /// Right now this is only used by Cancel Button to close the dialog.
        ///  
        internal static readonly RoutedCommand DialogCancelCommand = new RoutedCommand("DialogCancel", typeof(Window));

        #endregion Internal Fields
 

        //---------------------------------------------- 
        // 
        // Internal Types
        // 
        //----------------------------------------------
        #region Internal Types
        // similar to the one in FE except that it takes care of SizeToContent
        // while determining the min/max values for height and width. 
        internal struct WindowMinMax
        { 
            internal double minWidth; 
            internal double maxWidth;
            internal double minHeight; 
            internal double maxHeight;

            internal WindowMinMax(double minSize, double maxSize)
            { 
                minWidth = minSize;
                maxWidth = maxSize; 
                minHeight = minSize; 
                maxHeight = maxSize;
            } 
        }
        #endregion Internal Types

        //---------------------------------------------- 
        //
        // Private Methods 
        // 
        //----------------------------------------------
        #region Private Methods 
        private Size MeasureOverrideHelper(Size constraint)
        {
            // need to handle infinity
            // return the entire client area of the window 
            // Measure children properly.
 
            // Three primary cases 
            //      1)  hwnd does not exist  -- return 0,0
            //      1a) CompositionTarget is invalid -- return 0,0 
            //      2)  Child visual exists  -- we return child.DesiredSize + frame size
            //      3)  No Child visual      -- return the hwnd size (this should be the same
            //                                  as the one passed into MeasureOverride for our framework)
 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            { 
                // No need to use CompositionTarget.TransformFromDevice
                // since size is 0,0 
                return new Size(0,0);
            }

            if (this.VisualChildrenCount > 0) 
            {
                UIElement child = this.GetVisualChild(0) as UIElement; 
                if (child != null) // UIElement children 
                {
                    // Find out the size of the window frame x. 
                    // (constraint - x) is the size we pass onto
                    // our child

                    Size frameSize = GetHwndNonClientAreaSizeInMeasureUnits(); 

                    // In some instances (constraint size - frame size) can be negative. One instance 
                    // is when window is set to minimized before layout has happened.  Apparently, Win32 
                    // gives a rect(-32000, -32000, -31840, -31975) for GetWindowRect when hwnd is
                    // minimized.  However, when we calculate the frame size we get width = 8 and 
                    // height = 28!!!  Here, we will take the max of zero and the difference b/w the
                    // hwnd size and the frame size
                    //
                    // PS Windows OS Bug: 955861 
                    Size childConstraint = new Size();
                    childConstraint.Width = ((constraint.Width == Double.PositiveInfinity) ? Double.PositiveInfinity : Math.Max(0.0, (constraint.Width - frameSize.Width))); 
                    childConstraint.Height = ((constraint.Height == Double.PositiveInfinity) ? Double.PositiveInfinity : Math.Max(0.0, (constraint.Height - frameSize.Height))); 

                    child.Measure(childConstraint); 
                    Size childDesiredSize = child.DesiredSize;
                    return new Size(childDesiredSize.Width + frameSize.Width, childDesiredSize.Height + frameSize.Height);
                }
            } 

            // if we reach here, we return the input size 
            return _swh.GetSizeFromHwndInMeasureUnits(); 
        }
 
        // Similar logic as in FE.MinMax and takes care of max/min size allowed by win32 for the hwnd.  However, we
        // don't take Height/Width into consideration.  This is because of the following reasons:
        //
        // 1) Window Height/Width info doesn't matter here since we just need to ensure that the child element is 
        //    layed out within the Max/Min restrictions of the window.  Window is layed out at the size sent into MO/AO
        //    and Height and Width of the window does not play a part MO/AO stage. 
        // 
        // 2) We had WOSB 1399028 FlowDocumentReader: When the maximise button is clicked on the window with FDR the
        //    content don't reflow to fill in the entire window) and the fix for that is to simply not use H/W here. 
        //    GetWindowMinMax fixes the following bugs:
        //
        //    WOSB 1330752 Window content should respect Window's Max/Min size
        //    WOSB 1030000 Wrong window actual size returned if Autosize window content is smaller than the actual 
        //    window (seems to return content size as opposed to window size)
        // 
        //  This method is called by both MeasureOverride( ) and WmGetMinMaxInfo( ). 
        //  It will calculate a final Min/Max size in logic units for this HWND based on Win32 restricted value and
        //  current Min/Max setting in this instance. 
        //
        internal virtual WindowMinMax GetWindowMinMax()
        {
            WindowMinMax mm = new WindowMinMax( ); 

            Invariant.Assert(IsCompositionTargetInvalid == false, "IsCompositionTargetInvalid is supposed to be false here"); 
 
            // convert the max/min size (taken in to account the hwnd size restrictions by win32) into logical units
            Point trackMaxSizeLogicalUnits = DeviceToLogicalUnits(new Point(_trackMaxWidthDeviceUnits, _trackMaxHeightDeviceUnits)); 
            Point trackMinSizeLogicalUnits = DeviceToLogicalUnits(new Point(_trackMinWidthDeviceUnits, _trackMinHeightDeviceUnits));

            //
            // Get the final Min/Max Width 
            //
            mm.minWidth = Math.Max(this.MinWidth, trackMinSizeLogicalUnits.X); 
 
            // Min's precedence is higher than Max; If Min is greater than Max, use Min.
            if (MinWidth > MaxWidth) 
            {
                mm.maxWidth = Math.Min(MinWidth, trackMaxSizeLogicalUnits.X);
            }
            else 
            {
                if (!Double.IsPositiveInfinity(MaxWidth)) 
                { 
                    mm.maxWidth = Math.Min(MaxWidth, trackMaxSizeLogicalUnits.X);
                } 
                else
                {
                    mm.maxWidth = trackMaxSizeLogicalUnits.X;
                } 
            }
 
            // 
            // Get the final Min/Max Height
            // 
            mm.minHeight = Math.Max(this.MinHeight, trackMinSizeLogicalUnits.Y);

            // Min's precedence is higher than Max; If Min is greater than Max, use Min.
            if (MinHeight > MaxHeight) 
            {
                mm.maxHeight = Math.Min(this.MinHeight, trackMaxSizeLogicalUnits.Y); 
            } 
            else
            { 
                if (!Double.IsPositiveInfinity(MaxHeight))
                {
                    mm.maxHeight = Math.Min(MaxHeight, trackMaxSizeLogicalUnits.Y);
                } 
                else
                { 
                    mm.maxHeight = trackMaxSizeLogicalUnits.Y; 
                }
            } 

            return mm;
        }
 
        private void LoadedHandler(object sender, RoutedEventArgs e)
        { 
            if (_postContentRenderedFromLoadedHandler == true) 
            {
                PostContentRendered(); 
                _postContentRenderedFromLoadedHandler = false;
                this.Loaded -= new RoutedEventHandler(LoadedHandler);
            }
        } 

        ///  Keep this method in [....] with Frame.PostContentRendered().  
        private void PostContentRendered() 
        {
            // Post the firing of ContentRendered as Input priority work item so 
            // that ContentRendered will be fired after render query empties.
            if (_contentRenderedCallback != null)
            {
                // Content was changed again before the previous rendering completed (or at least 
                // before the Dispatcher got to Input priority callbacks).
                _contentRenderedCallback.Abort(); 
            } 
            _contentRenderedCallback = Dispatcher.BeginInvoke(DispatcherPriority.Input,
                                   (DispatcherOperationCallback) delegate (object unused) 
                                   {
                                       // Event handler exception continuality: there are no state related/depending on ContentRendered event.
                                       // If an exception occurs in event handler, our state will not be corrupted.
                                       // Please check event handler exception continuality if the logic changes. 
                                       _contentRenderedCallback = null;
                                       OnContentRendered(EventArgs.Empty); 
                                       return null; 
                                   },
                                   this); 
        }

        /// 
        /// Ensure Dialog command is registered with the CommandManager 
        /// 
        private void EnsureDialogCommand() 
        { 
            // _dialogCommandAdded is a static variable, however, we're not synchronizing
            // access to it.  The reason is that, CommandManager is thread safe and according 
            // to KiranKu we don't want to take the overhead of locking here.  For multiple
            // threaded cases, we could end up calling the CommandManager more than once but
            // KiranKu is okay with that perf hit in the corner case.
            if (!_dialogCommandAdded) 
            {
                // Right now we only have DialogCancel Command, which closes window if it's dialog and return false as the dialog's result. 
                CommandBinding binding = new CommandBinding(DialogCancelCommand); 
                binding.Executed += new ExecutedRoutedEventHandler(OnDialogCommand);
                CommandManager.RegisterClassCommandBinding(typeof(Window), binding); 

                _dialogCommandAdded = true;
            }
        } 

        ///  
        /// Dialog Command Execute handler 
        /// Right now we only have DialogCancel Command, which closes window if it's dialog and return false for DialogResult.
        ///  
        /// 
        /// 
        private static void OnDialogCommand(object target, ExecutedRoutedEventArgs e)
        { 
            //close dialog & return result
            Window w = target as Window; 
 
            Debug.Assert(w != null, "Target must be of type Window.");
            w.OnDialogCancelCommand(); 
        }

        /// 
        /// Close window if it's dialog and return false for DialogResult. 
        /// 
        private void OnDialogCancelCommand() 
        { 
            if (_showingAsDialog)
            { 
                DialogResult = false;
            }
        }
 
        /// 
        /// The callback function for EnumThreadWindows 
        ///  
        /// 
        ///  
        /// 
        private bool ThreadWindowsCallback(IntPtr hWnd, IntPtr lparam)
        {
            Debug.Assert(_threadWindowHandles != null, "_threadWindowHandles must not be null at this point"); 

            // the dialog's hwnd has not been created yet when calling into this function. 
            // so its hwnd won't be in the list. 

            // We only do visible && enabled windows. 
            // We need to check Visible because there might be hidden windows that do message looping,
            // We don't want to disable them.
            if (SafeNativeMethods.IsWindowVisible(new HandleRef(null, hWnd)) &&
                SafeNativeMethods.IsWindowEnabled(new HandleRef(null, hWnd))) 
            {
                _threadWindowHandles.Add(hWnd); 
            } 

            return true; 
        }

        /// 
        /// Enables/disables all Windows on this thread 
        /// 
        ///  
        ///  
        ///     Critical: This code calls into IsWindow and EnableWindow
        ///  
        [SecurityCritical]
        private void EnableThreadWindows(bool state)
        {
 
            Debug.Assert(_threadWindowHandles != null, "_threadWindowHandles must not be null at this point");
 
            for (int i = 0; i < _threadWindowHandles.Count; i++) 
            {
                IntPtr hWnd = (IntPtr)_threadWindowHandles[i]; 

                if (UnsafeNativeMethods.IsWindow(new HandleRef(null, hWnd)))
                {
                    // Calls EnableWindow which returns the previous Window state 
                    // (enable/disable) and we don't care about that here
#pragma warning disable 6523 
                    UnsafeNativeMethods.EnableWindowNoThrow(new HandleRef(null, hWnd), state); 
#pragma warning enable 6523
 
                }
            }

            // EnableThreadWindows is called with true only when dialog is going away.  Now 
            // we've enabled the windows that we had earlier disabled; thus, disposing
            // _threadWindowHandles. 
            if (state == true) 
            {
                _threadWindowHandles = null; 
            }
        }

        ///  
        /// Intialization when Window is constructed
        ///  
        ///     Initializes the Width/Height, Top/Left properties to use windows 
        ///     default. Updates Application object properties if inside app.
        /// 
        ///     Also, window style is set to WS_CHILD inside CreateSourceWindow
        ///     for browser hosted case
        private void Initialize()
        { 
            // AVTempUIPermission avtUIPermission = new AVTempUIPermission(AVTUIPermissionNewWindow.LaunchNewWindows);
            // CASRemoval:avtUIPermission.Demand(); 
 
            //  this makes MeasureCore / ArrangeCore to defer to direct MeasureOverride and ArrangeOverride calls
            //  without reading Width / Height properties and modifying input constraint size parameter... 
            BypassLayoutPolicies = true;

            // check if within an app && on the same thread
            if (IsInsideApp == true) 
            {
                if (Application.Current.Dispatcher.Thread == Dispatcher.CurrentDispatcher.Thread) 
                { 
                    // add to window collection
                    // use internal version since we want to update the underlying collection 
                    App.WindowsInternal.Add(this);
                    if (App.MainWindow == null)
                    {
                        App.MainWindow = this; 
                    }
                } 
                else 
                {
                    App.NonAppWindowsInternal.Add(this); 
                }
            }
        }
 

        internal void VerifyContextAndObjectState() 
        { 
            // Verify that we are executing on the right context
            VerifyAccess(); 

        //

 
#if DISPOSE
            if (_disposed) 
            { 
                throw new ObjectDisposedException(null, SR.Get(SRID.WindowDisposed));
            } 
#endif
        }

        private void VerifyCanShow() 
        {
            if (_disposed == true) 
            { 
                throw new InvalidOperationException(SR.Get(SRID.ReshowNotAllowed));
            } 
        }

        private void VerifyNotClosing()
        { 
            if (_isClosing == true)
            { 
                throw new InvalidOperationException(SR.Get(SRID.InvalidOperationDuringClosing)); 
            }
 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == true)
            {
                throw new InvalidOperationException(SR.Get(SRID.InvalidCompositionTarget));
            } 
        }
 
        ///  
        ///     sets the IWindowService attached property
        ///  
        private void SetIWindowService()
        {
            if (GetValue(IWindowServiceProperty) == null)
            { 
                SetValue(IWindowServiceProperty, (IWindowService)this);
            } 
        } 

        /// 
        ///     Critical - calls a method that elevates - GetCursorPos
        ///     TreatAsSafe - as there's a demand.
        ///
        [SecurityCritical, SecurityTreatAsSafe] 
        IntPtr GetCurrentMonitorFromMousePosition()
        { 
            SecurityHelper.DemandUnmanagedCode(); 
            // center on the screen on which the mouse is on
            NativeMethods.POINT pt = new NativeMethods.POINT(); 

            UnsafeNativeMethods.TryGetCursorPos(pt);

            NativeMethods.POINTSTRUCT ptStruct = new NativeMethods.POINTSTRUCT(pt.x, pt.y); 
            return SafeNativeMethods.MonitorFromPoint(ptStruct, NativeMethods.MONITOR_DEFAULTTONEAREST);
        } 
 
        // 
        //     Calculates the window location based on the WindowStartupLocation property 
        //     If values for CenterScreen, CenterOwner cannot be determined, then we return
        //     unmodified values.
        // 
        //  
        //     This method can be called before or after the hwnd is created.  So, we have
        //     to accout for both scenarios. 
        //  
        // 
        //  
        // 
        /// 
        ///     Critical: This code accesses handle and calls critical method GetNormalRectDeviceUnits
        ///     TreatAsSafe: This data is ok to give out 
        /// 
        [SecurityCritical,SecurityTreatAsSafe] 
        private bool CalculateWindowLocation(ref double leftDeviceUnits, ref double topDeviceUnits, Size currentSizeDeviceUnits) 
        {
            Debug.Assert(IsSourceWindowNull == false, "_swh should not be null here"); 
            double inLeft = leftDeviceUnits;
            double inTop = topDeviceUnits;

            switch (_windowStartupLocation) 
            {
                case WindowStartupLocation.Manual: 
                    break; 
                case WindowStartupLocation.CenterScreen:
                    // NOTE: hamidm 05/19/04 
                    // Bug (Windows OS Bugs) # 843790 -- Which screen to center the
                    // window on?
                    //
                    // If Window has a parent handle, then center the Window on the 
                    // same monitor as the parent hwnd.  If theres no parent hwnd,
                    // center the Window on the monitor where the mouse is currently 
                    // on. 
                    //
                    // The exception to this rule is when ShowInTaskbar is set to false 
                    // and we parent to window to achieve that.  That's the reason for
                    // having the extra condition in the if statement below
                    //
 
                    IntPtr hMonitor = IntPtr.Zero;
                    if ((_ownerHandle == IntPtr.Zero) || 
                        ((_hiddenWindow != null) && (_hiddenWindow.Handle == _ownerHandle))) 
                    {
                        hMonitor = GetCurrentMonitorFromMousePosition(); 
                    }
                    else
                    {
                        // have a parent hwnd; center on the screen on 
                        // which our parent hwnd is.
                        hMonitor = SafeNativeMethods.MonitorFromWindow(new HandleRef(this, _ownerHandle), NativeMethods.MONITOR_DEFAULTTONEAREST); 
                    } 

                    if (hMonitor != IntPtr.Zero) 
                    {
                        CalculateCenterScreenPosition(new HandleRef(this, hMonitor), currentSizeDeviceUnits, ref leftDeviceUnits, ref topDeviceUnits);
                    }
                    break; 
                case WindowStartupLocation.CenterOwner:
                    Rect ownerRectDeviceUnits = Rect.Empty; 
 
                    // If the owner is WPF window. The owner can be non-WPF window. It can be set via WindowInteropHelper.Owner.
                    if (CanCenterOverWPFOwner == true) 
                    {
                        // if owner hwnd is created, we use ActualWidth/Height to get its size
                        // otherwise we use Width/Height
                        double ownerWidthLogicalUnits = (Owner.CriticalHandle == IntPtr.Zero ? Owner.Width : Owner.ActualWidth); 
                        double ownerHeightLogicalUnits = (Owner.CriticalHandle == IntPtr.Zero ? Owner.Height : Owner.ActualHeight);
 
                        Point ownerSizeDeviceUnits = Owner.LogicalToDeviceUnits(new Point(ownerWidthLogicalUnits, ownerHeightLogicalUnits)); 
                        // A minimized window doesn't have valid Top,Left; that's why RestoreBounds.TopLeft is used.
                        Point ownerLocationDeviceUnits = Owner.LogicalToDeviceUnits( 
                            Owner.WindowState == WindowState.Minimized ?
                                Owner.RestoreBounds.TopLeft : new Point(Owner.Left, Owner.Top));

                        ownerRectDeviceUnits = new Rect(ownerLocationDeviceUnits.X, ownerLocationDeviceUnits.Y, 
                                            ownerSizeDeviceUnits.X, ownerSizeDeviceUnits.Y);
                    } 
                    else 
                    {
                        // non-WPF owner 
                        if ((_ownerHandle != IntPtr.Zero) && UnsafeNativeMethods.IsWindow(new HandleRef(null, _ownerHandle)))
                        {
                            ownerRectDeviceUnits = GetNormalRectDeviceUnits(_ownerHandle);
                        } 
                    }
 
                    if (! ownerRectDeviceUnits.IsEmpty) 
                    {
                        leftDeviceUnits = ownerRectDeviceUnits.X + ((ownerRectDeviceUnits.Width - currentSizeDeviceUnits.Width) / 2); 
                        topDeviceUnits = ownerRectDeviceUnits.Y + ((ownerRectDeviceUnits.Height - currentSizeDeviceUnits.Height) / 2);
                    }
                    break;
                default: 
                    break;
            } 
            return (!DoubleUtil.AreClose(inLeft, leftDeviceUnits) || !DoubleUtil.AreClose(inTop, topDeviceUnits)); 
        }
 

        /// 
        /// Calculates the left and right coordinates of a window
        /// when centered on a given monitor. 
        /// 
        /// Handle to the monitor to center the window on 
        /// Size of the window, in device units 
        /// Receives the new left location in device units
        /// Receives the new top location in device units 
        internal static void CalculateCenterScreenPosition(HandleRef hMonitor, Size currentSizeDeviceUnits, ref double leftDeviceUnits, ref double topDeviceUnits)
        {
            NativeMethods.MONITORINFOEX monitorInfo = new NativeMethods.MONITORINFOEX();
            monitorInfo.cbSize = SecurityHelper.SizeOf(typeof(NativeMethods.MONITORINFOEX)); 

            SafeNativeMethods.GetMonitorInfo(hMonitor, monitorInfo); 
            NativeMethods.RECT workAreaRectDeviceUnits = monitorInfo.rcWork; 

            // We're using Width/Height here as opposed to ActualWidth/Height 
            // as layout hasn't happened yet.
            double workAreaWidthDeviceUnits = workAreaRectDeviceUnits.right - workAreaRectDeviceUnits.left;
            double workAreaHeightDeviceUnits = workAreaRectDeviceUnits.bottom - workAreaRectDeviceUnits.top;
 
            Debug.Assert(workAreaWidthDeviceUnits >= 0, String.Format("workAreaWidth ({0})for monitor ({1}) is negative", hMonitor, workAreaWidthDeviceUnits));
            Debug.Assert(workAreaHeightDeviceUnits >= 0, String.Format("workAreaHeight ({0}) for monitor ({1}) is negative", hMonitor, workAreaHeightDeviceUnits)); 
 
            leftDeviceUnits = (workAreaRectDeviceUnits.left + ((workAreaWidthDeviceUnits - currentSizeDeviceUnits.Width) / 2));
            topDeviceUnits = (workAreaRectDeviceUnits.top + ((workAreaHeightDeviceUnits - currentSizeDeviceUnits.Height) / 2)); 
        }

        private bool CanCenterOverWPFOwner
        { 
            get
            { 
                Debug.Assert(IsSourceWindowNull == false, "_swh should not be null here"); 

                // if Owner is null, we cannot CenterOwner 
                if (Owner == null)
                {
                    return false;
                } 

                // if Owner._sourceWindow is null, and if Owner's Width or Height is not specified 
                // then we cannot CenterOwner 
                if (Owner.IsSourceWindowNull)
                { 
                    if ((DoubleUtil.IsNaN(Owner.Width)) ||
                        (DoubleUtil.IsNaN(Owner.Height)))
                    {
                        return false; 
                    }
                } 
 
                // if Owner's Top or Left is not specified, we cannot CenterOwner
                if ((DoubleUtil.IsNaN(Owner.Left)) || 
                    (DoubleUtil.IsNaN(Owner.Top)))
                {
                    return false;
                } 
                return true;
            } 
        } 

        /// 
        ///     Critical - calls a method that elevates - GetWindowLong, GetWindowPlacement
        ///
        [SecurityCritical]
        private Rect GetNormalRectDeviceUnits(IntPtr hwndHandle) 
        {
            int styleEx = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, hwndHandle), NativeMethods.GWL_EXSTYLE); 
 
            NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT();
            wp.length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT)); 
            UnsafeNativeMethods.GetWindowPlacement(new HandleRef(this, hwndHandle), ref wp);
            Point locationDeviceUnits = new Point(wp.rcNormalPosition_left, wp.rcNormalPosition_top);

            // GetWindowPlacement returns workarea co-ods for a top level window whose 
            // WS_EX_TOOLWINDOW bit is clear.  If this bit is set, then the co-ods
            // returned are relative to the screen co-ods of the monitor. 
            // TransfromWorkAreaScreenArea can transform a point from work area co-ods 
            // to screen area co-ods and vice versa depending on TransformType value passed.
            // So, in our case, if the window is not a ToolWindow we want to transform 
            // the point from work area co-ods to screen co-ods.
            if ((styleEx & NativeMethods.WS_EX_TOOLWINDOW) == 0)
            {
                locationDeviceUnits = TransformWorkAreaScreenArea(locationDeviceUnits, TransformType.WorkAreaToScreenArea); 
            }
 
            Point sizeDeviceUnits = new Point(wp.rcNormalPosition_right - wp.rcNormalPosition_left, 
                                              wp.rcNormalPosition_bottom - wp.rcNormalPosition_top);
 
            return new Rect(locationDeviceUnits.X, locationDeviceUnits.Y, sizeDeviceUnits.X, sizeDeviceUnits.Y);
        }

        /// 
        ///     Critical - calls critical method GetNormalRectDeviceUnits
        /// 
        [SecurityCritical] 
        private Rect GetNormalRectLogicalUnits(IntPtr hwndHandle)
        { 
            Rect rectDeviceUnits = GetNormalRectDeviceUnits(hwndHandle);

            Point sizeLogicalUnits = DeviceToLogicalUnits(new Point(rectDeviceUnits.Width, rectDeviceUnits.Height));
            Point locationLogicalUnits = DeviceToLogicalUnits(new Point(rectDeviceUnits.X, rectDeviceUnits.Y)); 

            return new Rect(locationLogicalUnits.X, locationLogicalUnits.Y, sizeLogicalUnits.X, sizeLogicalUnits.Y); 
        } 

        ///  
        ///     Update style bits for window state
        /// 
        private void CreateWindowState()
        { 
            switch (WindowState)
            { 
                case WindowState.Normal: 
                    break;
                case WindowState.Maximized: 
                    _Style |= NativeMethods.WS_MAXIMIZE;
                    break;
                case WindowState.Minimized:
                    _Style |= NativeMethods.WS_MINIMIZE; 
                    break;
#if THEATRE_FULLSCREEN 
                case WindowState.Theatre: 
                    throw new NotImplementedException(SR.Get(SRID.NotImplementedException));
 
                case WindowState.FullScreen:
                    throw new NotImplementedException(SR.Get(SRID.NotImplementedException));
#endif //THEATRE_FULLSCREEN
            } 
        }
 
        ///  
        ///     creates topmost window
        ///  
        private void CreateTopmost()
        {
            // check for topmost
            if ( Topmost ) 
            {
                _StyleEx |= NativeMethods.WS_EX_TOPMOST; 
            } 
            else
            { 
                _StyleEx &= ~NativeMethods.WS_EX_TOPMOST;
            }
        }
 
        /// 
        ///     set's resizibility for the window 
        ///  
        private void CreateResizibility()
        { 
            _Style &= ~(NativeMethods.WS_THICKFRAME | NativeMethods.WS_MAXIMIZEBOX | NativeMethods.WS_MINIMIZEBOX);


            switch(ResizeMode) 
            {
                case ResizeMode.NoResize: 
                    break; 
                case ResizeMode.CanMinimize:
                    _Style |= NativeMethods.WS_MINIMIZEBOX; 
                    break;
                case ResizeMode.CanResize:
                case ResizeMode.CanResizeWithGrip:
                    _Style |= NativeMethods.WS_THICKFRAME | NativeMethods.WS_MAXIMIZEBOX | NativeMethods.WS_MINIMIZEBOX; 
                    break;
                default: 
                    Debug.Assert(false, "Invalid value for ResizeMode"); 
                    break;
            } 
        }

        /// 
        ///     Updates the window icon 
        /// 
        /// 
        /// Critical as we perform an elevation - ( UnsafeNativeMethods.SendMessage) will have a SUC on it soon. 
        /// TreatAsSafe: This method ok to use on window and does nothing on RBW.
        /// 
        //

        [SecurityCritical, SecurityTreatAsSafe]
        private void UpdateIcon() 
        {
 
            // NOTE: hamidm -- bug 963275 AppModel: Set Window.Icon = null 
            // causes NullReferenceException
 
            // if _icon is null, set _defaultLargeIconHandle and _defaultSmallIconHandle
            //  to the app icon (embedded in the exe).  _icon is used as window icon if it
            // is not null, else default icons from exe are used.  If both are null,
            // we set IntPtr.Zero as the icons for the window and Win32 defaults 
            // come into play.
            // 
 
            NativeMethods.IconHandle largeIconHandle = new NativeMethods.IconHandle();
            NativeMethods.IconHandle smallIconHandle = new NativeMethods.IconHandle(); 


            if (_icon != null)
            { 
                IconHelper.GetIconHandlesFromBitmapFrame(this, _icon, ref largeIconHandle, ref smallIconHandle);
            } 
            else 
            {
                // these both should be null before we've queried that exe for icons. 
                // Once, we looked in the exe, these are no longer null and hence we
                // don't want to re-query in the exe anymore
                if (_defaultLargeIconHandle == null && _defaultSmallIconHandle == null)
                { 
                     // sets the default small and large icon handles
                     IconHelper.GetDefaultIconHandles(this, ref largeIconHandle, ref smallIconHandle); 
                    _defaultLargeIconHandle = largeIconHandle; 
                    _defaultSmallIconHandle = smallIconHandle;
                } 
                else
                {
                    largeIconHandle = _defaultLargeIconHandle;
                    smallIconHandle = _defaultSmallIconHandle; 
                }
                // get default icons 
            } 

 
            UnsafeNativeMethods.SendMessage(
                                    new HandleRef(this, CriticalHandle),
                                    NativeMethods.WM_SETICON,
                                    (IntPtr)NativeMethods.ICON_BIG, 
                                    largeIconHandle);
 
            UnsafeNativeMethods.SendMessage( 
                                    new HandleRef(this, CriticalHandle),
                                    NativeMethods.WM_SETICON, 
                                    (IntPtr)NativeMethods.ICON_SMALL,
                                    smallIconHandle);

            // dispose the previous icon handle if it's not the default handle 
            if (_currentLargeIconHandle != null && _currentLargeIconHandle != _defaultLargeIconHandle)
            { 
                _currentLargeIconHandle.Dispose(); 
            }
 
            if (_currentSmallIconHandle != null && _currentSmallIconHandle != _defaultSmallIconHandle)
            {
                _currentSmallIconHandle.Dispose();
            } 

            _currentLargeIconHandle = largeIconHandle; 
            _currentSmallIconHandle = smallIconHandle; 
        }
 
        /// 
        ///     Sets the parent hwnd for this window. This could be called as a result of
        ///     setting one of the following
        /// 
        ///         Window Owner {set;}
        ///         IntPtr OwnerHandle {set;}  -- this is used by WindowInteropHelper 
        ///  
        /// IntPtr of the parent window
        /// 
        /// Critical - sets _ownerHandle to the value got as a param
        ///
        [SecurityCritical]
        private void SetParentHandle(IntPtr parentHandle) 
        {
            // Note: hamidm 9/1/2005 
            // 1278098 "SetWindowLong failed.  Error = 1400" appears in console when setting 
            // Window.Owner to a Window hasn't been shown (chk build)
            // 
            // SetWindowLong with GWL_HWNDPARENT fails if the new parent/owner is IntPtr.Zero
            // and the old owner was also IntPtr.Zero.  The if check below works around this
            // issue.
 
            if (_ownerHandle == parentHandle)
            { 
                return; 
            }
 
            _ownerHandle = parentHandle;

            if ( IsSourceWindowNull == false)
            { 

                UnsafeNativeMethods.SetWindowLong(new HandleRef(null, CriticalHandle), 
                    NativeMethods.GWL_HWNDPARENT, 
                    _ownerHandle);
 
                // Update and reset the Owner Window if this is set through WindowInteropHelper.
                // We want to do this because once we are passed in the IntPtr for
                // the parent window, the Owner window is not the parent anymore.
 
                if ( (_ownerWindow != null) && (_ownerWindow.CriticalHandle != _ownerHandle) )
                { 
                    _ownerWindow.OwnedWindowsInternal.Remove(this); 
                    _ownerWindow = null;
                } 
            }
        }

        ///  
        ///     This is called back into when HwndSouce being used by this object is disposed, or if the
        ///     hwnd is destroyed. 
        /// 
        ///     When that happens on the same thread, we receive WM_CLOSE, WM_DESTROY and
        ///     everything works fine.  However, if that happened on another thread, we don't get 
        ///     WM_CLOSE, WM_DESTROY until later, but we get this disposed callback and we
        ///     set dispose this object.  If we don't do this, there could be timing related issues if
        ///     we get called into after the HwndSource or hwnd has been disposed/destoyed but before
        ///     we receive WM_CLOSE, WM_DESTROY messages. 
        /// 
        ///  
        ///  
        /// 
        /// 
        ///     Critical: Is used to dispose of the native handles which link demands in safe handle via the call to
        ///     InternalDispose
        ///
        [SecurityCritical] 
        private void OnSourceWindowDisposed(object sender, EventArgs e)
        { 
            if ( _disposed == false) 
            {
                InternalDispose(); 
            }
        }

        ///  
        ///     This is the hook to HwndSource that is called when window messages related to
        ///     this window occur. Currently, we listen to the following messages 
        /// 
        ///         WM_CLOSE        : We listen to this message in order to fire the Closing event.
        ///                           If the user cancels window closing, we set handled to true so 
        ///                           that the DefWindowProc does not handle this message. Otherwise,
        ///                           we set handled to false.
        ///         WM_DESTROY      : We listen to this message in order to fire the Closed event.
        ///                           Handled is always set to false. 
        ///         WM_ACTIVATE     : Used for Activated and deactivated events
        ///         WM_SIZE         : Used for SizeChanged, StateChanged events. Also, helps us keep our 
        ///                           size updated 
        ///         WM_MOVE:        : Used for location changed event and to keep our cached top/left
        ///                           updated 
        ///         WM_GETMINMAXINFO: Used to enforce Max/MinHeight and Max/MinWidth
        /// 
        /// 
        ///  
        /// 
        ///  
        ///  
        /// 
        /// 
        ///     Critical: Calls critical code: Window.WmClose()
        ///
        [SecurityCritical]
        private IntPtr WindowFilterMessage( IntPtr hwnd, 
            int msg,
            IntPtr wParam, 
            IntPtr lParam, 
            ref bool handled)
        { 
            IntPtr retInt = IntPtr.Zero ;

            // hamidm - 10/27/2005
            // we need to process WM_GETMINMAXINFO before _swh is assigned to 
            // b/c we want to store the max/min size allowed by win32 for the hwnd
            // which is later used in GetWindowMinMax.  WmGetMinMaxInfo can handle 
            // _swh == null case. 
            switch (msg)
            { 
                case NativeMethods.WM_GETMINMAXINFO:
                    handled = WmGetMinMaxInfo(lParam);
                    break;
                case NativeMethods.WM_SIZE: 
                    handled = WmSizeChanged(wParam, lParam);
                    break; 
            } 

            if(_swh != null && _swh.CompositionTarget != null) // For extraneous messages during shutdown 
            {
                switch (msg)
                {
                    case NativeMethods.WM_CLOSE: 
                        handled = WmClose();
                        break; 
                    case NativeMethods.WM_DESTROY: 
                        handled = WmDestroy();
                        break; 
                    case NativeMethods.WM_ACTIVATE:
                        handled = WmActivate(wParam);
                        break;
                    case NativeMethods.WM_ENTERSIZEMOVE: 
                        // If we are here, it means user is resizing.
                        // We do want to set Top&Left Width&Height local values when user resizes. 
                        // We don't get this message when user maximizes or minimizes. 
                        // We don't set local values when user maximizes or minimized.
                        _inUserSizeMove = true; 
                        _userResized = true;
                        handled = false;
                        break;
                    case NativeMethods.WM_EXITSIZEMOVE: 
                        // User resizing over.
                        _inUserSizeMove = false; 
                        handled = false; 
                        break;
                    case NativeMethods.WM_MOVE: 
                        handled = WmMoveChanged(hwnd, lParam);
                        break;
                    case NativeMethods.WM_NCHITTEST:
                        handled = WmNcHitTest(lParam, ref retInt); 
                        break;
                    case NativeMethods.WM_SHOWWINDOW: 
                        handled = WmShowWindow(wParam, lParam); 
                        break;
                    default: 
                        handled = false;
                        break;
                }
            } 

            return retInt; 
        } 

        ///  
        ///     Called on WM_CLOSE message. Fires the Closing event.
        /// 
        /// 
        ///     True if we want to stop the window from closing, else false 
        /// 
        private bool WmClose() 
        { 
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called
            // synchronously from CreateWindowEx call and we run into issues if 
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want
            // to explicitly add the null check below at all other places.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            { 
                return false;
            } 

            // if DialogResult is set from within a Closing event then
            // the window is in the closing state.  In such a case, we
            // should not call Close() from DialogResult.set and thus 
            // we have this variable.
            // 
            // Note: Windows OS bug # 934500 Setting DialogResult 
            // on the Closing EventHandler of a Dialog causes StackOverFlowException
            _isClosing = true; 

            // Event handler exception continuality: if exception occurs in Closing event handler, the
            // cleanup action is to finish closing.
            CancelEventArgs e = new CancelEventArgs(false); 
            try
            { 
                OnClosing(e); 
            }
            catch 
            {
                CloseWindowFromWmClose();
                throw;
            } 

            if (ShouldCloseWindow(e.Cancel)) 
            { 
                CloseWindowFromWmClose();
                return false; 
            }
            else
            {
                // close cancelled 
                _isClosing = false;
 
                // 03/14/2006 -- hamidm 
                // WOSB 1560557 Dialog does not close with ESC key after it has been cancelled
                // 
                // Since closing is cancelled, DialogResult should be reset to null b/c
                // 1) DialogResult = true/false means that dialog has been accepeted/rejected (since dialog didn't
                //                   close (closing cancelled), DialogResult should be null)
                _dialogResult = null; 

                return true; 
            } 
        }
 
        private void CloseWindowFromWmClose()
        {
            if (_showingAsDialog)
            { 
                DoDialogHide();
            } 
 
            // We should ClearRootVisual here instead of in InternalDispose. InternalDispose is called either as a result of HwndSource
            // disposing itself or it will try to dispose HwndSource. HwndSource will clear the root visual when it is disposed. 
            ClearRootVisual();

            // We should also ClearHiddenWindow here, because in InternalDispose the window handle could be null if the dispose happens as
            // a result of HwndSource dispose. Our InternalDispose has been changed to handle reantrance, so the issue (bug 953988) described in 
            // ClearHiddenWindowIfAny should not happen any more.
            ClearHiddenWindowIfAny(); 
        } 

        private bool ShouldCloseWindow(bool cancelled) 
        {
            // if shutdown Closing cannot be cancelled
            // if parent window is closing, child window Closing cannot be cancelled.
            return ((!cancelled) || (_appShuttingDown) || (_ignoreCancel)); 
        }
 
        ///  
        /// Critical - This code calls EnableThreadWindows and accesses _dialogPreviousActiveHandle
        /// TreatAsSafe - There is a demand for unmanaged code 
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        private void DoDialogHide()
        { 
            SecurityHelper.DemandUnmanagedCode();
 
            Debug.Assert(_showingAsDialog == true, "_showingAsDialog must be true when DoDialogHide is called"); 

            bool wasActive = false; 

            //It's possible that _dispatcherFrame could be null at this time.
            //The scenario is: When showing the window as a modal dialog, the window Activated event is fired
            //before _dispatcherFrame is instantiated. In the Activated handler, if user closes the 
            //window (setting DialogResult fires the WM_CLOSE event), the _dispatcherFrame is still null.
            //Bug 874463 addressed this. 
            if (_dispatcherFrame != null) 
            {
                // un block the push frame call 
                _dispatcherFrame.Continue = false;
                _dispatcherFrame = null;
            }
 
            // 03/03/2006 -- hamidm
            // Fix for 1388606 Close Dialog Window should not return null 
            // 
            // The consensus here is that DialogResult should never be null when ShowDialog returns
            // As such, we coerce it to be false.  Furthermore, we don't use the DialogResult property 
            // to update _dialogResult here since that does more than just updating the underlying
            // variable
            if (_dialogResult == null)
            { 
                _dialogResult = false;
            } 
 
            // clears _showingAsDialog
            _showingAsDialog = false; 

            // enable previous window stuff goes here...
            wasActive = _swh.IsActiveWindow;
 
            // NOTE: hamidm -- 01/22/04
            // We assert here b/c I think _threadWindowHandles should never be null when we get 
            // called in here. 
            //
            // However, if inside ShowDialog we hit an exception after showing the dialog and the 
            // exception handler is run, then _threadWindowHandles will be null here.
            //
            // Keeping this as assert.  If this turn out to be an over active assert, we'll switch to
            // an if condition. 
            Debug.Assert(_threadWindowHandles != null, "_threadWindowHandles must not be null at this point");
            // reenable windows in the thread that were disabled 
            EnableThreadWindows(true); 

            // if dialog that is closing was active window and there was a previously active window, 
            // set the active window.  The owner window may not be the previously active window. See DevDiv bug 122467 for details.
            // Furthermore, verify that _dialogPreviousActiveHandle is still a window b/c it
            // could have been destroyed by now by some other thread/codepath etc.
            // WOSB 1098573 (BVT BLOCKER: System.ComponentModel.Win32Exception thrown when 
            // trying to shutdown app inside a Dialog Window)
            if ((wasActive == true) && 
                (_dialogPreviousActiveHandle != IntPtr.Zero) && 
                (UnsafeNativeMethods.IsWindow(new HandleRef(this, _dialogPreviousActiveHandle)) == true))
            { 
                UnsafeNativeMethods.SetActiveWindow(new HandleRef(this, _dialogPreviousActiveHandle));
            }
            else
            { 
                //
 
 

                // rare situation, figure this out later 
                // talk to user team as to what we need to do here
            }
        }
 
        ///
        ///     Critical: Calls critical code: Window.InternalClose and Application.CriticalShutdown 
        /// 
        [SecurityCritical]
        private void UpdateWindowListsOnClose() 
        {
            // Close all owned windows
            // use internal version since we want to update the underlying collection
            WindowCollection ownedWindows = OwnedWindowsInternal; 

            // 
 

 
            while (ownedWindows.Count > 0)
            {
                // if parent window is closing, child window Closing cannot be cancelled.
                ownedWindows[0].InternalClose(false, true /* Ignore cancel */); 
            }
 
            Debug.Assert(ownedWindows.Count == 0, "All owned windows should now be gone"); 

            // Update OwnerWindows of our Owner 
            if (IsOwnerNull == false)
            {
                // use internal version since we want to update the underlying collection
                Owner.OwnedWindowsInternal.Remove(this); 
            }
 
            if (this.IsInsideApp) 
            {
                if (Application.Current.Dispatcher.Thread == Dispatcher.CurrentDispatcher.Thread) 
                {
                    // use internal version since we want to update the underlying collection
                    App.WindowsInternal.Remove(this);
 
                    // Check to see if app should shut down--this behavior really belongs in Application
                    if (_appShuttingDown == false) 
                    { 
                        // If this is the last window that's closing and shutdownmode is onlastwindowclose, or
                        // if this is the main window closing and shutdownmode is onmainwindowclose, shutdown 
                        // the app
                        if (((App.Windows.Count == 0) && (App.ShutdownMode == ShutdownMode.OnLastWindowClose))
                         || ((App.MainWindow == this) && (App.ShutdownMode == ShutdownMode.OnMainWindowClose)))
                        { 
                            App.CriticalShutdown(0);
                        } 
                    } 

                    TryClearingMainWindow(); 
                }
                else
                {
                    App.NonAppWindowsInternal.Remove(this); 
                }
            } 
 
        }
        /// 
        ///     Critical: This can be used to dispose a window which is a secure resource
        ///
        [SecurityCritical]
        private bool  WmDestroy() 
        {
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called 
            // synchronously from CreateWindowEx call and we run into issues if 
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want 
            // to explicitly add the null check below at all other places.
            if (IsSourceWindowNull)
            {
                return false; 
            }
 
            if (_disposed == false) 
            {
                InternalDispose(); 
            }

            // hamidm - WOSB 1453012 STRESS: System.NullReferenceException @ System.Windows.Window.DeviceToLogicalUnits
            // 
            // We're intentionally not adding a check for IsCompositionTargetInvlaid here since we
            // feel that it is okay to fire the Closed event to notify the developer that window has 
            // closed. 

            // Event handler exception continuality: if exception occurs in Closed event handler, the 
            // cleanup action is to finish closing.
            // raise Closed event
            OnClosed(EventArgs.Empty);
 
            return false;
        } 
 
        private bool WmActivate( IntPtr wParam )
        { 
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called
            // synchronously from CreateWindowEx call and we run into issues if
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want 
            // to explicitly add the null check below at all other places.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            { 
                return false;
            }

            int loWord = NativeMethods.SignedLOWORD(wParam); 
            bool windowActivated;
 
 
            if ( loWord == NativeMethods.WA_INACTIVE )
            { 
                windowActivated = false;
            }
            else
            { 
                windowActivated = true;
            } 
 
            HandleActivate(windowActivated);
 
            return false;
        }

        private void AdjustWindowRectEx(ref NativeMethods.RECT rc) 
        {
            // HwndSource expands the client area to cover the entire window when it is in UsesPerPixelOpacity mode, 
            // So there is no need to adjust window rect. 
            if (! AllowsTransparency)
            { 
                SafeNativeMethods.AdjustWindowRectEx(ref rc, _Style, false, _StyleEx);
            }
        }
 
        private bool WmSizeChanged( IntPtr wParam, IntPtr lParam )
        { 
            // hamidm 11/07/2005 
            // 1378397  HOT: Window Width and Height overrides the other when set in Style
            // 
            // This bug is caused b/c of using ActualHeight/Width and UpdateWidth/Height method.
            // ActualHeight/Width is zero when Width/Height is invalidated after hwnd creation and
            // before 1st layout happens.  We hit this when Width/Height is set in style of the window
            // 
            // The fix is to cache the current hwnd size and use that instead.  We cache the size
            // even if sourceWindow is null b/c we might need to use this cache value before another 
            // WM_SIZE is received 

            int width = NativeMethods.SignedLOWORD(lParam); 
            int height = NativeMethods.SignedHIWORD(lParam);

            NativeMethods.RECT rc = new NativeMethods.RECT(0, 0, width, height);
            AdjustWindowRectEx(ref rc); 

            _currentHwndWidthDevicePixels = (rc.right - rc.left); 
            _currentHwndHeightDevicePixels = (rc.bottom - rc.top); 

            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called 
            // synchronously from CreateWindowEx call and we run into issues if
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want
            // to explicitly add the null check below, at all other places. 
            //
            // Adding IsCompositionTargetInvalid check here for fix of WOSB 1453012. 
            // Add this check here means that we won't fire WindowStateChanged event. 
            // However, since the hwnd is going away anyways, not firing StateChanged
            // should not be a big deal.  The other side effect is that Width/Height DPs 
            // won't be updated that should be fine too since window is going away.
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            {
                return false; 
            }
 
            Point ptLogicalUnits = DeviceToLogicalUnits(new Point(rc.right - rc.left, rc.bottom - rc.top)); 

            // Only set Width/Height local value when user resizes 
            if (_inUserSizeMove)
            {
                try
                { 
                    _updateHwndSize = false;
                    SetValue(FrameworkElement.WidthProperty, ptLogicalUnits.X); 
                    SetValue(FrameworkElement.HeightProperty, ptLogicalUnits.Y); 
                }
                finally 
                {
                    _updateHwndSize = true;
                }
            } 

            switch ((int)wParam) 
            { 
                // We introduced _previousWindowState for the following scenario:
                // 
                // win1.WindowState = WindowState.Maximized; // or stateA
                // ...
                // win1.WindowState = WindowState.Normal; // or stateB
                // 
                // Developer sets WindowState to Maximized/Minimized then return to Normal.
                // OnStateChanged should be fired. However, We were comparing that to WindowState.Normal. 
                // The value in property engine had been updated to Normal in the CLR setter, so OnStateChanged 
                // was never fired.
                // This is addressed in bug 937458. 
                //
                // Another reason for remembering the previous state is that
                // WM_SIZE is sent when the client area size of the hwnd changes.
                // Thus, if the hwnd is maximized, and the border style changes, 
                // WM_SIZE is sent.  In such cases, we don't want to fire
                // StateChanged since the previous state was maximized too. 
                // See WOSB 1097658 (NullReferenceException thrown when changing ResizeMode from CanMinimize 
                // to CanResizeWithGrip inside StateChanged event handler).
                // 
                // There are two places we update _previousWindowState.

                // WindowState can be changed as a result of the following two passes
                // 1. User interaction changes WindowState 
                // 2. Developer programmatically changes WindowState
                // We update _previousWindowState at two places 
                // 1. Before Hwnd is created, when developer programmatically changes WindowState, we update it when WindowState is invalidated. 
                // 2. After Hwnd is created, we update it here because both passes comes here eventually.
 
                // Event handler exception continuality: if exception occurs in StateChanged event handler, our state will not be
                // corrupted because the state related to StateChanged, WindowStateProperty and _previousWindowState, are set before the event is fired.
                // Please check Event handler exception continuality if the logic changes.
                case NativeMethods.SIZE_MAXIMIZED: 
                    if (_previousWindowState != WindowState.Maximized)
                    { 
                        // Do not set local value unless it is from user interaction. 
                        // User interaction is considered as the same pri as SetValue
                        // If WindowState is not the same as the current win32 value, it means the change is 
                        // not from the DP system but from user interaction.
                        if (WindowState != WindowState.Maximized)
                        {
                            WindowState = WindowState.Maximized; 
                        }
                        _previousWindowState = WindowState.Maximized; 
                        OnStateChanged(EventArgs.Empty); 
                    }
                    break; 
                case NativeMethods.SIZE_MINIMIZED:
                    if (_previousWindowState != WindowState.Minimized)
                    {
                        if (WindowState != WindowState.Minimized) 
                        {
                            WindowState = WindowState.Minimized; 
                        } 
                        _previousWindowState = WindowState.Minimized;
                        OnStateChanged(EventArgs.Empty); 
                    }
                    break;
                case NativeMethods.SIZE_RESTORED:
                    if (_previousWindowState != WindowState.Normal) 
                    {
                        if (WindowState != WindowState.Normal) 
                        { 
                            WindowState = WindowState.Normal;
                        } 
                        _previousWindowState = WindowState.Normal;
                        OnStateChanged(EventArgs.Empty);
                    }
                    break; 
                default:
                    break; 
            } 

            // DON'T DO ANYTHIHG HERE SINCE WE FIRE STATECHANGED ABOVE.  USER CODE 
            // RUNS IN STATE CHANGED AND WINDOW COULD HAVE BEEN CLOSED.  THUS, THE
            // STATE OF VARIABLES IS UNKNOWN.

            // HwndSource passes the win32 msgs to the public hookds first before 
            // passing layout hook etc.  Thus we get the WM_SIZE msg before
            // layout filter has processed it and we were reporting stale 
            // value for height/width.  Now, UIElement fires SizeChanged event. 

            return false; 
        }
        /// 
        ///     Critical: This code accesses CriticalHandle
        ///  
        [SecurityCritical]
        private bool WmMoveChanged(IntPtr hwnd, IntPtr lParam) 
        { 
            // We want to listen to WM_MOVE synchronously since if a Window is
            // created minimized/maximized we get this message as a result of 
            // calling CreateWindowEx.  Here, sourceWindow is null but we still
            // need to update _actual[Top/Left] to reflect the correct Top/Left
            // when Show() returns.  Thus we input hwnd and process top/left info
            // 
            // We won't fire LocationChanged unless Show has returned meaning
            // IsSourceWindowNull is false.  Furthermore, LocationChanged is 
            // fired only if the top/left values really changed 

            // Adding IsCompositionTargetInvalid check here for WOSB 1453012. 
            // Since hwnd is going away, not updating Top/Left DPs and not firing
            // LocationChanged should not matter.
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            { 
                return false;
            } 
 
            if (!_inTrustedSubWindow)
            { 
                SecurityHelper.DemandUIWindowPermission();
            }

            // the input lparam gives the client location, thus we have to 
            // convert it to the window location.
            NativeMethods.RECT rc = new NativeMethods.RECT(0,0,0,0); 
            SafeNativeMethods.GetClientRect(new HandleRef(this, hwnd), ref rc); 

            int left = NativeMethods.SignedLOWORD( lParam ); 
            int top = NativeMethods.SignedHIWORD( lParam );
            int right = left + rc.right;
            int bottom = top + rc.bottom;
 
            rc = new NativeMethods.RECT(left, top, right, bottom);
 
            AdjustWindowRectEx(ref rc); 

            Point ptLogicalUnits = DeviceToLogicalUnits(new Point(rc.left, rc.top)); 


            if (!DoubleUtil.AreClose(_actualLeft, ptLogicalUnits.X) ||
                !DoubleUtil.AreClose(_actualTop, ptLogicalUnits.Y)) 
            {
                _actualLeft = ptLogicalUnits.X; 
                _actualTop = ptLogicalUnits.Y; 

 
                // In Window, WmMoveChangedHelper write the local value of Top/Left
                // (if necessary) or updates the property system values for
                // Top/Left by calling CoerceValue.  Furthermore, it fires the
                // LocationChanged event.  RBW overrides WmMoveChangedHelper to do 
                // nothing as writing Top/Left is not supported for RBW and
                // LocationChanged is never fired for it either. 
                WmMoveChangedHelper(); 

                //Invalidate AutomationPeer if it was created/used by Automation. 
                //This will schedule a deferred update of bounding rectangle and
                //corresponding notification to the Automation layer.
                AutomationPeer peer = UIElementAutomationPeer.FromElement(this);
                if(peer != null) 
                {
                    peer.InvalidatePeer(); 
                } 

            } 

            return false;
        }
 
        // This method updates the Left/Top values and fires the location changed event.
        // It is virtual so that RBW can override it. 
        internal virtual void WmMoveChangedHelper() 
        {
 
            // Only set Top&Left local value when user resizes
            if (_inUserSizeMove)
            {
                try 
                {
                    _updateHwndLocation = false; 
                    SetValue(LeftProperty, _actualLeft); 
                    SetValue(TopProperty, _actualTop);
                } 
                finally
                {
                    _updateHwndLocation = true;
                } 
            }
            else 
            { 
                // hamidm -- 5/15/2007
                // WOSB 1447707 Window Left and Top properties do not update in Multi-Mon Scenario 
                //      1813033 Window.Left/Top/Width/Height return incorrect value after changing screen resolution / orientation
                //
                // The above were caused b/c of the fact that we didn't have this else block and thus
                // ignoring the WM_MOVE that we sent as a result of system level changes. 
                // Now, we coerce Top/Left with the actual value for location (even when it is not
                // sent as a result of user resize).  Note that coercing does not write the local value 
 
                try
                { 
                    _coercedFromWmMoveChanged = true;
                    _updateHwndLocation = false;
                    CoerceValue(TopProperty);
                    CoerceValue(LeftProperty); 
                }
                finally 
                { 
                    _updateHwndLocation = true;
                    _coercedFromWmMoveChanged = false; 
                }
            }

 
            // Event handler exception continuality: if exception occurs in LocationChanged event handler, our state will not be
            // corrupted because the states related to LocationChanged, LeftProperty, TopProperty, Left and Top are set before the event is fired. 
            // Please check event handler exception continuality if the logic changes. 
            OnLocationChanged(EventArgs.Empty);
        } 


        /// 
        ///     Critical:This calls into pointer to structure which is critical 
        /// 
        [SecurityCritical] 
        private bool WmGetMinMaxInfo( IntPtr lParam ) 
        {
            NativeMethods.MINMAXINFO mmi = (NativeMethods.MINMAXINFO)UnsafeNativeMethods.PtrToStructure( lParam, typeof(NativeMethods.MINMAXINFO)); 

            //
            // For Bug 1380569: Window SizeToContent does not work after changing Max size properties
            // 
            // When Min/Max size is changed in this Window instance, we want to make sure the correct
            // final Min/Max size is used to measure the window layout and notify the Win32 of the required 
            // Min/Max size. 
            //
            // This method is responsible to notify Win32 of the new Min/Max size. 
            // MeasureOverride( ) is responisble to use the right Min/Max size to calculate the desired layout size.
            //
            // But only this method knows the Win32 restricted Min/Max value for the HWND when it responds to WM_GETMINMAXINFO message.
            // 
            // To generate the right final Min/Max size value in both places ( here and MeasureOverride), we should
            // cache the Win32 restricted size here. 
            // 

 
            // hamidm -- 10/27/2005
            // We need to store the max/min size the hwnd can take.  This is used in GetWindowMinMax to determine
            // the size passed to children for their layout.  These are stored in device units here so later
            // we change them to logical units.  Fixes the following bugs: 
            //
            // WOSB: 1030000 Wrong window actual size returned if Autosize window 
            // content is smaller than the actual window (seems to return content 
            // size as opposed to window size)
            // 
            // WOSB: 1330752 Window content should respect Window's Max/Min size

            _trackMinWidthDeviceUnits = mmi.ptMinTrackSize.x;
            _trackMinHeightDeviceUnits = mmi.ptMinTrackSize.y; 
            _trackMaxWidthDeviceUnits = mmi.ptMaxTrackSize.x;
            _trackMaxHeightDeviceUnits = mmi.ptMaxTrackSize.y; 
 
            // if IsCompositionTargetInvalid is true, then it means that the CompositionTarget is not available.
            // This can happen at hwnd creation or destruction time. 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            {
                //
                // Get the final MinMax size for this HWND based on Win32 track value and Min/Max setting 
                // in this instance.
                // 
                WindowMinMax finalMinMax = GetWindowMinMax( ); 

                // The finalMinMax struct keeps the desired Min/Max size for this hwnd in Logic Units. 
                Point minSizeDeviceUnits = LogicalToDeviceUnits(new Point(finalMinMax.minWidth, finalMinMax.minHeight));
                Point maxSizeDeviceUnits = LogicalToDeviceUnits(new Point(finalMinMax.maxWidth, finalMinMax.maxHeight));

                // Put the new value in mmi 
                mmi.ptMinTrackSize.x = DoubleUtil.DoubleToInt(minSizeDeviceUnits.X);
                mmi.ptMinTrackSize.y = DoubleUtil.DoubleToInt(minSizeDeviceUnits.Y); 
 
                mmi.ptMaxTrackSize.x = DoubleUtil.DoubleToInt(maxSizeDeviceUnits.X);
                mmi.ptMaxTrackSize.y = DoubleUtil.DoubleToInt(maxSizeDeviceUnits.Y); 

                // Notify Win32 of the new Min/Max value for this HWND.

                Marshal.StructureToPtr(mmi, lParam, true); 
            }
 
            return true; 
        }
 
        private bool WmNcHitTest( IntPtr lParam, ref IntPtr refInt )
        {
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called
            // synchronously from CreateWindowEx call and we run into issues if 
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want 
            // to explicitly add the null check below at all other places. 
            //
            // Adding check for IsCompositionTargetInvalid as the fix for WOSB 1453012. 
            // This can be true either at HwndSource creation time or when hwnd is going
            // away.
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            { 
                return false;
            } 
 
            // WmNcHitTest is necessary to enable ResizeGrip and it only
            // relevant for Window.  Doing this processing in a virtual so 
            // that RBW can override it
            return HandleWmNcHitTestMsg(lParam, ref refInt);
        }
 
        internal virtual bool HandleWmNcHitTestMsg(IntPtr lParam, ref IntPtr refInt)
        { 
            // 

 



 

            if ((_resizeGripControl == null) || (ResizeMode != ResizeMode.CanResizeWithGrip)) 
            { 
                return false;
            } 

            // mouse position wrt to the left/top of the screen
            int x = NativeMethods.SignedLOWORD(lParam);
            int y = NativeMethods.SignedHIWORD(lParam); 

            // Find the client area 0,0 of the Window wrt the screen 
            // This will be used to transform the mouse position from screen co-od 
            // to window's client area co-od.  We need this to be able to figure out
            // whether the mouse is currently over the resize grip control or not 


            NativeMethods.POINT pt = GetPointRelativeToWindow(x, y);
            Point ptLogicalUnits = DeviceToLogicalUnits(new Point(pt.x, pt.y)); 

            // Now, (ptLogicalUnits.X, ptLogicalUnits.Y) is the mouse postion wrt to the 
            // Window's client region. 
            // The next step is to find out whether the mouse is on top of the
            // ResizeGrip control 
            // For this we first need to find out mouse location wrt to the ResizeGrip
            // control and then check whether the mouse location is on the control
            // Conditions when mouse is on top of the control:
            //     x,y should be not be less than zero 
            //     x,y should not be greater than RenderSize.Width and RenderSize.Height
 
            GeneralTransform transfromFromWindow = this.TransformToDescendant(_resizeGripControl); 
            Point mousePositionWRTResizeGripControl = ptLogicalUnits;
            if (transfromFromWindow == null || transfromFromWindow.TryTransform(ptLogicalUnits, out mousePositionWRTResizeGripControl) == false) 
            {
                return false;
            }
 
            // check if the mouse is outside the ResizeGripControl region
            if ((mousePositionWRTResizeGripControl.X < 0) || 
                (mousePositionWRTResizeGripControl.Y < 0 ) || 
                (mousePositionWRTResizeGripControl.X > _resizeGripControl.RenderSize.Width) ||
                (mousePositionWRTResizeGripControl.Y > _resizeGripControl.RenderSize.Height)) 
            {
                // mouse not over ResizeGripControl; just let the DefWndProc handle this
                return false;
            } 

            if (FlowDirection == FlowDirection.RightToLeft) 
            { 
                refInt = new IntPtr(NativeMethods.HTBOTTOMLEFT);
            } 
            else
            {
                refInt = new IntPtr(NativeMethods.HTBOTTOMRIGHT);
            } 
            // we've handled the WM_NCHITTEST msg thus return true
            return true; 
        } 

        private bool WmShowWindow(IntPtr wParam, IntPtr lParam) 
        {
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called
            // synchronously from CreateWindowEx call and we run into issues if
            // _sourceWindow in null.  We only care to listen to WM_CREATE & 
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want
            // to explicitly add the null check below at all other places. 
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            {
                return false;
            }
 
            //lParam has five values: 0(programtically show/hide), 1(SW_PARENTCLOSING),
            //2(SW_OTHERMAXIMIZED), 3(SW_PARENTOPENING), 4(SW_OTHERRESTORED). We only care 
            //about 1 and 3. 
            switch (NativeMethods.IntPtrToInt32(lParam))
            { 
                //The window's owner window is being minimized.
                //In Win32, when lParam is SW_PARENTCLOSING, wParam is false,
                //which means the window is being hidden.
                case NativeMethods.SW_PARENTCLOSING: 
                    //This window will be hidden. Update _isVisible to reflect the
                    // new state.  Furthermore update visibility such that we 
                    // do not call ShowHelper again and thus calling 
                    // UpdateVisibilityProperty.
                    _isVisible = false; 
                    UpdateVisibilityProperty(Visibility.Hidden);
                    break;

                //The window's owner window is being restored. 
                //In Win32, when lParam is SW_PARENTOPENING, wParam is true,
                //which means the window is being shown. 
                case NativeMethods.SW_PARENTOPENING: 
                    //This window will be shown. Update _isVisible to reflect the
                    // new state.  Furthermore update visibility such that we 
                    // do not call ShowHelper again and thus calling
                    // UpdateVisibilityProperty.
                    _isVisible = true;
                    UpdateVisibilityProperty(Visibility.Visible); 
                    break;
 
                default: 
                    break;
            } 

            return false;
        }
 
        private static void _OnIconChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = (Window)d; 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
 
            BitmapFrame bf;

            // setting icon value to null or something that is a BitmapFrame is allowed.
            // Why only BitmapFrame, b/c when an ImageSource is created using an .ico, it 
            // always returns a BitmapFrame.  Moreover, we want APIs that are on BitmapFrame.
            // Also, we don't support any other source of image besides an ico for icons yet. 
            if (e.NewValue == null) 
            {
                bf = null; 
            }
            else
            {
                bf = e.NewValue as BitmapFrame; 

                if (bf == null) 
                { 
                    throw new InvalidOperationException(SR.Get(SRID.IconMustBeBitmapFrame));
                } 
            }
            w.OnIconChanged(bf);
        }
 

        private void OnIconChanged(BitmapFrame newIcon) 
        { 
            // No need to dispose previous _icon.
            // _icon is a ref to the ImageSource object 
            // set by the developer.  Since the dev created
            // the ImageSource object it is his responsibility to
            // dispose it.
            _icon = newIcon; 

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            {
                UpdateIcon(); 
            }
        }

        private static void _OnTitleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = (Window)d; 
            Debug.Assert(w != null, "DependencyObject must be of type Window."); 

            w.OnTitleChanged(); 
        }

        private static bool _ValidateText(object value)
        { 
            return (value != null);
        } 
 
        private void OnTitleChanged()
        { 
            UpdateTitle(Title);
        }

        private static void _OnShowInTaskbarChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = (Window)d; 
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnShowInTaskbarChanged(); 
        }

        /// 
        ///     Critical: This code accesses hwnd 
        ///     TreatAsSafe: This function simply minimizes and maximises that is ok, also this will only
        ///     work in RBW code path and that is ok since this is bounded to parent 
        ///  
        [SecurityCritical,SecurityTreatAsSafe]
        private void OnShowInTaskbarChanged() 
        {
            if (!_inTrustedSubWindow)
            {
 
                SecurityHelper.DemandUIWindowPermission();
            } 
 
            // this call ends up throwing an exception if accessing
            // ShowInTaskbar is not allowed 
            VerifyApiSupported();

            // There are 2 cases
            // Case 1 : being set before source window is created 
            // Case 2 : being set after the source window is created
            // Case 3 : bet set when CompositionTarget is invalid meaning we're in a bad state 
 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if ( IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            {
                bool fHideWindow = false;
                // Win32 bug. For ShowInTaskbar to change dynamically, we need to hide then show the window.
                // It is recommended to hide the window, chnage the style bits and then show it again. 
                if (_isVisible)
                { 
                    UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle), NativeMethods.NullHandleRef, 0, 0, 0, 0, 
                                       NativeMethods.SWP_NOMOVE |
                                       NativeMethods.SWP_NOSIZE | 
                                       NativeMethods.SWP_NOZORDER |
                                       NativeMethods.SWP_NOACTIVATE |
                                       NativeMethods.SWP_NOSENDCHANGING |
                                       NativeMethods.SWP_HIDEWINDOW); 
                    fHideWindow = true;
                } 
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd  )) 
                {
                    SetTaskbarStatus(); 
                }
                // Use fHideWindow instead of _isVisible in case if we listen to HideWindow messages and update _isVisible value,
                // it won't break this code.
                if (fHideWindow) 
                {
                    UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle), NativeMethods.NullHandleRef, 0, 0, 0, 0, 
                                                    NativeMethods.SWP_NOMOVE | 
                                                    NativeMethods.SWP_NOSIZE |
                                                    NativeMethods.SWP_NOZORDER | 
                                                    NativeMethods.SWP_NOACTIVATE |
                                                    NativeMethods.SWP_NOSENDCHANGING |
                                                    NativeMethods.SWP_SHOWWINDOW);
                } 
            }
        } 
 
        private static bool _ValidateWindowStateCallback(object value)
        { 
            return IsValidWindowState((WindowState)value);
        }

        private static void _OnWindowStateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = (Window)d; 
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnWindowStateChanged((WindowState) e.NewValue); 
        }

        /// 
        ///     Critical: This code can cause window to maximize and minimize and used hwnd 
        ///     TreatAsSafe: This has a demand
        ///  
        [SecurityCritical,SecurityTreatAsSafe] 
        private void OnWindowStateChanged(WindowState windowState)
        { 
            SecurityHelper.DemandUIWindowPermission();

            //
 

 
 

 



 

            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            { 
                if (_isVisible == true)
                { 
                    HandleRef hr = new HandleRef(this,  CriticalHandle);

                    int style = _Style;
 
                    // Only call ShowWindow if window is in a different state
                    switch (windowState) 
                    { 
                        case WindowState.Normal:
                            if ((style & NativeMethods.WS_MAXIMIZE) == NativeMethods.WS_MAXIMIZE) 
                            {
                                //
                                // The old behavior of this case is to restore the window using SW_RESTORE.
                                // With the ShowActivated property set to false we want this restore operation 
                                // to take the current activation state into account when restoring the window.
                                // 
                                if (ShowActivated || IsActive) 
                                    UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_RESTORE);
                                else 
                                    UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_SHOWNOACTIVATE);
                            }
                            else if ((style & NativeMethods.WS_MINIMIZE) == NativeMethods.WS_MINIMIZE)
                            { 
                                //
                                // We query to WINDOWPLACEMENT to get an indication about the state before the 
                                // minimize operation happened. If we were coming from a maximized state and now we 
                                // switch to normal, we want activation to happen since the maximized state is always
                                // activated and transitioning from activated to non-activated would be weird. 
                                //
                                NativeMethods.WINDOWPLACEMENT placement = new NativeMethods.WINDOWPLACEMENT();
                                placement.length = Marshal.SizeOf(placement);
                                UnsafeNativeMethods.GetWindowPlacement(hr, ref placement); 

                                if ((placement.flags & NativeMethods.WPF_RESTORETOMAXIMIZED) == NativeMethods.WPF_RESTORETOMAXIMIZED) 
                                    UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_RESTORE); 
                                else
                                { 
                                    if (ShowActivated)
                                        UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_RESTORE);
                                    else
                                        UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_SHOWNOACTIVATE); 
                                }
                            } 
                            break; 

                        case WindowState.Maximized: 
                            if ((style & NativeMethods.WS_MAXIMIZE) != NativeMethods.WS_MAXIMIZE)
                            {
                                //
                                // The OS doesn't provide support for non-activated maximized windows. 
                                //
                                UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_MAXIMIZE); 
                            } 
                            break;
 
                        case WindowState.Minimized:
                            if ((style & NativeMethods.WS_MINIMIZE) != NativeMethods.WS_MINIMIZE)
                            {
                                // 
                                // Historically, we used SW_MINIMIZE in here which activates the next top-level
                                // window in the Z order. Therefore, our ShowActivated property can't affect the 
                                // minimized state since this would incur a breaking change requiring us to use 
                                // SW_SHOWMINIMIZED instead in case ShowActivated is set to true (bw compat case).
                                // 
                                UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_MINIMIZE);
                            }
                            break;
                        // 

 
 
                    }
                } 
            }
            else
            {
                // WindowState can be changed as a result of the following two passes 
                // 1. User interaction changes WindowState
                // 2. Developer programmatically changes WindowState 
                // We update _previousWindowState at two places 
                // 1. Before Hwnd is created, when developer programmatically changes WindowState, we update it here.
                // 2. After Hwnd is created, we update it when we get to WM_SIZE because both passes eventally meet there. 
                _previousWindowState = windowState;
            }

            // The value of Top and Left is affected by WindowState and WindowStartupLocation. 
            // we need to coerce Top and Left whenever these deciding factors change.
            // More info in CoerceTop. 
            try 
            {
                _updateHwndLocation = false; 
                CoerceValue(TopProperty);
                CoerceValue(LeftProperty);
            }
            finally 
            {
                _updateHwndLocation = true; 
            } 
        }
 
        private static bool _ValidateWindowStyleCallback(object value)
        {
            return IsValidWindowStyle((WindowStyle)value);
        } 

        private static void _OnWindowStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            Window w = (Window)d;
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnWindowStyleChanged((WindowStyle) e.NewValue);
        }
 
        private void OnWindowStyleChanged(WindowStyle windowStyle)
        { 
            //Per our conversation with Aaron today, in M6 we are going to demand UnrestrictedFullScreen permission for 
            //setting WindowStyle to None. But there will be changes in M7 so that we can differentiate between FullScreen
            //and NoBorder window, so we comment this section out for future references. 
            //if ((value == WindowStyle.None) && (WindowState == WindowState.Maximized))
            //if (windowStyle == WindowStyle.None)
            //{
            //    AVTempUIPermission avtUIPermission = new AVTempUIPermission(AVTUIPermissionFullScreen.UnrestrictedFullScreen); 

                //CASRemoval:avtUIPermission.Demand(); 
            //} 

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            {
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd ))
                { 
                    CreateWindowStyle();
                } 
            } 
        }
 
        private static void _OnTopmostChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            Window w = (Window)d;
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnTopmostChanged((bool) e.NewValue); 
        } 

        /// 
        /// There is an explicit demand here - to enforce not being able to set this DP in Internet Zone.
        /// this should remanin here until Window spoofing work is done.
        ///     Critical as this accesses critical data - (CriticalHandle )
        ///     TreatAsSafe - as there is a demand. 
        ///
        [SecurityCritical, SecurityTreatAsSafe ] 
        private void OnTopmostChanged(bool topmost) 
        {
            SecurityHelper.DemandUIWindowPermission(); // Demand UI permission for topmost. 

            // this call ends up throwing an exception if accessing
            // Topmost is not allowed
            VerifyApiSupported(); 

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false  && IsCompositionTargetInvalid == false) 
            {
                HandleRef hWnd = topmost ? NativeMethods.HWND_TOPMOST : NativeMethods.HWND_NOTOPMOST; 
                UnsafeNativeMethods.SetWindowPos(new HandleRef(null, CriticalHandle),
                       hWnd,
                       0, 0, 0, 0,
                       NativeMethods.SWP_NOMOVE | NativeMethods.SWP_NOSIZE | NativeMethods.SWP_NOACTIVATE); 
            }
        } 
 
        private static object CoerceVisibility(DependencyObject d, object value)
        { 
            Window w = (Window)d;

            Visibility newValue = (Visibility)value;
            if (newValue == Visibility.Visible) 
            {
                w.VerifyCanShow(); 
                w.VerifyConsistencyWithAllowsTransparency(); 
                w.VerifyNotClosing();
                w.VerifyConsistencyWithShowActivated(); 
            }

            return value;
        } 

        ///  
        /// Called when VisiblityProperty is invalidated 
        /// The actual window is created when the Visibility property is set
        /// to Visibility.Visible for the first time or when Show is called. 
        /// For Window, Visibility.Visible means the Window is visible.
        /// Visibility.Hidden and Visibility.Collapsed mean the Window is not visible.
        /// Visibility.Hidden and Visibility.Collapsed are treated the same.
        ///  
        private static void _OnVisibilityChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = (Window)d; 

            // Indicate Visibility has been set 
            // This works fine because Window is always the root.  So Visibility property
            // would not be invalidated usless it is set to a value.  But if that changes,
            // we will get invalidation when Window it added to the tree and this would be broken.
            w._isVisibilitySet = true; 

            // _visibilitySetInternally is used to identify a call from Show/Hide in 
            // _OnVisibilityInvalidated callback.  If a call originates in Show/Hide, 
            // we DO NOT want to do anything in the _OnVisibilityCallback since, we
            // synchronously call ShowHelper from Show/Hide 
            if (w._visibilitySetInternally == true)
            {
                return;
            } 

            bool visibilityValue = VisibilityToBool((Visibility) e.NewValue); 
 
            w.Dispatcher.BeginInvoke(
                DispatcherPriority.Normal, 
                new DispatcherOperationCallback(w.ShowHelper),
                visibilityValue ? BooleanBoxes.TrueBox : BooleanBoxes.FalseBox);

        } 

        ///  
        ///     Critical: This code causes an elevation to all Window permission and 
        ///               calls into CreateSourceWindowImpl
        ///     TreatAsSafe: This code causes window to be created if it was null, 
        ///                  calling it over and over has no affect. Also in this case
        ///                 the code only creates the window if this is under an RBW
        ///                 code path and if it has been called via the internal constructor chain
        ///  
        [SecurityCritical, SecurityTreatAsSafe]
        private void SafeCreateWindow() 
        { 
            //this is true the first time the window is created
            if (IsSourceWindowNull == true) 
            {
                //this is true only if called via RBW
                if (!_inTrustedSubWindow)
                { 
                   SecurityHelper.DemandUIWindowPermission();
                } 
                // _isVisible is false at this moment.  Thus CreateAllStyle 
                // called by CreateSourceWindow does not set WS_VISIBLE style
 
                CreateSourceWindowImpl();
            }
        }
 
        // We set/clear ShowKeyboardCue when Show(ShowDialog)/Hide is called.
        // We do not clear the state of ShowKeyboardCue when Window is closed. 
        private void SetShowKeyboardCueState() 
        {
            // set property on AccessKey control indicating the 
            // invocation device
            if (KeyboardNavigation.IsKeyboardMostRecentInputDevice())
            {
                _previousKeyboardCuesProperty = (bool)GetValue(KeyboardNavigation.ShowKeyboardCuesProperty); 
                SetValue(KeyboardNavigation.ShowKeyboardCuesProperty, BooleanBoxes.TrueBox);
                _resetKeyboardCuesProperty = true; 
            } 
        }
 
        // We set/clear ShowKeyboardCue when Show(ShowDialog)/Hide is called.
        // We do not clear the state of ShowKeyboardCue when Window is closed.
        private void ClearShowKeyboardCueState()
        { 
            // if we set KeyboradNavigation.ShowKeyboardCuesProperty in ShowDialog,
            // set it to false here. 
            if (_resetKeyboardCuesProperty == true) 
            {
                _resetKeyboardCuesProperty = false; 
                SetValue(KeyboardNavigation.ShowKeyboardCuesProperty, BooleanBoxes.Box(_previousKeyboardCuesProperty));
            }
        }
 
        private void UpdateVisibilityProperty(Visibility value)
        { 
            // _visibilitySetInternally is used to identify a call (in _OnVisibilityInvalidated 
            // callback) for updating the property value only and not changing the actual
            // visibility state of the hwnd. 
            try
            {
                _visibilitySetInternally = true;
                Visibility = value; 
            }
            finally 
            { 
                _visibilitySetInternally = false;
            } 
        }

        /// 
        /// update _isVisible and call CreateSourceWindow if 
        /// it's the first time window is set to Visibile
        ///  
        ///  
        ///     Critical: Acceses CriticalHandle
        ///     TreatAsSafe: Code only creates window in RBW path 
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        private object ShowHelper(object booleanBox)
        { 
            // Setting Visiblilty is async. When this is called from the async callback,
            // check whether the window is already closed. 
            // E.g. window.Visibility = true; 
            //      ...
            //      window.Close(); 
            // We should not do anything if the window is already closed.
            if (_disposed == true)
            {
                return null; 
            }
 
            bool value = (bool) booleanBox; 
            _isClosing = false;
 
            // hamidm 9/7/2005 WOSB 1223920 (BVT Blocker: Invariant Assert when calling
            // Window.Show after setting Visibility=Hidden)

            // We should optimize for when visibilityValue == _isVisible only in ShowHelper 
            // since this is called from a [....] and async call.  We cannot optimize it there
            // since _isVisible may not reflect the exact state requested by the OM call. 
            if (_isVisible == value) 
            {
                return null; 
            }

            // _isVisible should always be set after calling SafeCreateWindow, because
            // if exception occurs in Loading event (fired as a result of setting Visibility to visible) handler, 
            // we set Visibility back to Collapsed. Otherwise we could get into a loop.
            if (value == true) 
            { 
                if (Application.IsShuttingDown)
                    return null; 

                SetShowKeyboardCueState();

                //create window only if under rbw 
                SafeCreateWindow();
                _isVisible = true; 
            } 
            else
            { 
                //demand in case you are trying to hide this window
                if (!_inTrustedSubWindow)
                {
                    SecurityHelper.DemandUIWindowPermission(); 
                }
 
                ClearShowKeyboardCueState(); 

                if (_showingAsDialog == true) 
                {
                    DoDialogHide();
                }
                _isVisible = false; 
            }
 
            // we need this check here again, b/c creating the window fires the 
            // Activted event and if user closes the window from it, then by
            // the time we get to this point _sourceWindow is already disposed. 
            if ( IsSourceWindowNull == false )
            {
                // NOTE: hamidm 08/24/04
                // PS Windows OS bug # 950580 Specifying an Avalon app to start 
                // maximized from a shortcut does not work.
 
                // ShowWindow MSDN documentation says that the first time ShowWindow 
                // is called, nCmd passed in STARTUPINFO is used instead of the one
                // passed in via ShowWindow call. However, that is not the case. 
                // ShowWindow implementation in user32 uses nCmd of STARTUPINFO only
                // if we pass SW_SHOW, SW_SHOWNORMAL, SW_SHOWDEFAULT to ShowWindow.
                // If anything else is passed, it does not use nCmd of STARTUPINFO.
 
                int nCmd = 0;
                if (value == true) 
                { 
                    // nCmdForShow access WindowState which is inaccessible for RBW.
                    // Thus doing so in a virtual that RBW overrides 
                    nCmd = nCmdForShow();
                }
                else
                { 
                    nCmd = NativeMethods.SW_HIDE;
                } 
                UnsafeNativeMethods.ShowWindow(new HandleRef(this, CriticalHandle), nCmd); 

                // We already did a ShowWindow upabove and then because of the using, we will flush which 
                // will cause us to set the visibility. Ideally I would like to simply not have the ShowWindow
                // call above, *but* there is this SHOWNA stuff which is tied to Focus/Activation cleanup
                // scheduled for M8.
                //set the style 
                SafeStyleSetter();
            } 
 

            // dialog functionality; start dispatcher loop to block the call 
            if ((_showingAsDialog == true) && (_isVisible == true))
            {
                // hamidm -- 07/07/04
                // PS Bug # 992107, 935429 
                //
                // Since we exited the Context, we need to make sure 
                // we enter it before returning even if there is an 
                // exception
                // 
                Debug.Assert(_dispatcherFrame == null, "_dispatcherFrame must be null here");

                try
                { 
                    // tell users we're going modal
                    ComponentDispatcher.PushModal(); 
 
                    _dispatcherFrame = new DispatcherFrame();
                    Dispatcher.PushFrame(_dispatcherFrame); 
                }
                finally
                {
                    // tell users we're going non-modal 
                    ComponentDispatcher.PopModal();
                } 
            } 

            return null; 
        }

        internal virtual int nCmdForShow()
        { 
            int nCmd = 0;
            switch(WindowState) 
            { 
                case WindowState.Maximized:
                    nCmd = NativeMethods.SW_SHOWMAXIMIZED; // The OS doesn't provide support for non-activated maximized windows. 
                    break;
                case WindowState.Minimized:
                    nCmd = ShowActivated ? NativeMethods.SW_SHOWMINIMIZED : NativeMethods.SW_SHOWMINNOACTIVE;
                    break; 
                 default:
                    nCmd = ShowActivated ? NativeMethods.SW_SHOW : NativeMethods.SW_SHOWNA; 
                    break; 
            }
            return nCmd; 
        }

        /// 
        ///     Critical: This code elevates 
        ///     TreatAsSafe: This code is safe to call since it is not configurable and sets a preallowed style
        ///  
        [SecurityCritical,SecurityTreatAsSafe] 
        private void SafeStyleSetter()
        { 
            (new UIPermission(UIPermissionWindow.AllWindows)).Assert();
            try//blessed assert to toggle visibility, this does not let random styles from being set
            {
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd)) 
                {
                    _Style = _isVisible ? (_Style | NativeMethods.WS_VISIBLE) : _Style; 
                } 
            }
            finally 
            {
                UIPermission.RevertAssert();
            }
        } 
        private static bool _ValidateSizeToContentCallback(object value)
        { 
            return IsValidSizeToContent((SizeToContent)value); 
        }
 
        /// 
        /// SizeToContent property GetValue override
        /// 
        ///  
        /// 
        private static object _SizeToContentGetValueOverride(DependencyObject d) 
        { 
            Window w = d as Window;
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            return w.SizeToContent;
        }
 
        /// 
        /// SizeToContent property invalidation callback 
        ///  
        private static void _OnSizeToContentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = d as Window;

            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnSizeToContentChanged((SizeToContent) e.NewValue); 
        }
 
        private void OnSizeToContentChanged(SizeToContent sizeToContent) 
        {
            // this call ends up throwing an exception if accessing 
            // SizeToContent is not allowed
            VerifyApiSupported();

            // Update HwndSource's SizeToContent. 
            // HwndSource will only update layout if the value has changed.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            { 
                HwndSourceSizeToContent = sizeToContent;
            }
        }
 
        /// 
        /// Validate [Max/Min]Width/Height and Top/Left value. 
        ///  
        /// Length takes Double; Win32 handles Int.
        /// We throw exception when the value goes below Int32Min and Int32Max. 
        /// WorkItem 26263: ValidateValueCallback needs to move to PropertyMetadata so Window can
        /// add its own validation and validate before invalid value is set. Right now, we can only
        /// validate this in PropertyInalidatinonCallback because of this. (We couldn't make it virtual on
        /// FrameworkELement because ValidateValueCallback doesn't provide context. Work item 25275). 
        private static void ValidateLengthForHeightWidth(double l)
        { 
            //basically, NaN and PositiveInfinity are ok, and then anything 
            //that can be converted to Int32
            if (!Double.IsPositiveInfinity(l) && !DoubleUtil.IsNaN(l) && 
                ((l > Int32.MaxValue) || (l < Int32.MinValue)))
            {
                throw new ArgumentException(SR.Get(SRID.ValueNotBetweenInt32MinMax, l));
            } 
        }
 
        private static void ValidateTopLeft(double length) 
        {
            // Values not allowed: PositiveInfinity, NegativeInfinity 
            // and values that are beyond the range of Int32
            if (Double.IsPositiveInfinity(length) ||
                Double.IsNegativeInfinity(length))
            { 
                throw new ArgumentException(SR.Get(SRID.InvalidValueForTopLeft, length));
            } 
 
            if ((length > Int32.MaxValue) ||
                (length < Int32.MinValue)) 
            {
                throw new ArgumentException(SR.Get(SRID.ValueNotBetweenInt32MinMax, length));
            }
        } 

        private static void _OnHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            Window w = d as Window;
            Debug.Assert(w != null, "d must be typeof Window"); 
            if (w._updateHwndSize)
            {
                w.OnHeightChanged((double) e.NewValue);
            } 
        }
 
        /// 
        /// There is an explicit demand here - to enforce not being able to set this DP in Internet Zone.
        /// this should remanin here until Window spoofing work is done. 
        ///
        private void OnHeightChanged(double height)
        {
            // WOSB 1018227:  Move ValidateLengthForHeightWidth calls from property 
            // invalidation callback to PropertyMetadata
            ValidateLengthForHeightWidth(height); 
 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false && !DoubleUtil.IsNaN(height)) 
            {
                UpdateHeight(height);
            }
        } 

        private static void _OnMinHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            Window w = d as Window;
            Debug.Assert(w != null, "d must be typeof Window"); 
            w.OnMinHeightChanged((double) e.NewValue);
        }

        private void OnMinHeightChanged(double minHeight) 
        {
            // this call ends up throwing an exception if accessing 
            // MinHeight is not allowed 
            VerifyApiSupported();
 
            ValidateLengthForHeightWidth(minHeight);
            // Only trigger immediate size update when hwnd has been created and MinHeight is not Auto and MinHeight is
            // greater then current ActualHeight.
            // If hwnd hasn't been created, size will be controlled when it is created. 
            // If MinHeight is Auto or ActualHeight is greater than MinHeight, there is no need update size of the window.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if ((IsSourceWindowNull == false ) && (IsCompositionTargetInvalid == false) && (minHeight > ActualHeight))
            { 
                if (WindowState == WindowState.Normal)
                {
                    UpdateHwndSizeOnWidthHeightChange(ActualWidth, minHeight);
                } 
                else
                { 
                    // no need to do anything.  When window is restored, we get WM_GETMINMAXINFO where 
                    // we restrict the max/min size of the window to [Max/Min][Height/Width]
                } 
            }
        }

        private static void _OnMaxHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = d as Window; 
            Debug.Assert(w != null, "d must be typeof Window"); 
            w.OnMaxHeightChanged((double) e.NewValue);
        } 

        private void OnMaxHeightChanged(double maxHeight)
        {
            // this call ends up throwing an exception if accessing 
            // MaxHeight is not allowed
            VerifyApiSupported(); 
 
            ValidateLengthForHeightWidth(MaxHeight);
 
            // Only trigger immediate size update when hwnd has been created and MaxHeight is not Auto and
            // ActualHeight > MaxHeight
            //
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if ((IsSourceWindowNull == false) && (IsCompositionTargetInvalid == false) &&(maxHeight < ActualHeight))
            { 
                if (WindowState == WindowState.Normal) 
                {
                    UpdateHwndSizeOnWidthHeightChange(ActualWidth, maxHeight); 
                }
                else
                {
                    // no need to do anything.  When window is restored, we get WM_GETMINMAXINFO where 
                    // we restrict the max/min size of the window to [Max/Min][Height/Width]
                } 
            } 
        }
 
        private static void _OnWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            Window w = d as Window;
            Debug.Assert(w != null, "d must be typeof Window"); 
            if (w._updateHwndSize)
            { 
                w.OnWidthChanged((double) e.NewValue); 
            }
        } 

        private void OnWidthChanged(double width)
        {
            ValidateLengthForHeightWidth(width); 

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false && !DoubleUtil.IsNaN(width)) 
            {
                UpdateWidth(width); 
            }
        }

        private static void _OnMinWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = d as Window; 
            Debug.Assert(w != null, "d must be typeof Window"); 
            w.OnMinWidthChanged((double) e.NewValue);
        } 

        private void OnMinWidthChanged(double minWidth)
        {
            // this call ends up throwing an exception if accessing 
            // MinWidth is not allowed
            VerifyApiSupported(); 
 
            // WOSB 1018227:  Move ValidateLengthForHeightWidth calls from property
            // invalidation callback to PropertyMetadata 
            ValidateLengthForHeightWidth(minWidth);
            // Only trigger immediate size update when hwnd has been created and MinWidth is not Auto and MinWidth is
            // greater then current ActualWidth.
            // If hwnd hasn't been created, size will be controlled when it is created. 
            // If MinWidth is Auto or ActualWidth is greater than MinWidth, there is no need update size of the window.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if ((IsSourceWindowNull == false) && (IsCompositionTargetInvalid == false) && (minWidth > ActualWidth))
            { 
                if ( WindowState == WindowState.Normal)
                {
                    UpdateHwndSizeOnWidthHeightChange(minWidth, ActualHeight);
                } 
                else
                { 
                    // no need to do anything.  When window is restored, we get WM_GETMINMAXINFO where 
                    // we restrict the max/min size of the window to [Max/Min][Height/Width]
                } 
            }
        }

        private static void _OnMaxWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = d as Window; 
            Debug.Assert(w != null, "d must be typeof Window"); 
            w.OnMaxWidthChanged((double) e.NewValue);
        } 

        private void OnMaxWidthChanged(double maxWidth)
        {
            // this call ends up throwing an exception if accessing 
            // MaxWidth is not allowed
            VerifyApiSupported(); 
 
            ValidateLengthForHeightWidth(maxWidth);
            // Only trigger immediate size update when hwnd has been created and MaxWidth is not Auto and 
            // ActualWidth > MaxWidth
            //
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if ((IsSourceWindowNull == false ) && (IsCompositionTargetInvalid == false) && (maxWidth < ActualWidth)) 
            {
                if (WindowState == WindowState.Normal) 
                { 
                    UpdateHwndSizeOnWidthHeightChange(maxWidth, ActualHeight);
                } 
                else
                {
                    // no need to do anything.  When window is restored, we get WM_GETMINMAXINFO where
                    // we restrict the max/min size of the window to [Max/Min][Height/Width] 
                }
            } 
        } 

        // Updates the restore bounds of the hwnd based on BoundsSpecified enum values 
        // OR-ing of BoundsSpecified enum is not supported.
        /// 
        ///     Critical: This code accesses CriticalHandle
        ///     TreatAsSafe:This code is disabled for all windows including RBW in PartialTrust 
        /// 
        [SecurityCritical,SecurityTreatAsSafe] 
        private void UpdateHwndRestoreBounds(double newValue, BoundsSpecified specifiedRestoreBounds) 
        {
            SecurityHelper.DemandUIWindowPermission(); 

            NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT();
            wp.length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT));
            UnsafeNativeMethods.GetWindowPlacement(new HandleRef(this, CriticalHandle), ref wp); 

            double convertedValue = (LogicalToDeviceUnits(new Point(newValue, 0))).X; 
            switch (specifiedRestoreBounds) 
            {
                case BoundsSpecified.Height: 
                    wp.rcNormalPosition_bottom = wp.rcNormalPosition_top + DoubleUtil.DoubleToInt(convertedValue);
                    break;
                case BoundsSpecified.Width:
                    wp.rcNormalPosition_right = wp.rcNormalPosition_left + DoubleUtil.DoubleToInt(convertedValue); 
                    break;
                case BoundsSpecified.Top: 
                    // convert input value into work-area co-ods 
                    double newTop = newValue;
                    // [Get/Set]WindowPlacement work with workarea co-ods for a top level 
                    // window whose WS_EX_TOOLWINDOW bit is clear.  If this bit is set,
                    // then the co-ods are expected to be in screen co-ods of the monitor.
                    // TransfromWorkAreaScreenArea can transform a point from work area co-ods
                    // to screen area co-ods and vice versa depending on TransformType value passed. 
                    // So, in our case, if the window is not a ToolWindow we want to transform
                    // the input value from screen co-ods to work area co-ods. 
                    if ((StyleExFromHwnd & NativeMethods.WS_EX_TOOLWINDOW) == 0) 
                    {
                        newTop = TransformWorkAreaScreenArea(new Point(0, newTop), TransformType.ScreenAreaToWorkArea).Y; 
                    }
                    newTop = (LogicalToDeviceUnits(new Point(0, newTop))).Y;
                    int currentHeight = wp.rcNormalPosition_bottom - wp.rcNormalPosition_top;
                    wp.rcNormalPosition_top = DoubleUtil.DoubleToInt(newTop); 
                    wp.rcNormalPosition_bottom = wp.rcNormalPosition_top + currentHeight;
                    break; 
                case BoundsSpecified.Left: 
                    // convert input value into work-area co-ods
                    double newLeft = newValue; 
                    // [Get/Set]WindowPlacement work with workarea co-ods for a top level
                    // window whose WS_EX_TOOLWINDOW bit is clear.  If this bit is set,
                    // then the co-ods are expected to be in screen co-ods of the monitor.
                    // TransfromWorkAreaScreenArea can transform a point from work area co-ods 
                    // to screen area co-ods and vice versa depending on TransformType value passed.
 
                    // So, in our case, if the window is not a ToolWindow we want to transform 
                    // the input value from screen co-ods to work area co-ods.
                    if ((StyleExFromHwnd & NativeMethods.WS_EX_TOOLWINDOW) == 0) 
                    {
                        newLeft = TransformWorkAreaScreenArea(new Point(newLeft, 0), TransformType.ScreenAreaToWorkArea).X;
                    }
                    newLeft = (LogicalToDeviceUnits(new Point(newLeft, 0))).X; 
                    int currentWidth = wp.rcNormalPosition_right - wp.rcNormalPosition_left;
                    wp.rcNormalPosition_left = DoubleUtil.DoubleToInt(newLeft); 
                    wp.rcNormalPosition_right = wp.rcNormalPosition_left + currentWidth; 
                    break;
                default: 
                    Debug.Assert(false, String.Format("specifiedRestoreBounds can't be {0}", specifiedRestoreBounds));
                    break;
            }
 
            UnsafeNativeMethods.SetWindowPlacement(new HandleRef(this, CriticalHandle), ref wp);
        } 
 
        // deltaX = workAreaOriginValue - screenOriginValue (both in virtual co-ods)
        // X(screenAreaCood) = x(workAreaCood) + deltaX 
        /// 
        /// Critical: This code acceses CriticalHandle
        ///     TreatAsSafe: This code only works under RBW code path , this operation is ok since
        ///     RBW window is bound to the restrictions of its parent window which is the browser 
        /// 
        [SecurityCritical,SecurityTreatAsSafe] 
        private Point TransformWorkAreaScreenArea(Point pt, TransformType transformType) 
        {
            int deltaX = 0; 
            int deltaY = 0;
            Point retPt;
            if (!_inTrustedSubWindow)
            { 
                SecurityHelper.DemandUIWindowPermission();
            } 
 
            // First we get the monitor on which the window is on.  [Get/Set]WindowPlacement
            // co-ods are dependent on the monitor on which the window is on. 
            IntPtr hMonitor = SafeNativeMethods.MonitorFromWindow(new HandleRef(this, CriticalHandle), NativeMethods.MONITOR_DEFAULTTONULL);

            if (hMonitor != IntPtr.Zero)
            { 
                NativeMethods.MONITORINFOEX monitorInfo = new NativeMethods.MONITORINFOEX();
                monitorInfo.cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX)); 
 
                SafeNativeMethods.GetMonitorInfo(new HandleRef(this, hMonitor), monitorInfo);
                NativeMethods.RECT workAreaRect = monitorInfo.rcWork; 
                NativeMethods.RECT screenAreaRect = monitorInfo.rcMonitor;
                deltaX = workAreaRect.left - screenAreaRect.left;
                deltaY = workAreaRect.top - screenAreaRect.top;
            } 

            if (transformType == TransformType.WorkAreaToScreenArea) 
            { 
                retPt = new Point(pt.X + deltaX, pt.Y + deltaY);
            } 
            else
            {
                retPt = new Point(pt.X - deltaX, pt.Y - deltaY);
            } 
            return retPt;
        } 
 
        // Hua Wang: The logic for coerce Top & Left
        // 1.   Before Window is first shown (w.IsSourceWindowNull == false) 
        //      The value can come from 3 parties
        //          a. default
        //          b. SetValue
        //          c. Style, trigger... 
        //      In all those 3 cases, we would like to pass the value because we don't have a
        //      different value from hwnd before it is shown. 
        // 
        // To understarnd the below 2 cases better, you will need to know the Window position API precedence as following:
        //      WindowState > WindowStartupLocation (only works the first time shown) > Top/Left 
        //
        // 2.   During show
        //      There are 3 places that can coerce value during show. Right now they are all in
        //      SetupInitialState. 
        //          a. After CreateWindowEx.
        //                  i. We should always update with the win32 default position when it is Nan. 
        //                  ii. If WindowState is maxmized, we should always return from the hwnd (_actualTop/Left), 
        //                  but update the hwnd restorebounds. So setting Top/Left WindowState to to Maxmized before show would
        //                  work for restorebounds (details in bug 1217802). 
        //          b. If Top/Left is set and/or WindowStartupLocation is effective.
        //                  WindowState must be normal here because it takes precedence over WindowStartupLocation and Top/Left.
        //                  Since WindowStartupLocation only works the first time shown, we have a flag (_updateStartupLocation)
        //                  to help indicating that. 
        //                  If StartupLocation is effective, we should return from the hwnd (_actualTop/Left).
        //          c. If SizeToContent is set and WindowStartupLocation is effective. 
        //                  Same as b. 
        //
        // 3.   After show 
        //      a. User moves the Window.
        //          If user resize, we set local value (SetValue).
        //      b. User maximizes or minimizes. Or WindowState is changed programmtically
        //          We coerce Top and Left's value when WindowState is changed no matter whether it is 
        //          from user action or programmtically.
        //      c. SetValue 
        //      hamidm -- 5/15/2007  WOSB 1447707, 1813033 
        //      d. WM_MOVE
        //          When we get WM_MOVE as a result of window moving, we coerce Top/Left to the actual location 
        //          of the hwnd. _coercedFromWmMoveChanged is used to identify this case
        //
        //      For b and c, when WindowState is max or min, the hwnd value should always be returned.
        //      The new value should be set as restorebounds. Otherwise update with the new value. 
        //
        // Note: as we can see from above logic, _actualTop/Left should always be updated with the current hwnd position before we 
        // coerce Top and Left after hwnd is created. 
        private static object CoerceTop(DependencyObject d, object value)
        { 
            Window w = d as Window;

            // this call ends up throwing an exception if accessing Top
            // is not allowed 
            w.VerifyApiSupported();
 
            double top = (double)value; 

            // WOSB 1018227:  Move ValidateTopLeft calls from property 
            // invalidation callback to PropertyMetadata
            ValidateTopLeft(top);

            if (double.IsNaN(top)) 
            {
                return w._actualTop; 
            } 
            else
            { 
                // If it is after hwnd has been created.
                // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
                if (w.IsSourceWindowNull == false && w.IsCompositionTargetInvalid == false)
                { 
                    if (w.WindowState != WindowState.Normal)
                    { 
                        // We need to update restore bounds here instead of in property changed callback. 
                        // It is because when WindowState is maximized (Top is 0) and then developer sets Top to 100,
                        // the coerce call back still returns 0 so GetValue will get the correct value. 
                        // Top property changed callback will not be called.
                        w.UpdateHwndRestoreBounds(top, BoundsSpecified.Top);
                        return w._actualTop;
 
                    }
                    else 
                    { 
                        if ((w._updateStartupLocation) && (w.WindowStartupLocation != WindowStartupLocation.Manual))
                        { 
                            return w._actualTop;
                        }
                    }
                } 
            }
 
            if (w._coercedFromWmMoveChanged) 
            {
                return w._actualTop; 
            }

            return value;
        } 

        private static void _OnTopChanged (DependencyObject d , DependencyPropertyChangedEventArgs e) 
        { 
            Window w = d as Window;
            Debug.Assert( w != null, "DependencyObject must be of type Window." ); 

            if (w._updateHwndLocation)
            {
                w.OnTopChanged((double) e.NewValue); 
            }
        } 
 
        private void OnTopChanged(double newTop)
        { 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            {
                // NaN is special and indicates using Win32 default, 
                // so we exclude that.
                if (DoubleUtil.IsNaN(newTop) == false) 
                { 
                    if (WindowState == WindowState.Normal)
                    { 
                        Invariant.Assert(!Double.IsNaN(_actualLeft), "_actualLeft cannot be NaN after show");
                        UpdateHwndPositionOnTopLeftChange(Double.IsNaN(Left) ? _actualLeft : Left, newTop);
                    }
                } 
            }
            else 
            { 
                // here the value is stored as measure units as newTop is in measure/logical units
                _actualTop = newTop; 
            }
        }

        // Please see comments for CoerceTop. 
        private static object CoerceLeft(DependencyObject d, object value)
        { 
            Window w = d as Window; 

            // this call ends up throwing an exception if setting property is not allowed 
            w.VerifyApiSupported();

            double left = (double)value;
 
            // WOSB 1018227:  Move ValidateTopLeft calls from property
            // invalidation callback to PropertyMetadata 
            ValidateTopLeft(left); 

            if (double.IsNaN(left)) 
            {
                return w._actualLeft;
            }
            else 
            {
                // If window is minmized ot maximized, if hwnd is created, should update the restore bounds 
                // shouldn't change the value 
                //
                // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
                if (w.IsSourceWindowNull == false && w.IsCompositionTargetInvalid == false)
                {
                    if (w.WindowState != WindowState.Normal)
                    { 
                        w.UpdateHwndRestoreBounds(left, BoundsSpecified.Left);
                        return w._actualLeft; 
                    } 
                    else
                    { 
                        if ((w._updateStartupLocation) && (w.WindowStartupLocation != WindowStartupLocation.Manual))
                        {
                            return w._actualLeft;
                        } 
                    }
                } 
            } 

            if (w._coercedFromWmMoveChanged) 
            {
                return w._actualLeft;
            }
 
            return value;
        } 
 
        private static void _OnLeftChanged (DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = d as Window;
            Debug.Assert( w != null, "DependencyObject must be of type Window." );

            if (w._updateHwndLocation) 
            {
                w.OnLeftChanged((double) e.NewValue); 
            } 
        }
 
        // _actualLeft is used to determine if LocationChanged should be fired in WMMoveChagnged.
        // We need it b/c we need to remember the last hwnd Left location to decide whether
        // we need to fire the event or not.  Why do we need to update here?  Well, for the following
        // scenario: 
        //    Window w = new Window();
        //    w.Left = 100; 
        //    w.WindowStyle = WindowStyle.None; 
        //    w.Show();
        // 
        //  In this case, we want to not fire LocationChanged from SetWindowPos called called
        //  from CorrectStyleForBorderlessWindowCase().
        //
        //  _actualLeft is update from the following places: 
        //
        // 
        // 1) In WM_MOVE handler 
        //
        // 2) In OnLeftChanged for the case when the hwnd is not created yet. 
        //
        // 3) SetupInitialState
        private void OnLeftChanged(double newLeft)
        { 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            { 
                // NaN is special and indicates using Win32 default,
                // so we exclude that here. 
                if (DoubleUtil.IsNaN(newLeft) == false)
                {
                    if (WindowState == WindowState.Normal)
                    { 
                        Invariant.Assert(!Double.IsNaN(_actualTop), "_actualTop cannot be NaN after show");
                        UpdateHwndPositionOnTopLeftChange(newLeft, Double.IsNaN(Top) ? _actualTop : Top); 
                    } 
                }
            } 
            else
            {
                // here the value is stored as measure units as newLeft is in measure/logical units
                _actualLeft = newLeft; 
            }
        } 
 
        /// 
        ///     Critical: This code accesses Hwnd and can be used to reposition window 
        ///     TreatAsSafe: Will not work on any window in partial trust
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        private void UpdateHwndPositionOnTopLeftChange(double leftLogicalUnits, double topLogicalUnits) 
        {
            Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull cannot be true when calling this function"); 
            SecurityHelper.DemandUIWindowPermission(); 

            Point ptDeviceUnits = LogicalToDeviceUnits(new Point(leftLogicalUnits, topLogicalUnits)); 

            UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle),
                        new HandleRef(null, IntPtr.Zero),
                        DoubleUtil.DoubleToInt(ptDeviceUnits.X), 
                        DoubleUtil.DoubleToInt(ptDeviceUnits.Y),
                        0, 
                        0, 
                        NativeMethods.SWP_NOSIZE | NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE
                        ); 
        }

        private static bool _ValidateResizeModeCallback(object value)
        { 
            return IsValidResizeMode((ResizeMode)value);
        } 
 
        private static void _OnResizeModeChanged (DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = d as Window;
            Debug.Assert( w != null, "DependencyObject must be of type Window." );

            w.OnResizeModeChanged(); 
        }
 
        private void OnResizeModeChanged() 
        {
            // this call ends up throwing an exception if accessing 
            // ResizeMode is not allowed
            VerifyApiSupported();

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if ( IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            { 
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd  )) 
                {
                    CreateResizibility(); 
                }
            }
        }
 
        private static object VerifyAccessCoercion(DependencyObject d, object value)
        { 
            // this call ends up throwing an exception if setting property is not allowed 
            ((Window)d).VerifyApiSupported();
 
            return value;
        }

        private static void _OnFlowDirectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = d as Window; 
            Debug.Assert(w != null, "DependencyObject must be of type Window."); 

            w.OnFlowDirectionChanged(); 
        }

        /// 
        ///     Right to Left 
        /// 
        private void OnFlowDirectionChanged() 
        { 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            {
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd ))
                {
                    CreateRtl(); 
                }
            } 
        } 

        private static object CoerceRenderTransform(DependencyObject d, object value) 
        {
            Transform renderTransformValue = (Transform)value;

            if ((value == null) || 
                (renderTransformValue != null && renderTransformValue.Value != null && renderTransformValue.Value.IsIdentity == true))
            { 
                // setting this value is allowed. 
            }
            else 
            {
                throw new InvalidOperationException(SR.Get(SRID.TransformNotSupported));
            }
 
            return value;
        } 
 
        private static void _OnRenderTransformChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
        }

        private static object CoerceClipToBounds(DependencyObject d, object value)
        { 
            if (value != BooleanBoxes.FalseBox)
            { 
                throw new InvalidOperationException(SR.Get(SRID.ClipToBoundsNotSupported)); 
            }
            return value; 
        }

        private static void _OnClipToBoundsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
        }
 
        ///  
        ///     sets taskbar status
        /// 
        ///


 

 
 

 



        [SecurityCritical, SecurityTreatAsSafe ] 
        private void SetTaskbarStatus()
        { 
            if (ShowInTaskbar == false) // don't show in taskbar 
            {
                SecurityHelper.DemandUIWindowPermission(); 

                // when this window is a top-level window
                if (_ownerHandle == IntPtr.Zero)
                { 
                    // need to parent this window to a hidden window
                    if (_hiddenWindow == null) 
                    { 
                        HwndSourceParameters param = new HwndSourceParameters("Hidden Window");
                        param.SetSize(NativeMethods.CW_USEDEFAULT, NativeMethods.CW_USEDEFAULT); 
                        param.SetPosition(NativeMethods.CW_USEDEFAULT, NativeMethods.CW_USEDEFAULT);
                        param.WindowStyle = NativeMethods.WS_OVERLAPPEDWINDOW;
                        _hiddenWindow = new HwndSource(param);
                    } 
                    SetParentHandle(_hiddenWindow.Handle);
                } 
                _StyleEx &= ~NativeMethods.WS_EX_APPWINDOW; 
            }
            else // (ShowInTaskbar == true) show in task bar 
            {
                _StyleEx |= NativeMethods.WS_EX_APPWINDOW;
                if( ! IsSourceWindowNull )
                { 
                    if ((_hiddenWindow != null) && ( _ownerHandle == _hiddenWindow.Handle))
                    { 
                        SetParentHandle(IntPtr.Zero); 
                    }
                } 
            }
        }

        private void CreateRtl() 
        {
            if ( this.FlowDirection == FlowDirection.LeftToRight ) 
            { 
                _StyleEx &= ~NativeMethods.WS_EX_LAYOUTRTL;
            } 
            else if ( this.FlowDirection == FlowDirection.RightToLeft )
            {
                _StyleEx |= NativeMethods.WS_EX_LAYOUTRTL;
            } 
            else
            { 
                throw new InvalidOperationException(SR.Get(SRID.IncorrectFlowDirection)); 
            }
 
        }

        /// 
        ///     Updates both style and styleEx for the window 
        ///
        /// 
 

 



 

 
        [SecurityCritical,SecurityTreatAsSafe] 
        internal void Flush()
        { 
            // hamidm - 07/13/2005: WOSB 1178019 (A NullReferenceException occurs when animating
            // the WindowStyle enum via a custom animation).  This bug contains details of
            // why we were seeing the null ref.
            // 
            // Sometimes, the SetWindowPos call below results in sending certain window messages
            // like (WM_SIZE) and their handling leads to setting some property on the Window leading 
            // to a call to HwndStyleManager.StartManaging.  Thus, we end up calling 
            // dispose on the "new" usage of the Manager before we complete this run of Flush method.
            // This resulted in null ref in setting the Dirty bit below since we were not using 
            // a local copy and the window member copy was already set to null by the "new" usage
            // of Manager.  To fix this bug, we do the following two things:
            //
            // 1) Keep a local copy of HwndStyleManager in this method to make it re-entrant. 
            // 2) null out _window.Manager in HwndStyleMangager.Dispose only if _window.Manager is
            //    this instance of the Manager. 
            // 
            HwndStyleManager manager = Manager;
            if (manager.Dirty && CriticalHandle != IntPtr.Zero) 
            {
                UnsafeNativeMethods.CriticalSetWindowLong(new HandleRef(this,CriticalHandle), NativeMethods.GWL_STYLE, (IntPtr)_styleDoNotUse.Value);
                UnsafeNativeMethods.CriticalSetWindowLong(new HandleRef(this,CriticalHandle), NativeMethods.GWL_EXSTYLE, (IntPtr)_styleExDoNotUse.Value);
 
                UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle), NativeMethods.NullHandleRef, 0, 0, 0, 0,
                                               NativeMethods.SWP_NOMOVE | 
                                               NativeMethods.SWP_NOSIZE | 
                                               NativeMethods.SWP_NOZORDER |
                                               NativeMethods.SWP_FRAMECHANGED | 
                                               NativeMethods.SWP_DRAWFRAME |
                                               NativeMethods.SWP_NOACTIVATE);
                manager.Dirty = false;
            } 
        }
        private void ClearRootVisual() 
        { 
            _swh.ClearRootVisual();
        } 


        private NativeMethods.POINT GetPointRelativeToWindow( int x, int y )
        { 
            return _swh.GetPointRelativeToWindow( x, y, this.FlowDirection);
        } 
 
        //     If you're in the middle of changing the window's _style or _styleEx and call this function,
        //     you may get inconsistent results. 
        private Size GetHwndNonClientAreaSizeInMeasureUnits()
        {
            // HwndSource expands the client area to cover the entire window when it is in UsesPerPixelOpacity mode,
            // So non client area is (0,0) 
            return AllowsTransparency ? new Size(0, 0) : _swh.GetHwndNonClientAreaSizeInMeasureUnits();
        } 
 
        ///
        ///      Critical as this method accesses critical data. 
        ///      TreatAsSafe - this method "eliminates" critical data - ergo considered safe.
        ///
        [SecurityCritical, SecurityTreatAsSafe]
        private void ClearSourceWindow() 
        {
            if (_swh != null) 
            { 
                try
                { 
                    _swh.RemoveDisposedHandler(OnSourceWindowDisposed);
                }
                finally
                { 
                    HwndSource source = _swh.HwndSourceWindow;
                    _swh = null; 
 
                    if (source != null)
                    { 
                        source.SizeToContentChanged -= new EventHandler(OnSourceSizeToContentChanged);
                    }
                }
            } 
        }
 
        ///  
        /// Critical - accesses _ownerHandle and SetParentHandle.
        /// TreatAsSafe - doesn't disclose _ownerHandle; setting parent's handle to IntPtr.Zero is considered a safe operation. 
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        private void ClearHiddenWindowIfAny()
        { 
            // If there is a hiddenWindow and it's the owner of the current one as the result of setting ShowInTaskbar,
            // we need to unparent it. Because when we dipose the hiddenWindow, if it's still the parent 
            // of the current window, the current Window will get a second WM_DESTORY because its owner being distoried. 
            // See detail in bug 953988.
            // Unparent it in WM_CLOSE because when we get to WM_DESTROY, _sourceWindow.Handle could be IntPtr.Zero; 
            // InternalDispose() is where _hiddenWindow is disposed. It could be called from two places: 1. WmDestroy 2. OnSourceWindowDisposed.
            // When it's called from OnSourceWindowDisposed, _sourceWindow.Handle could have been set to IntPtr.Zero.
            if ((_hiddenWindow != null) && (_hiddenWindow.Handle == _ownerHandle))
            { 
                SetParentHandle(IntPtr.Zero);
            } 
        } 

        private void VerifyConsistencyWithAllowsTransparency() 
        {
            if (AllowsTransparency && WindowStyle != WindowStyle.None)
            {
                throw new InvalidOperationException(SR.Get(SRID.MustUseWindowStyleNone)); 
            }
        } 
 
        /// 
        /// Ciritical - accesses _inTrustedSubWindow. 
        /// TreatAsSafe - doesn't reveal _inTrustedSubWindow.
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        private void VerifyConsistencyWithShowActivated() 
        {
            // 
            // We don't support to show a maximized non-activated window. 
            // Don't check this consistency in a RBW (would break because Visibility is set when launching the RBW).
            // 
            if (!_inTrustedSubWindow && WindowState == WindowState.Maximized && !ShowActivated)
                throw new InvalidOperationException(SR.Get(SRID.ShowNonActivatedAndMaximized));
        }
 
        private static bool IsValidSizeToContent(SizeToContent value)
        { 
            return value == SizeToContent.Manual || 
                   value == SizeToContent.Width ||
                   value == SizeToContent.Height || 
                   value == SizeToContent.WidthAndHeight;
        }

        private static bool IsValidResizeMode(ResizeMode value) 
        {
            return value == ResizeMode.NoResize 
                || value == ResizeMode.CanMinimize 
                || value == ResizeMode.CanResize
                || value == ResizeMode.CanResizeWithGrip; 
        }

        private static bool IsValidWindowStartupLocation(WindowStartupLocation value)
        { 
            return value == WindowStartupLocation.CenterOwner
                || value == WindowStartupLocation.CenterScreen 
                || value == WindowStartupLocation.Manual; 
        }
 
        private static bool IsValidWindowState(WindowState value)
        {
            return value == WindowState.Maximized
                || value == WindowState.Minimized 
                || value == WindowState.Normal;
        } 
 
        private static bool IsValidWindowStyle(WindowStyle value)
        { 
            return value == WindowStyle.None
                || value == WindowStyle.SingleBorderWindow
                || value == WindowStyle.ThreeDBorderWindow
                || value == WindowStyle.ToolWindow; 
        }
 
        #endregion Private Methods 

        //---------------------------------------------- 
        //
        // Private Properties
        //
        //---------------------------------------------- 
        #region Private Properties
 
        private SizeToContent HwndSourceSizeToContent 
        {
            get 
            {
                return _swh.HwndSourceSizeToContent;
            }
            set 
            {
                _swh.HwndSourceSizeToContent = value; 
            } 
        }
 
        private NativeMethods.RECT WindowBounds
        {
            get
            { 
                Debug.Assert( _swh != null );
                return _swh.WindowBounds; 
            } 
        }
 
        private int StyleFromHwnd
        {
            get
            { 
                return _swh != null ? _swh.StyleFromHwnd : 0;
            } 
        } 

        private int StyleExFromHwnd 
        {
            get
            {
                return _swh != null ? _swh.StyleExFromHwnd : 0; 
            }
        } 
 
        /// 
        ///     Private helper for OwnedWindows property. 
        ///     The public version returns a copy of the WindowCollection.
        ///     For internal Window usage, we use OwnedWindowInternal
        ///     so that we can modify the underlying collection.
        ///  
        private WindowCollection OwnedWindowsInternal
        { 
            get 
            {
                if (_ownedWindows == null) 
                {
                    _ownedWindows = new WindowCollection();
                }
                return _ownedWindows; 
            }
        } 
 
        /// 
        ///     Application Instance 
        /// 
        private System.Windows.Application App
        {
            get {return System.Windows.Application.Current;} 
        }
 
        ///  
        ///     Tells whether the Application object exists or not
        ///  
        private bool IsInsideApp
        {
            get
            { 
                return (Application.Current != null);
            } 
        } 

        ///  
        ///     List of events on this Window
        /// 
        private EventHandlerList Events
        { 
            get
            { 
                if (_events == null) 
                {
                    _events = new EventHandlerList(); 
                }
                return _events;
            }
        } 
        #endregion Private Properties
 
 
        //----------------------------------------------
        // 
        // Private Fields
        //
        //----------------------------------------------
        #region Private Fields 

        private SourceWindowHelper  _swh;                               // object that will hold the window 
        private Window              _ownerWindow;                       // owner window 

        // keeps track of the owner hwnd 
        // we need this one b/c a owner/parent
        // can be set through the WindowInteropHandler
        // which is different than the owner Window object
        /// 
        /// Critical - handle of the parent window; get/set considered privileged operation
        /// 
        [SecurityCritical] 
        private IntPtr              _ownerHandle = IntPtr.Zero;   // no need to dispose this
        private WindowCollection    _ownedWindows; 
        private ArrayList           _threadWindowHandles;

        private bool                _updateHwndSize     = true;
        private bool                _updateHwndLocation = true; 
        private bool                _updateStartupLocation;
        private bool                _coercedFromWmMoveChanged;  // is used to special case Coerce[Top/Left] when called from WmMoveChanged 
        private bool                _isVisible; 
        private bool                _isVisibilitySet;           // use this to tell whether Visibility is set or not.
        private bool                _resetKeyboardCuesProperty; // true if we set ShowKeyboradCuesProperty in ShowDialog 
        private bool                _previousKeyboardCuesProperty;

        private static bool         _dialogCommandAdded;
        private bool                _postContentRenderedFromLoadedHandler; 

        // 
 

        private bool                _disposed; 

        private bool                _appShuttingDown;
        private bool                _ignoreCancel;
        private bool                _showingAsDialog; 
        private bool                _isClosing;
        private bool                _visibilitySetInternally; 
 
        private double              _trackMinWidthDeviceUnits = 0;
        private double              _trackMinHeightDeviceUnits = 0; 
        private double              _trackMaxWidthDeviceUnits = Double.PositiveInfinity;
        private double              _trackMaxHeightDeviceUnits = Double.PositiveInfinity;
        private double              _currentHwndWidthDevicePixels;
        private double              _currentHwndHeightDevicePixels; 

        /// 
        /// Critical - as this data is obtained via an elevation. 
        /// TreatAsSafe - as we've decided that Window position is not directly exploitable.
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        private double              _actualTop = Double.NaN;

        /// 
        /// Critical - as this data is obtained via an elevation.
        /// TreatAsSafe - as we've decided that Window position is not directly exploitable. 
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        private double              _actualLeft = Double.NaN; 

        private bool                _inUserSizeMove;
        private bool                _userResized;
        //Never expose this at any cost 
        /// 
        ///     Critical: This is a flag to indicate that this call is under RBW 
        ///                please do not expose it 
        /// 
        [SecurityCritical] 
        private bool                        _inTrustedSubWindow;

        private BitmapFrame                 _icon;
 
        private NativeMethods.IconHandle    _defaultLargeIconHandle;
        private NativeMethods.IconHandle    _defaultSmallIconHandle; 
        private NativeMethods.IconHandle    _currentLargeIconHandle; 
        private NativeMethods.IconHandle    _currentSmallIconHandle;
 
        private bool?                       _dialogResult = null;
        ///
        /// Critical - handle of the owner dialog; get/set considered privileged operation
        /// 
        [SecurityCritical]
        private IntPtr                      _dialogOwnerHandle = IntPtr.Zero; 
        /// 
        /// Critical - handle of the active window before the dialog is shown; get/set considered privileged operation
        /// 
        [SecurityCritical]
        private IntPtr                      _dialogPreviousActiveHandle;
        private DispatcherFrame             _dispatcherFrame;
 
        private WindowStartupLocation       _windowStartupLocation = WindowStartupLocation.Manual;
 
        // The previous WindowState value before WindowState changes 
        private WindowState                 _previousWindowState = WindowState.Normal;
        /// 
        /// Critical - handle of the owner dialog; get/set considered privileged operation
        ///
        [SecurityCritical]
        private HwndSource          _hiddenWindow; 
        private EventHandlerList    _events;
 
        // These should never be used directly, access only through property accessors 

        private SecurityCriticalDataForSet                 _styleDoNotUse; 
        private SecurityCriticalDataForSet                 _styleExDoNotUse;
        private HwndStyleManager    _manager;

        // reference to Resize Grip control; this is used to find out whether 
        // the mouse of over the resizegrip control
        private Control                 _resizeGripControl; 
 
        // static objects for Events
        private static readonly object EVENT_SOURCEINITIALIZED = new object(); 
        private static readonly object EVENT_CLOSING = new object();
        private static readonly object EVENT_CLOSED = new object();
        private static readonly object EVENT_ACTIVATED = new object();
        private static readonly object EVENT_DEACTIVATED = new object(); 
        private static readonly object EVENT_STATECHANGED = new object();
        private static readonly object EVENT_LOCATIONCHANGED = new object(); 
        private static readonly object EVENT_CONTENTRENDERED = new object(); 

        internal static readonly DependencyProperty IWindowServiceProperty 
            = DependencyProperty.RegisterAttached("IWindowService", typeof(IWindowService), typeof(Window),
                                          new FrameworkPropertyMetadata((IWindowService)null,
                                          FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.OverridesInheritanceBehavior));
 
        DispatcherOperation         _contentRenderedCallback;
 
        #endregion Private Fields 

        #region Private Class 

        ///
        ///      This class - is a wrapper around the HwndSource member - stored by the Window
        ///      All properties/methods on this class are marked as crtical, as by definition this classes purpose is the storage of critical data. 
        ///      Some of the individual members are marked - "TreatAsSafe".
        /// 
        ///      If you find you need a property on HwndSource to be accessed by the outer Window class 
        ///      Make sure you understand what you're doing from a security perspective.
        ///      Consult with AvSee or HamidM if you have any questions. 
        ///
        ///
        internal class SourceWindowHelper
        { 
                ///
                ///     Critical - as this accesses critical data ( _sourceWindow ) 
                /// 
                [SecurityCritical]
                internal SourceWindowHelper( HwndSource sourceWindow ) 
                {
                    Debug.Assert( sourceWindow != null );
                    _sourceWindow = sourceWindow;
                } 

                /// 
                ///     Critical - as this accesses critical data. 
                ///     TreatAsSafe - as this function just tests to see whether _sourceWindow has been created.
                ///                          Ok to expose publically. Equivalent to is Window visible. 
                ///
                internal bool IsSourceWindowNull
                {
                    [ SecurityCritical, SecurityTreatAsSafe ] 
                    get
                    { 
                        return ( _sourceWindow == null ); 
                    }
                } 

                ///
                ///     Critical - as this accesses critical data.
                ///     TreatAsSafe - as this function just tests to see whether CompositionTarget is valid or not. 
                ///                          Ok to expose publically.
                /// 
                internal bool IsCompositionTargetInvalid 
                {
                    [ SecurityCritical, SecurityTreatAsSafe ] 
                    get
                    {
                        return (CompositionTarget == null);
                    } 
                }
 
                /// 
                ///     Critical as this method hands out critical data.
                /// 
                internal IntPtr CriticalHandle
                {
                    [ SecurityCritical]
                    get 
                    {
                        if (_sourceWindow != null) 
                        { 
                            return _sourceWindow.CriticalHandle;
                        } 
                        else
                        {
                            return IntPtr.Zero;
                        } 
                    }
                } 
 
                ///
                /// Get the work area bounds for this window - taking multi-mon into account. 
                ///
                /// 
                ///     Critical: This code accesses CriticalHandle
                ///     TreatAsSafe: This information is safe to expose. It does not expose the CriticalHandle 
                /// 
                internal NativeMethods.RECT WorkAreaBoundsForNearestMonitor 
                { 
                    [SecurityCritical, SecurityTreatAsSafe]
                    get 
                    {
                        IntPtr monitor;
                        NativeMethods.MONITORINFOEX monitorInfo = new NativeMethods.MONITORINFOEX();
                        monitorInfo.cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX)); 

                        monitor = SafeNativeMethods.MonitorFromWindow( new HandleRef( this, CriticalHandle), NativeMethods.MONITOR_DEFAULTTONEAREST  ); 
                        if ( monitor != IntPtr.Zero ) 
                        {
                            SafeNativeMethods.GetMonitorInfo( new HandleRef ( this, monitor ) , monitorInfo); 
                        }

                        return monitorInfo.rcWork;
 
                    }
                } 
 
                ///
                ///     Critical as this method accesses critical data. 
                ///     TreatAsSafe - window bounds by themselves is considered safe.
                ///
                internal NativeMethods.RECT WindowBounds
                { 
                   [SecurityCritical, SecurityTreatAsSafe ]
                    get 
                    { 
                        NativeMethods.RECT rc = new NativeMethods.RECT(0,0,0,0);
                        SafeNativeMethods.GetWindowRect(new HandleRef(this, CriticalHandle), ref rc); 

                        return rc;
                    }
                } 

 
                /// 
                ///     Critical as this method accesses critical data, _sourceWindow.CriticalHandle.
                /// 
                [SecurityCritical]
                private NativeMethods.POINT GetWindowScreenLocation(FlowDirection flowDirection)
                {
                    Debug.Assert(IsSourceWindowNull != true, "IsSourceWindowNull cannot be true here"); 
                    NativeMethods.POINT pt = new NativeMethods.POINT(0, 0);
                    if (flowDirection == FlowDirection.RightToLeft) 
                    { 
                        NativeMethods.RECT rc = new NativeMethods.RECT(0, 0, 0, 0);
 
                        // with RTL window, GetClientRect returns reversed coordinates
                        SafeNativeMethods.GetClientRect(new HandleRef(this, CriticalHandle), ref rc);

                        // note that we use rc.right here for the RTL case and client to screen that point 
                        pt = new NativeMethods.POINT(rc.right, rc.top);
                    } 
                    UnsafeNativeMethods.ClientToScreen(new HandleRef(this, _sourceWindow.CriticalHandle), pt); 

                    return pt; 
                }

                ///
                ///     Critical as this method accesses critical data. 
                ///     TreatAsSafe - as setting the auto-size behavior of the window is considered safe.
                /// 
                internal SizeToContent HwndSourceSizeToContent 
                {
                    [SecurityCritical, SecurityTreatAsSafe] 
                    get
                    {
                        return _sourceWindow.SizeToContent;
                    } 

                    [SecurityCritical, SecurityTreatAsSafe] 
                    set 
                    {
                        _sourceWindow.SizeToContent = value; 
                    }
                }

                /// 
                ///      Critical as this method accesses critical data.
                ///      NOT TREAT AS SAFE ! 
                /// 
                internal Visual RootVisual
                { 
                    [SecurityCritical]
                    set
                    {
                        _sourceWindow.RootVisual = value; 
                    }
                } 
 
                ///
                ///     Critical - as this method accesses critical data, _sourceWindow.CriticalHandle, 
                ///              - and calls UnsafeNativeMethod GetActiveWindow()
                ///     TreatAsSafe - the information we're returning ( this window is active) is deemed safe.
                ///
                internal bool IsActiveWindow 
                {
                    [ SecurityCritical, SecurityTreatAsSafe] 
                    get 
                    {
                        return (_sourceWindow.CriticalHandle == UnsafeNativeMethods.GetActiveWindow()); 
                    }
                }

                /// 
                ///         Critical as this accesses and hands out critical data.
                ///      * This is currently exposed for usage in the DRTs only. * 
                /// 
                internal HwndSource HwndSourceWindow
                { 
                    [SecurityCritical]
                    get
                    {
                        return _sourceWindow; 
                    }
                } 
 
                ///
                ///         Critical as this accesses and hands out critical data. 
                ///
                internal HwndTarget CompositionTarget
                {
                    [SecurityCritical] 
                    get
                    { 
                        if (_sourceWindow != null) 
                        {
                            HwndTarget compositionTarget = _sourceWindow.CompositionTarget; 
                            if (compositionTarget != null && compositionTarget.IsDisposed == false)
                            {
                                return compositionTarget;
                            } 
                        }
                        return null; 
                    } 
                }
 
                ///
                /// Return the relative window width and height.
                ///
                internal Size WindowSize 
                {
                    get 
                    { 
                        // Get the size of the avalon window and pass it to
                        // the base implementation. 

                        NativeMethods.RECT rc = WindowBounds;

                        return new Size(rc.right - rc.left, rc.bottom - rc.top); 
                    }
                } 
 
                ///
                /// Critical as this method calls a method that elevates - GetWindowLong 
                /// TreatAsSafe - this is information about the current window.
                ///                     this is safe as :
                ///                             it's innocous information.
                ///                             if you had permission to create the current window - you should be able to find out what you created it as. 
                ///                             for the browser case - you're not allowed to create the window. The actual styles you'd get would be fixed per OS release, you could guess them anyway.
                /// 
                internal int StyleExFromHwnd 
                {
                    [SecurityCritical, SecurityTreatAsSafe ] 
                    get
                    {
                        // Should never be called when Handle is non-null
                        Debug.Assert( IsSourceWindowNull == false , "Should only be invoked when we know Handle is non-null" ); 
                        return UnsafeNativeMethods.GetWindowLong(new HandleRef(this,CriticalHandle), NativeMethods.GWL_EXSTYLE);
                    } 
                } 

                /// 
                /// Critical as this method calls a method that elevates - GetWindowLong
                /// TreatAsSafe -this is information about the current window.
                ///                     this is safe as :
                ///                             it's innocous information. 
                ///                             if you had permission to create the current window - you should be able to find out what you created it as.
                ///                             for the browser case - you're not allowed to create the window. The actual styles you'd get would be fixed per OS release, you could guess them anyway. 
                /// 
                internal int StyleFromHwnd
                { 
                    [SecurityCritical, SecurityTreatAsSafe ]
                    get
                    {
                        // Should never be called when Handle is non-null 
                        Debug.Assert( IsSourceWindowNull == false , "Should only be invoked when we know Handle is non-null" );
                        return UnsafeNativeMethods.GetWindowLong(new HandleRef(this,CriticalHandle), NativeMethods.GWL_STYLE); 
                    } 
                }
 

                ///
                ///     Transform global coords of window location
                ///     to coords relative to top/left of the window. 
                ///
                /// 
                ///      Critical as this function accesses critical data (GetWindowScreenLocation). 
                ///      TreatAsSafe - as exposing the coords relative to the Window is considered safe.
                /// 
                [SecurityCritical, SecurityTreatAsSafe ]
                internal NativeMethods.POINT GetPointRelativeToWindow( int x, int y, FlowDirection flowDirection )
                {
                    NativeMethods.POINT ptWindow = GetWindowScreenLocation(flowDirection); 

                    // At this point ptWindow contains the location of the client area's top/left wrt 
                    // the screen 

                    return new NativeMethods.POINT( x - ptWindow.x, y - ptWindow.y ); 
                }

                /// 
                ///     Gets the size from the hwnd 
                /// 
                /// 
                /// Critical as this method accesses critical data. 
                /// TreatAsSafe - as this method returns the Window's current size. Considered safe.
                /// 
                [SecurityCritical, SecurityTreatAsSafe]
                internal Size GetSizeFromHwndInMeasureUnits()
                {
                    Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull can't be true here"); 

                    Point pt = new Point(0,0); 
                    NativeMethods.RECT rect = new NativeMethods.RECT(0,0,0,0); 
                    SafeNativeMethods.GetWindowRect(new HandleRef(null, CriticalHandle), ref rect);
                    pt.X = rect.right - rect.left; 
                    pt.Y = rect.bottom - rect.top;
                    pt = _sourceWindow.CompositionTarget.TransformFromDevice.Transform(pt);
                    return new Size(pt.X,pt.Y);
                } 

 
                ///  
                ///     Gets the frame size of the hwnd.
                ///     Note that we use the current Hwnd's style information. 
                ///     If you're in the middle of changing the window's _style or _styleEx and call this function,
                ///     you may get inconsistent results.
                /// 
                /// 
                ///     Critical as this method accesses critical data and performs an elevation
                ///     TreatAsSafe - as this method returns the Window's current non client area size. Considered safe. 
                /// 
                [ SecurityCritical, SecurityTreatAsSafe]
                internal Size GetHwndNonClientAreaSizeInMeasureUnits() 
                {
                    Point pt;
                    int style = StyleFromHwnd;
                    int styleEx = StyleExFromHwnd; 
                    Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull can't be true here");
 
                    // Find out the size of the window frame x. 
                    // use any reference size to calculate the frame size
                    NativeMethods.RECT referenceClientAreaRect = new NativeMethods.RECT(100,100,500,500); 
                    NativeMethods.RECT windowRect = new NativeMethods.RECT(referenceClientAreaRect.left,
                                                                           referenceClientAreaRect.top,
                                                                           referenceClientAreaRect.right,
                                                                           referenceClientAreaRect.bottom); 

                    SafeNativeMethods.AdjustWindowRectEx(ref windowRect, style, false, styleEx ); 
 
                    pt = new Point(
                        (windowRect.right - windowRect.left) - (referenceClientAreaRect.right - referenceClientAreaRect.left), 
                        (windowRect.bottom - windowRect.top) - (referenceClientAreaRect.bottom - referenceClientAreaRect.top));

                    pt = _sourceWindow.CompositionTarget.TransformFromDevice.Transform(pt);
                    return new Size(pt.X, pt.Y); 
                }
 
                /// 
                ///     Critical as this function accesses critical data.
                ///     TreatAsSafe - as this function eliminates the top visual of the window if there is one. Considered safe this is 
                ///                          equivalent to making the window have no content.
                ///
                [SecurityCritical, SecurityTreatAsSafe]
                internal void ClearRootVisual() 
                {
                    if ( _sourceWindow.RootVisual != null ) 
                    { 
                        _sourceWindow.RootVisual = null;
                    } 
                }

                ///
                ///     Critical as this function accesses critical data. 
                ///     THIS FUNCTION IS NOT TREAT AS SAFE !
                /// 
                [SecurityCritical] 
                internal void AddDisposedHandler( EventHandler theHandler )
                { 
                    if (_sourceWindow != null)
                    {
                        _sourceWindow.Disposed += theHandler;
                    } 
                }
 
                /// 
                ///     Critical as this function accesses critical data.
                ///     THIS FUNCTION IS NOT TREAT AS SAFE ! 
                ///
                [SecurityCritical]
                internal void RemoveDisposedHandler( EventHandler theHandler )
                { 
                    if (_sourceWindow != null)
                    { 
                        _sourceWindow.Disposed -= theHandler; 
                    }
                } 

                [SecurityCritical]
                private HwndSource _sourceWindow;
        } 

        internal class HwndStyleManager : IDisposable 
        { 
            static internal HwndStyleManager StartManaging(Window w, int Style, int StyleEx )
            { 
                if (w.Manager == null)
                {
                    return new HwndStyleManager(w, Style, StyleEx);
                } 
                else
                { 
                    w.Manager._refCount++; 
                    return w.Manager;
                } 
            }

            private HwndStyleManager(Window w, int Style, int StyleEx  )
            { 
                _window = w;
                _window.Manager = this; 
 
                if ( w.IsSourceWindowNull == false )
                { 
                    _window._Style    =  Style;
                    _window._StyleEx  = StyleEx;

                    // Dirty ==> _style and hwnd are out of [....]. Since we just got 
                    // the style from hwnd, it obviously is not Dirty.
                    Dirty = false; 
                } 
                _refCount = 1;
            } 

            void IDisposable.Dispose()
            {
                _refCount--; 

                // hamidm - 07/13/2005: WOSB 1178019 (A NullReferenceException occurs when animating 
                // the WindowStyle enum via a custom animation).  This bug contains details of 
                // why we were seeing the null ref.
                // 
                // Sometimes, the Flush call below results in sending certain window messages
                // and their handling leads to setting some property on the Window leading
                // to a call to HwndStyleManager.StartManaging.  Thus, we end up calling
                // dispose on that before we complete this run of the Dispose method.  This 
                // resulted in null ref in Flush.  To fix this bug, we do the following two things:
                // 
                // 1) Keep a local copy of HwndStyleManager in Flush to make it re-entrant 
                // 2) null out _window.Manager below only if _window.Manager is this instance
                //    of the Manager. 

                if (_refCount == 0)
                {
                    _window.Flush(); 

                    if (_window.Manager == this) 
                    { 
                        _window.Manager = null;
                    } 
                }
            }

            internal bool Dirty 
            {
                get { return _fDirty; } 
                set { _fDirty = value; } 
            }
 
            private Window          _window;
            private int             _refCount;
            private bool            _fDirty;
        } 
        #endregion PrivateClass
 
        #region Private Enums 
        private enum TransformType
        { 
            WorkAreaToScreenArea = 0,
            ScreenAreaToWorkArea = 1
        }
 
        private enum BoundsSpecified
        { 
            Height = 0, 
            Width = 1,
            Top = 2, 
            Left = 3
        }
        #endregion Private Enums
 
        #region DTypeThemeStyleKey
 
        // Returns the DependencyObjectType for the registered ThemeStyleKey's default 
        // value. Controls will override this method to return approriate types.
        internal override DependencyObjectType DTypeThemeStyleKey 
        {
            get { return _dType; }
        }
 
        private static DependencyObjectType _dType;
 
        #endregion DTypeThemeStyleKey 
    }
 


    #region Enums
 
    /// 
    /// WindowStyle 
    ///  
    public enum WindowStyle
    { 
        /// 
        /// no border at all  also implies no caption
        /// 
        None = 0,                                               // no border at all  also implies no caption 

        ///  
        /// SingleBorderWindow 
        /// 
        SingleBorderWindow = 1,                                    // WS_BORDER 

        /// 
        /// 3DBorderWindow
        ///  
        ThreeDBorderWindow = 2,                                    // WS_BORDER | WS_EX_CLIENTEDGE
 
        ///  
        /// FixedToolWindow
        ///  
        ToolWindow = 3,                                           // WS_BORDER | WS_EX_TOOLWINDOW

        // NOTE: if you add or remove any values in this enum, be sure to update Window.IsValidWindowStyle()
    } 

 
    ///  
    /// WindowState
    ///  
    public enum WindowState
    {
        /// 
        /// Default size 
        /// 
        Normal = 0, 
 
        /// 
        /// Minimized 
        /// 
        Minimized = 1,   // WS_MINIMIZE

        ///  
        /// Maximized
        ///  
        Maximized = 2   // WS_MAXIMIZE 

        // NOTE: if you add or remove any values in this enum, be sure to update Window.IsValidWindowState() 

#if THEATRE_FULLSCREEN
        // The following Two are not Implement yet
        ///  
        /// Theatre
        ///  
        Theatre = 3, 

        ///  
        /// FullScreen
        /// 
        FullScreen = 4
#endif //THEATRE_FULLSCREEN 
    }
 
    ///  
    ///
    ///  
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
    public enum WindowStartupLocation
    {
        ///  
        /// Uses the values specified by Left and Top properties to position the Window
        ///  
        Manual = 0, 

        ///  
        /// Centers the Window on the screen.  If there are more than one monitors, then
        /// the Window is centered on the monitor that has the mouse on it
        /// 
        CenterScreen = 1, 

        ///  
        /// Centers the Window on its owner.  If there is no owner window defined or if 
        /// it is not possible to center it on the owner, then defaults to Manual
        ///  
        CenterOwner = 2,

        // NOTE: if you add or remove any values in this enum, be sure to update Window.IsValidWindowStartupLocation()
    } 

    ///  
    ///     ResizeMode 
    /// 
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)] 
    public enum ResizeMode
    {
        /// 
        ///     User cannot resize the Window. Maximize and Minimize boxes 
        ///     do not show in the caption bar.
        ///  
        NoResize = 0, 

        ///  
        ///     User can only minimize the Window.  Minimize box is shown and enabled
        ///     in the caption bar while the Maximize box is disabled.
        /// 
        CanMinimize = 1, 

        ///  
        ///     User can fully resize the Window including minimize and maximize. 
        ///     Both Maximize and Minimize boxes are shown and enabled in the caption
        ///     bar. 
        /// 
        CanResize = 2,

        ///  
        ///     Same as CanResize and ResizeGrip will show
        ///  
        CanResizeWithGrip = 3 

        // NOTE: if you add or remove any values in this enum, be sure to update Window.IsValidResizeMode() 
    }
    #endregion Enums

    internal class SingleChildEnumerator : IEnumerator 
    {
        internal SingleChildEnumerator(object Child) 
        { 
            _child = Child;
            _count = Child == null ? 0 : 1; 
        }

        object IEnumerator.Current
        { 
            get { return (_index == 0) ? _child : null; }
        } 
 
        bool IEnumerator.MoveNext()
        { 
            _index++;
            return _index < _count;
        }
 
        void IEnumerator.Reset()
        { 
            _index = -1; 
        }
 
        private int _index = -1;
        private int _count = 0;
        private object _child;
    } 
}
 
 


// 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: Implements the base Avalon Window class 
// 
// History
//  06/12/02    MihaiI      Created 
//  06/12/03    hamidm      Added functionalities and moved to wcp tree
//
//---------------------------------------------------------------------------
using System; 
using System.Windows;
using System.Windows.Automation.Peers; 
using System.ComponentModel; 
using System.Windows.Threading;
using System.Windows.Media; 
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Markup;
using System.Windows.Input; 
using System.Windows.Documents;
using System.Windows.Interop; 
using System.Windows.Media.Imaging; 

using MS.Win32; 
using MS.Internal;
using MS.Internal.AppModel;
using MS.Internal.KnownBoxes;
using MS.Internal.PresentationFramework;                   // SecurityHelper 
using MS.Utility;
 
using System.Runtime.InteropServices; 
using System.Diagnostics;
using System.Security; 
using System.Security.Permissions;
using System.Collections;

//In order to avoid generating warnings about unknown message numbers and 
//unknown pragmas when compiling your C# source code with the actual C# compiler,
//you need to disable warnings 1634 and 1691. (Presharp Documentation) 
#pragma warning disable 1634, 1691 

namespace System.Windows 
{
    /// 
    ///
    ///  
    /// 
    /// Critical: In PartialTrust we want to not allow creation or inheritance of window 
    /// PublicOk: This has inheritance demand and constructor is blocked in partial trust 
    /// 
    [Localizability(LocalizationCategory.Ignore)] 
    [UIPermissionAttribute(SecurityAction.InheritanceDemand,Window=UIPermissionWindow.AllWindows)]
    public class Window: ContentControl, IWindowService
    {
        //--------------------------------------------------- 
        //
        // Constructors 
        // 
        //---------------------------------------------------
        #region Constructors 

        /// 
        ///     Initializes the dependency ids of this class
        ///  
        static Window()
        { 
            HeightProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnHeightChanged))); 
            MinHeightProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnMinHeightChanged)));
            MaxHeightProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnMaxHeightChanged))); 
            WidthProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnWidthChanged)));
            MinWidthProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnMinWidthChanged)));
            MaxWidthProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnMaxWidthChanged)));
 
            // override VisibilityProperty Metadata. For Window, Visibility.Visible means the Window is visible.
            // Visibility.Hidden and Visibility.Collapsed mean the Window is not visible. 
            // Visibility.Hidden and Visibility.Collapsed are treated the same. 
            // We default to Visibility.Collapsed since RenderSize returns (0,0) only for
            // collapsed elements and not for hidden. We want to return (0,0) when window is 
            // never shown.
            VisibilityProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(Visibility.Collapsed, new PropertyChangedCallback(_OnVisibilityChanged), new CoerceValueCallback(CoerceVisibility)));

            IsTabStopProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(BooleanBoxes.FalseBox)); 
            KeyboardNavigation.DirectionalNavigationProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(KeyboardNavigationMode.Cycle));
            KeyboardNavigation.TabNavigationProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(KeyboardNavigationMode.Cycle)); 
            KeyboardNavigation.ControlTabNavigationProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(KeyboardNavigationMode.Cycle)); 
            FocusManager.IsFocusScopeProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(BooleanBoxes.TrueBox));
 
            DefaultStyleKeyProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(typeof(Window)));
            _dType = DependencyObjectType.FromSystemTypeInternal(typeof(Window));

            FlowDirectionProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(new PropertyChangedCallback(_OnFlowDirectionChanged))); 
            //
 
            RenderTransformProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(Transform.Identity, new PropertyChangedCallback(_OnRenderTransformChanged), new CoerceValueCallback(CoerceRenderTransform))); 
            ClipToBoundsProperty.OverrideMetadata(typeof(Window), new FrameworkPropertyMetadata(BooleanBoxes.FalseBox, new PropertyChangedCallback(_OnClipToBoundsChanged), new CoerceValueCallback(CoerceClipToBounds)));
        } 

        /// 
        ///     Constructs a window object
        ///  
        /// 
        ///     Automatic determination of current Dispatcher. Use alternative constructor 
        ///     that accepts a Dispatcher for best performance. 
        ///
        ///     Initializes the Width/Height, Top/Left properties to use windows 
        ///     default. Updates Application object properties if inside app.
        ///
        ///     Also, window style is set to WS_CHILD inside CreateSourceWindow
        ///     for browser hosted case 
        ///
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        ///  
        /// 
        /// Critical: We explicitly demand all window permission currently Window creation is not available in Internet Zone. 
        ///     _ownerHandle and _dialogOwnerHandle fields are initialized when this .ctor gets called.
        /// PublicOK: The only scenarios where we're currently going to enable creation of Windows is with RootBrowserWindow.
        ///     This code has a demand.
        ///  
        [SecurityCritical]
        public Window() 
        { 
            SecurityHelper.DemandUnmanagedCode();
            _inTrustedSubWindow = false; 
            Initialize();
        }

        ///  
        ///     Constructs a window object
        ///  
        ///  
        ///     Automatic determination of current Dispatcher. Use alternative constructor
        ///     that accepts a Dispatcher for best performance. 
        ///
        ///     Initializes the Width/Height, Top/Left properties to use windows
        ///     default. Updates Application object properties if inside app.
        /// 
        ///     Also, window style is set to WS_CHILD inside CreateSourceWindow
        ///     for browser hosted case 
        /// 
        ///     This method currently requires full trust to run.
        ///  
        /// 
        /// Critical - The only scenarios where we're currently going to enable creation of Windows is with RootBrowserWindow.
        ///     Do not ever call it from anywhere else. This is only for RBW scenario!!!
        ///     _ownerHandle and _dialogOwnerHandle fields are initialized when this .ctor gets called. 
        /// 
        [SecurityCritical] 
        internal Window(bool inRbw):base() 
        {
            if (inRbw) 
            {
                _inTrustedSubWindow = true;
            }
            else 
            {
                _inTrustedSubWindow = false; 
                SecurityHelper.DemandUnmanagedCode(); 
            }
            Initialize(); 

        }
        #endregion Constructors
 
        //----------------------------------------------------
        // 
        // Public Methods 
        //
        //--------------------------------------------------- 
        #region Public Methods

        /// 
        ///     Show the window 
        /// 
        ///  
        ///     Calling Show on window is the same as setting the 
        ///     Visibility property to Visibility.Visible.
        ///  
        public void Show()
        {
            VerifyContextAndObjectState();
            VerifyCanShow(); 
            VerifyNotClosing();
            VerifyConsistencyWithAllowsTransparency(); 
 
            // Update the property value only.  Do not do anything further in
            // _OnVisibilityInvalidate since we will synchronously call ShowHelper 
            // from here.
            UpdateVisibilityProperty(Visibility.Visible);

            ShowHelper(BooleanBoxes.TrueBox); 
        }
 
        ///  
        ///     Hide the window
        ///  
        /// 
        ///     Calling Hide on window is the same as setting the
        ///     Visibility property to Visibility.Hidden
        ///      
        public void Hide()
        { 
            VerifyContextAndObjectState(); 

            if (_disposed == true) 
            {
                return;
            }
 
            // set Visibility to Hidden even if _isVisible is false since
            // _isVisible can be false b/c of Visibility = Collapsed and Hide() 
            // should change Visibility to Hidden. 
            //
            // Update the property value only.  Do not do anything further in 
            // _OnVisibilityInvalidate since we will synchronously call ShowHelper
            // from here.
            UpdateVisibilityProperty(Visibility.Hidden);
 
            ShowHelper(BooleanBoxes.FalseBox);
        } 
 
        /// 
        ///     Closes the Window 
        /// 
        /// 
        ///     Window fires the Closing event before it closes. If the
        ///     user cancels the closing event, the window is not closed. 
        ///     Otherwise, the window is closed and the Closed event is
        ///     fired. 
        /// 
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API.
        ///  
        ///
        ///  PublicOK: This API Demands UIPermission with AllWindows access
        ///  Critical: calls critical code (InternalClose)
        /// 
        [SecurityCritical ]
        public void Close() 
        { 
            // this call ends up throwing an exception if Close
            // is not allowed 
            VerifyApiSupported();
            SecurityHelper.DemandUIWindowPermission();
            VerifyContextAndObjectState();
            InternalClose(false, false); 
        }
 
        ///  
        ///     Kick off the Window's MoveWindow loop
        ///  
        /// 
        ///     To enable custom chrome on Windows. First check if this is the Left MouseButton.
        ///     Will throw exception if it's not, otherwise, will kick off the Windows's MoveWindow loop.
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        /// 
        /// 
        ///     Critical - as this code performs an elevation via the calls to SendMessage. 
        ///     PublicOk - as there is a demand for all windows permission.
        ///     We explicitly demand unamnaged code permission - as there's no valid scenario for this in the SEE. 
        ///
        [SecurityCritical]
        public void DragMove()
        { 

            // this call ends up throwing an exception if dragmove 
            // is not allowed 
            VerifyApiSupported();
            SecurityHelper.DemandUIWindowPermission(); 
            VerifyContextAndObjectState();

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            {
                return; 
            } 

            // Mouse.LeftButton actually reflects the primary button user is using. 
            // So we don't need to check whether the button has been swapped here.
            if (Mouse.LeftButton == MouseButtonState.Pressed)
            {
                if (WindowState == WindowState.Normal) 
                {
                    // SendMessage's return value is dependent on the message send.  WM_SYSCOMMAND 
                    // and WM_LBUTTONUP return value just signify whether the WndProc handled the 
                    // message or not, so they are not interesting
#pragma warning disable 6523 
                    UnsafeNativeMethods.SendMessage( CriticalHandle, NativeMethods.WM_SYSCOMMAND, (IntPtr)NativeMethods.SC_MOUSEMOVE, IntPtr.Zero);
                    UnsafeNativeMethods.SendMessage( CriticalHandle, NativeMethods.WM_LBUTTONUP, IntPtr.Zero, IntPtr.Zero);
#pragma warning restore 6523
                } 
            }
            else 
            { 
                throw new InvalidOperationException(SR.Get(SRID.DragMoveFail));
            } 

        }

        ///  
        ///     Shows the window as a modal window
        ///  
        /// bool? 
        /// 
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        /// 
        /// 
        /// Critical: This code causes unmamanged code elevation in the call to GetWindowLong
        ///           which has a SUC on it. There is also a call to SetFocus which returns a window handle. 
        ///           It also accesses _dialogOwnerHandle, _dialogPreviousActiveHandle and _ownerHandle.
        /// PublicOK: There is a demand in the code 
        ///  
        [SecurityCritical ]
        public Nullable ShowDialog() 
        {

            // this call ends up throwing an exception if dragmove
            // is not allowed 
            VerifyApiSupported();
            SecurityHelper.DemandUnrestrictedUIPermission(); 
            VerifyContextAndObjectState(); 
            VerifyCanShow();
            VerifyNotClosing(); 
            VerifyConsistencyWithAllowsTransparency();

            if ( _isVisible == true )
            { 
                throw new InvalidOperationException(SR.Get(SRID.ShowDialogOnVisible));
            } 
            else if ( _showingAsDialog == true ) 
            {
                throw new InvalidOperationException(SR.Get(SRID.ShowDialogOnModal)); 
            }

            _dialogOwnerHandle = _ownerHandle;
 
            // verify owner handle is window
            if (UnsafeNativeMethods.IsWindow( new HandleRef( null, _dialogOwnerHandle ) ) != true) 
            { 
                _dialogOwnerHandle = IntPtr.Zero;
            } 


            // remember the current active window;
            // this is used when dialog creation fails or dialog closes, we set the active window back to this one. 
            _dialogPreviousActiveHandle = UnsafeNativeMethods.GetActiveWindow();
 
            // if owner window is not specified, we get the current active window on this thread's 
            // message queue as the owner.
            if (_dialogOwnerHandle == IntPtr.Zero) 
            {
                _dialogOwnerHandle = _dialogPreviousActiveHandle;
            }
 
            // If hwndOwner == HWNDESKTOP, change it to NULL.  This way the desktop
            // (and all its children) won't be disabled if the dialog is modal. 
            if ((_dialogOwnerHandle != IntPtr.Zero) && 
                (_dialogOwnerHandle == UnsafeNativeMethods.GetDesktopWindow()))
            { 
                _dialogOwnerHandle = IntPtr.Zero;
            }

            // if dialog owner is not null, get the top level window (case where dialog owner is a 
            // child window), and save it's state regarding enabled and active window
            if (_dialogOwnerHandle != IntPtr.Zero) 
            { 
                // get the top level window from the dialog owner handle
                int style = 0; 

                while (_dialogOwnerHandle != IntPtr.Zero)
                {
                    style = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, _dialogOwnerHandle), NativeMethods.GWL_STYLE); 
                    if ((style & NativeMethods.WS_CHILD) == NativeMethods.WS_CHILD)
                    { 
                        _dialogOwnerHandle = UnsafeNativeMethods.GetParent(new HandleRef(null, _dialogOwnerHandle)); 
                    }
                    else 
                    {
                        break;
                    }
                } 
            }
 
            Debug.Assert(_threadWindowHandles == null, "_threadWindowHandles must be null before enumerating the thread windows"); 

            // NOTE: hamidm -- 01/22/04 
            // _threadWindowHandles is created here.  This reference is nulled out in EnableThreadWindows
            // when it is called with a true parameter.  Please do not null it out anywhere else.
            // EnableThreadWindow(true) is called when dialog is going away.  Once dialog is closed and
            // thread windows have been enabled, then there no need to keep the array list around. 
            // Please see
            _threadWindowHandles = new ArrayList(); 
            //Get visible and enabled windows in the thread 
            // If the callback function returns true for all windows in the thread, the return value is true.
            // If the callback function returns false on any enumerated window, or if there are no windows 
            // found in the thread, the return value is false.
            // No need for use to actually check the return value.
#pragma warning disable 6523
            UnsafeNativeMethods.EnumThreadWindows(SafeNativeMethods.GetCurrentThreadId(), 
                                                  new NativeMethods.EnumThreadWindowsCallback(ThreadWindowsCallback),
                                                  NativeMethods.NullHandleRef); 
#pragma warning enable 6523 
            //disable those windows
            EnableThreadWindows(false); 

            IntPtr hWndCapture = SafeNativeMethods.GetCapture();
            if (hWndCapture != IntPtr.Zero)
            { 
                //
                // NOTE: hamidm -- 7/14/04 
                // EnableWindow(false) (called from EnableThreadWindows(false) 
                // sends WM_CANCELMODE to the window, so we don't need
                // to send it again.  However, if we change our impl 
                // of dialog such that we don't disable all windows on the
                // thread, then we would need this call. Keeping this code here
                // until we finish the Dialog task # 18498
 
                // UnsafeNativeMethods.SendMessage(hWndCapture,
                //                                NativeMethods.WM_CANCELMODE, 
                //                                IntPtr.Zero, 
                //                                IntPtr.Zero);
 
                // hWndCapture = UnsafeNativeMethods.GetCapture();
                // if (hWndCapture != IntPtr.Zero)
                // {
                    // PS # 862892 
                    // WCP: Investigate whether ReleaseCapture is needed in ShowDialog
                    SafeNativeMethods.ReleaseCapture(); 
                // } 
            }
 
            // Ensure Dialog RoutedCommand is registered with CommandManager
            EnsureDialogCommand();

            try 
            {
                _showingAsDialog = true; 
                Show(); 
            }
            catch 
            {
                // NOTE: hamidm 01/22/04
                // See
 

 
 

 



 

 
 

 



 

 
 

                if (_threadWindowHandles != null) 
                {
                    // Some exception case. Re-enable the windows that were disabled
                    EnableThreadWindows(true);
                } 

                // Activate the previously active window. 
                // This code/logic came from User. 
                if ( (_dialogPreviousActiveHandle != IntPtr.Zero) &&
                    (UnsafeNativeMethods.IsWindow(new HandleRef(null, _dialogPreviousActiveHandle)) == true)) 
                {
                    // SetFocus fails if the input hwnd is not a Window or if the Window is not on the
                    // calling thread.
                    // 
                    // Furthermore, this code path is executed when an exception occurs when we try to
                    // show the window.  Here we are doing the minimum possible to restore state of 
                    // the avalon window object.  Hence, if for some reason, we are not able to 
                    // SetFocus to the window that previously had focus, we don't care as that failure
                    // is not important enought to warrant throwing an exception. 
                    UnsafeNativeMethods.TrySetFocus(new HandleRef(null, _dialogPreviousActiveHandle), ref _dialogPreviousActiveHandle);
                }

                // clears _showingAsDialog and accelerators related fields 
                ClearShowKeyboardCueState();
                _showingAsDialog = false; 
 
                // using catch and throw instead of catch(Exception e) throw e;  since the former
                // gives the complete call stack upto the offending method where the exception is thrown 
                throw;
            }
            finally
            { 
                // If the owner window belongs to another thread, the reactivation
                // of the owner may have failed within DestroyWindow().  Therefore, 
                // if the current thread is in the foreground and the owner is not 
                // in the foreground we can safely set the foreground back
                // to the owner. 
#if FIGURE_OUT
                TODO: hamidm  7/18/2003
                PS: 862826
                // WCP Dialog: Figure out what to do when reactivating the owner window 
                // which is in another thread.
                if (_dialogOwnerHandle != IntPtr.Zero) 
                { 
                    if (IsCurrentThreadForeground() &&
                        !IsInForegroundQueue(hwndOwner)) 
                    {
                        NtUserSetForegroundWindow(hwndOwner);
                    }
                } 
#endif //FIGURE_OUT
                _showingAsDialog = false; 
            } 
            return _dialogResult;
        } 


        /// 
        ///     This method tries to activate the Window. 
        /// 
        ///  
        ///     This method calls SetForegroundWindow on the hWnd, thus the rules for SetForegroundWindow 
        ///     apply to this method.
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        /// 
        /// bool -- indicating whether the window was activated or not
        ///
        ///     Critical as this code performs an elevation in the call to SetForegroundWindow. 
        ///     PublicOk - there is a demand in the code. Any caller will require
        ///                     all window code permissions. 
        /// 
        [SecurityCritical]
        public bool Activate() 
        {

            // this call ends up throwing an exception if Activate
            // is not allowed 
            VerifyApiSupported();
            // 
            // Demand AllWindows code permission. 
            // There be a more appropriate less-restrictive permission - but this should suffice for now.
            // 
            SecurityHelper.DemandUIWindowPermission();
            VerifyContextAndObjectState();

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            { 
                return false; 
            }
 
            return UnsafeNativeMethods.SetForegroundWindow(new HandleRef(null, CriticalHandle));
        }
        #region LogicalTree
        ///  
        ///     Returns enumerator to logical children
        ///  
        protected internal override IEnumerator LogicalChildren 
        {
            get 
            {
                // Don't use UIElementCollection because we don't have a reference to content's visual parent;
                // window has style and user can change it.
                return new SingleChildEnumerator(this.Content); 
            }
        } 
 
        #endregion LogicalTree
 
        #region static public method

        /// 
        /// Gets Window in which the given DependecyObject is hosted in. 
        /// 
        /// Returns the Window the given dependencyObject is hosted in. 
        /// Window 
        public static Window GetWindow(DependencyObject dependencyObject)
        { 
            if (dependencyObject == null)
            {
                throw new ArgumentNullException("dependencyObject");
            } 

            // Window.IWindowServiceProperty is an internal inheritable dependency property 
            // Normally this value is set to the root Window element, all the element 
            // inside the window view will get this value through property inheritance mechanism.
 
            return dependencyObject.GetValue(Window.IWindowServiceProperty) as Window;
        }

        #endregion static public method 

        #endregion Public Methods 
        //---------------------------------------------------- 
        //
        // Public Properties 
        //
        //----------------------------------------------------
        #region Public Properties
 
        /// 
        /// DependencyProperty for AllowsTransparency 
        ///  
        public static readonly DependencyProperty AllowsTransparencyProperty =
                DependencyProperty.Register( 
                        "AllowsTransparency",
                        typeof(bool),
                        typeof(Window),
                        new FrameworkPropertyMetadata( 
                                BooleanBoxes.FalseBox,
                                new PropertyChangedCallback(OnAllowsTransparencyChanged), 
                                new CoerceValueCallback(CoerceAllowsTransparency))); 

        ///  
        /// Whether or not the Window uses per-pixel opacity
        /// 
        public bool AllowsTransparency
        { 
            get { return (bool)GetValue(AllowsTransparencyProperty); }
            set { SetValue(AllowsTransparencyProperty, BooleanBoxes.Box(value)); } 
        } 

        private static void OnAllowsTransparencyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
        }

        private static object CoerceAllowsTransparency(DependencyObject d, object value) 
        {
            value = VerifyAccessCoercion(d, value); 
 
            if (!((Window) d).IsSourceWindowNull)
            { 
                throw new InvalidOperationException(SR.Get(SRID.ChangeNotAllowedAfterShow));
            }

            return value; 
        }
 
        ///  
        ///     The DependencyProperty for TitleProperty.
        ///     Flags:              None 
        ///     Default Value:      String.Empty
        /// 
        public static readonly DependencyProperty TitleProperty =
                DependencyProperty.Register("Title", typeof(String), typeof(Window), 
                        new FrameworkPropertyMetadata(String.Empty,
                                new PropertyChangedCallback(_OnTitleChanged)), 
                        new ValidateValueCallback(_ValidateText)); 
        /// 
        ///     The data that will be displayed as the title of the window. 
        ///     Hosts are free to display the title in any manner that they
        ///     want.  For example, the browser may display the title set via
        ///     the Title property somewhere besides the caption bar
        ///  
        [Localizability(LocalizationCategory.Title)]
        public string Title 
        { 
            get
            { 
                VerifyContextAndObjectState();

                return (String)GetValue(TitleProperty);
            } 
            set
            { 
                VerifyContextAndObjectState(); 

                SetValue(TitleProperty, value); 
            }
        }

        ///  
        ///     The DependencyProperty for Icon
        ///     Flags:              None 
        ///     Default Value:      None 
        /// 
        public static readonly DependencyProperty IconProperty = 
                DependencyProperty.Register(
                        "Icon",
                        typeof(ImageSource),
                        typeof(Window), 
                        new FrameworkPropertyMetadata(
                                new PropertyChangedCallback(_OnIconChanged), 
                                new CoerceValueCallback(VerifyAccessCoercion))); 

        ///  
        ///     Sets the Icon of the Window
        /// 
        /// 
        ///     Following is the precedence for displaying the icon: 
        ///
        ///     1) Use ImageSource provided by the Icon property.  If Icon property is 
        ///     null, see 2 below. 
        ///     2) If Icon Property is not set, then use the Application icon
        ///     embedded in the exe.  Querying Icon property returns null. 
        ///     3) If no icon is embedded in the exe, then we set IntPtr.Zero
        ///     as the icon and Win32 displays its default icon.  Querying Icon
        ///     property returns null.
        /// 
        ///     If Icon property is set, Window does not dispose that object when it
        ///     is closed. 
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        /// 
        ///  
        ///     Critical: This code causes icon value to be set. This in turn causes property invalidation
        ///               which will access unsafe native methods.
        ///     PublicOK: There exists a demand , safe to expose
        ///  
        public ImageSource Icon
        { 
            get 
            {
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing
                // Icon is not allowed
                VerifyApiSupported(); 

                return (ImageSource) GetValue(IconProperty); 
            } 

            [SecurityCritical] 
            set
            {
                // this call ends up throwing an exception if accessing
                // Icon is not allowed 
                VerifyApiSupported();
                SecurityHelper.DemandUIWindowPermission(); 
                VerifyContextAndObjectState(); 

                SetValue(IconProperty, value); 
            }
        }

        ///  
        ///     The DependencyProperty for SizeToContentProperty.
        ///     Flags:              None 
        ///     Default Value:      "SizeToContent.Manual" 
        /// 
        public static readonly DependencyProperty SizeToContentProperty = 
                DependencyProperty.Register("SizeToContent",
                        typeof(SizeToContent),
                        typeof(Window),
                        new FrameworkPropertyMetadata( 
                                SizeToContent.Manual,
                                new PropertyChangedCallback(_OnSizeToContentChanged)), 
                        new ValidateValueCallback(_ValidateSizeToContentCallback)); 

        ///  
        /// Auto size Window to its content's size
        /// 
        /// 
        /// 1. SizeToContent can be applied to Width Height independently 
        /// 2. After SizeToContent is set, setting Width/Height does not take affect if that
        ///    dimension is sizing to content. 
        /// 3. SizeToContent is turned off (restored to SizeToContent.Manual) if user starts to 
        ///    interact with window in terms of size
        ///  
        /// 
        /// Default value is SizeToContent.Manual
        /// 
        public SizeToContent SizeToContent 
        {
            get 
            { 
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // SizeToContent is not allowed
                VerifyApiSupported();
 
                return (SizeToContent) GetValue(SizeToContentProperty);
            } 
            set 
            {
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing
                // SizeToContent is not allowed
                VerifyApiSupported(); 

                SetValue(SizeToContentProperty, value); 
            } 
        }
 
        /// 
        /// DependencyProperty for  property.
        /// 
 
        public static readonly DependencyProperty TopProperty =
                Canvas.TopProperty.AddOwner(typeof(Window), 
                        new FrameworkPropertyMetadata( 
                                Double.NaN,
                                new PropertyChangedCallback(_OnTopChanged), 
                                new CoerceValueCallback(CoerceTop)));

        /// 
        ///     Position for Top of the host window 
        /// 
        ///  
        ///     The following values are valid: 
        ///     Positive Doubles: sets the top location to the specified value
        ///     NaN: indicates to use the system default value. This 
        ///     is the default for Top property
        ///     PositiveInfinity, NegativeInfinity: These are invalid inputs.
        /// 
        ///  
        [TypeConverter("System.Windows.LengthConverter, PresentationFramework, Version=" + Microsoft.Internal.BuildInfo.WCP_VERSION + ", Culture=neutral, PublicKeyToken=" + Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_TOKEN + ", Custom=null")]
        public double Top 
        { 
            get
            { 
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing Top
                // is not allowed 
                VerifyApiSupported();
                return (double)GetValue(TopProperty); 
            } 
            set
            { 
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing Top
                // is not allowed 
                VerifyApiSupported();
 
                // we don't do an if check here to see if the new value is the same 
                // as the current Top value b/c the current value maybe as a result
                // of user resizing which means the the local value of Top has not 
                // been written to.  So, if window.Top is explicitly set now we want
                // to write to the local value.  We do make this if check in Top
                // property invalidation callback for optimization
                SetValue(TopProperty, value); 
            }
        } 
 
        /// 
        /// DependencyProperty for  property. 
        /// 
        public static readonly DependencyProperty LeftProperty =
                Canvas.LeftProperty.AddOwner(typeof(Window),
                        new FrameworkPropertyMetadata( 
                                Double.NaN,
                                new PropertyChangedCallback(_OnLeftChanged), 
                                new CoerceValueCallback(CoerceLeft))); 

        ///  
        ///     Position for Left edge of  coordinate of the host window
        /// 
        /// 
        ///     The following values are valid: 
        ///     Positive Doubles: sets the top location to the specified value
        ///     NaN: indicates to use the system default value. This 
        ///     is the default for Top property 
        ///     PositiveInfinity, NegativeInfinity: These are invalid inputs.
        ///  
        /// 
        [TypeConverter("System.Windows.LengthConverter, PresentationFramework, Version=" + Microsoft.Internal.BuildInfo.WCP_VERSION + ", Culture=neutral, PublicKeyToken=" + Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_TOKEN + ", Custom=null")]
        public double Left
        { 
            get
            { 
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing left 
                // is not allowed
                VerifyApiSupported();
                return (double)GetValue(LeftProperty);
            } 
            set
            { 
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing left 
                // is not allowed
                VerifyApiSupported();

                // we don't do an if check here to see if the new value is the same 
                // as the current Left value b/c the current value maybe as a result
                // of user resizing which means the the local value of Left has not 
                // been written to.  So, if window.Left is explicitly set now we want 
                // to write to the local value.  We do make this if check in Left
                // property invalidation callback for optimization 
                SetValue(LeftProperty, value);
            }
        }
 
        /// 
        ///     This property returns the restoring rectangle of the window.  This information 
        ///     can be used to track a users size and position preferences when the 
        ///     Window is maximized or minimized.
        /// 
        ///     If RestoreBounds is queried before the Window has been shown or after it has
        ///     been closed, it will return Rect.Empty.
        /// 
        ///  
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API.
        ///  
        ///  
        ///     Critical: This code accesses Handle and calls critical method GetNormalRectLogicalUnits
        ///     PublicOK: This code only works under RBW code path , this operation is ok since 
        ///     RBW window is bound to the restrictions of its parent window which is the browser
        /// 

        public Rect RestoreBounds 
        {
            [SecurityCritical ] 
            get 
            {
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing RestoreBounds
                // is not allowed
                VerifyApiSupported(); 

                if (!_inTrustedSubWindow) 
                { 
                    SecurityHelper.DemandUIWindowPermission();
                } 

                // either before calling show or after closing AND
                // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
                if (IsSourceWindowNull || IsCompositionTargetInvalid) 
                {
                    return Rect.Empty; 
                } 

                return GetNormalRectLogicalUnits(CriticalHandle); 
            }
        }

        ///  
        ///     This enum can have following values
        ///         Manual (default) 
        ///         CenterScreen 
        ///         CenterOwner
        /// 
        ///     If the WindowStartupLocation is WindowStartupLocation.Manual then
        ///     Top and Left properites are used to position the window.
        ///     This property is used only before window creation. Once the window is
        ///     created hiding it and showing it will not take this property into account. 
        /// 
        ///  
        ///     WindowStartupLocation is used to position the window only it it is set to 
        ///     WindowStartupLocation.CenterScreen or WindowStartupLocation.CenterOwner,
        ///     otherwise Top/Left is used.  Furthermore, if determining the location 
        ///     of the window is not possible when WindowStartupLocation is set to
        ///     WindowStartupLocation.CenterScreen or WindowStartupLocation.Owner, then
        ///     Top/Left is used instead.
        ///  
        [DefaultValue(WindowStartupLocation.Manual)]
        public WindowStartupLocation WindowStartupLocation 
        { 
            get
            { 
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing
                // WindowStartupLocation is not allowed 
                VerifyApiSupported();
 
                return _windowStartupLocation; 
            }
 
            set
            {
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // WindowStartupLocation is not allowed 
                VerifyApiSupported(); 

                //validate WindowStartupLocation enum 
                if (!IsValidWindowStartupLocation(value))
                {
                    throw new InvalidEnumArgumentException("value", (int)value, typeof( WindowStartupLocation ));
                } 
                _windowStartupLocation = value;
            } 
        } 

        ///  
        ///     The DependencyProperty for ShowInTaskbarProperty.
        ///     Flags:              None
        ///     Default Value:      true
        ///  
        public static readonly DependencyProperty ShowInTaskbarProperty =
                DependencyProperty.Register("ShowInTaskbar", 
                        typeof(bool), 
                        typeof(Window),
                        new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, 
                                new PropertyChangedCallback(_OnShowInTaskbarChanged),
                                new CoerceValueCallback(VerifyAccessCoercion)));

        /// 
        ///     Determines if the window should show up in the system taskbar.
        ///     This also determines if the window appears in the Alt-Tab list. 
        /// 
        public bool ShowInTaskbar
        { 
            get
            {
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // ShowInTaskbar is not allowed 
                VerifyApiSupported(); 

                return (bool) GetValue(ShowInTaskbarProperty); 
            }
            set
            {
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing 
                // ShowInTaskbar is not allowed 
                VerifyApiSupported();
 
                SetValue(ShowInTaskbarProperty, BooleanBoxes.Box(value));
            }
        }
 
        /// 
        ///     The key needed set a read-only property. 
        ///  
        private static readonly DependencyPropertyKey IsActivePropertyKey
            = DependencyProperty.RegisterReadOnly("IsActive", typeof(bool), typeof(Window), 
                                          new FrameworkPropertyMetadata(BooleanBoxes.FalseBox));

        /// 
        ///     The DependencyProperty for IsActive. 
        ///     Flags:              None
        ///     Default Value:      True 
        ///     Read-Only:          true 
        /// 
        public static readonly DependencyProperty IsActiveProperty 
            = IsActivePropertyKey.DependencyProperty;

        /// 
        /// IsActive property. It indicates whether the Window is active. 
        /// The title bar will have the active theme. The active window will be
        /// the topmost of all top-level windows that don't explicitly set the TopMost property or style. 
        /// If a window is active, focus is within the window. 
        /// 
        public bool IsActive 
        {
            get
            {
                VerifyContextAndObjectState(); 
                return (bool)GetValue(IsActiveProperty);
            } 
        } 

        ///  
        ///     This set the owner for the property of the current window.
        ///     If the window has owner and the owner is minimized then
        ///     owned window is also minimized. Owner window can never be
        ///     over owned window. Owned window is NOT modal. So user can 
        ///     still interact with owner window. This property can not be
        ///     set of the top level window. 
        ///  
        ///
        ///     Callers must have UIPermission(UIPermissionWindow.AllWindows) to call this API. 
        ///
        ///
        /// Critical - _ownerWindow is accessed, SetParentHandle is called.
        /// PublicOK - get/set protected by Demand's. 
        ///
        [DefaultValue(null)] 
        public Window Owner 
        {
            [SecurityCritical ] 
            get
            {
                // this call ends up throwing an exception if accessing Owner
                // is not allowed 
                VerifyApiSupported();
                SecurityHelper.DemandUIWindowPermission(); 
                VerifyContextAndObjectState(); 
                return _ownerWindow;
            } 
            [SecurityCritical]
            set
            {
                // this call ends up throwing an exception if accessing Owner 
                // is not allowed
                VerifyApiSupported(); 
                SecurityHelper.DemandUIWindowPermission(); 
                VerifyContextAndObjectState();
                if (value == this) 
                {
                    throw new ArgumentException(SR.Get(SRID.CannotSetOwnerToItself));
                }
 
                if ( _showingAsDialog == true )
                { 
                    throw new InvalidOperationException(SR.Get(SRID.CantSetOwnerAfterDialogIsShown)); 
                }
 
                if (value != null && value.IsSourceWindowNull == true)
                {
                    throw new InvalidOperationException(SR.Get(SRID.CantSetOwnerWhosHwndIsNotCreated));
                } 

                if ( _ownerWindow == value ) 
                { 
                    return;
                } 

                // Check to see if value is already a child of this window.
                // If yes, throw Exception
 
                if (value != null)
                { 
                    WindowCollection ownedWindows = OwnedWindows; 
                    for (int i = 0; i < ownedWindows.Count; i++)
                    { 
                        if (ownedWindows[i] == value)
                        {
                            throw new ArgumentException(SR.Get(SRID.CircularOwnerChild, value, this));
                        } 
                    }
                } 
 
                // Update OwnerWindows of the previous owner
                if (_ownerWindow != null) 
                {
                    // using OwnedWindowsInternl b/c we want to modifying the
                    // underlying collection
                    _ownerWindow.OwnedWindowsInternal.Remove(this); 
                }
 
 
                // Update parent handle. If value is null, then make parent
                // handle IntPtr.Zero 
                _ownerWindow = value;
                SetParentHandle(_ownerWindow != null ? _ownerWindow.CriticalHandle: IntPtr.Zero);

                // Update OwnerWindows of the new owner 
                if (_ownerWindow != null)
                { 
                    // using OwnedWindowsInternl b/c we want to modifying the 
                    // underlying collection
                    _ownerWindow.OwnedWindowsInternal.Add(this); 
                }
            }
        }
 
        /// This code checks to see if the owner property is null
        /// True if the window is null , false other wise 
        ///  
        ///     Critical: This code is critical since it acceses owner which is critical data
        ///     TreatAsSafe: Since this exposes no critical data 
        /// 
        private bool IsOwnerNull
        {
            [SecurityCritical,SecurityTreatAsSafe] 
            get
            { 
                return (_ownerWindow == null); 
            }
 
        }
        /// 
        ///     This is a collection of windows that are owned by current window.
        ///  
        // This collection is a copy of the original one to avoid synchronizing issues.
        // DO-NOT USE THIS PROPERY IF YOU MEAN TO MODIFY THE UNDERLYING COLLECTION.  USE 
        // OwnedWindowsInternal PROPERTY FOR MODIFYING THE UNDERLYING DATASTRUCTURE. 
        public WindowCollection OwnedWindows
        { 
            get
            {
                VerifyContextAndObjectState();
                return OwnedWindowsInternal.Clone(); 
            }
        } 
 
        /// 
        /// Sets/gets DialogResult 
        /// 
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), TypeConverter(typeof(DialogResultConverter))]
        public Nullable DialogResult
        { 
            get
            { 
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing 
                // DialogResult is not allowed
                VerifyApiSupported();

                return _dialogResult; 
            }
            set 
            { 
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // DialogResult is not allowed
                VerifyApiSupported();
 
                if (_showingAsDialog == true)
                { 
                    // This value should be set only after the window is created and shown as dialog. 

                    // When _showingAsDialog is set, _sourceWindow must be set too. 
                    Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull cannot be true when _showingAsDialog is true");

                    // 03/03/2006 -- hamidm
                    // Fix for 1388606 Close Dialog Window should not return null 
                    //
                    // According to the new design, setting DialogResult to its current value will not have any effect. 
                    if (_dialogResult != value) 
                    {
                        _dialogResult = value; 

                        // if DialogResult is set from within a Closing event then
                        // the window is in the closing state.  Thus, if we call
                        // Close() again from here we go into an infinite loop. 
                        //
                        // Note: Windows OS bug # 934500 Setting DialogResult 
                        // on the Closing EventHandler of a Dialog causes StackOverFlowException 

                        if(_isClosing == false) 
                        {
                            Close();
                        }
                    } 
                }
                else 
                { 
                    throw new InvalidOperationException(SR.Get(SRID.DialogResultMustBeSetAfterShowDialog));
 
                }
            }
        }
 
        /// 
        ///     The DependencyProperty for WindowStyleProperty. 
        ///     Flags:              None 
        ///     Default Value:      WindowStyle.SingleBorderWindow
        ///  
        public static readonly DependencyProperty WindowStyleProperty =
                DependencyProperty.Register("WindowStyle", typeof(WindowStyle), typeof(Window),
                        new FrameworkPropertyMetadata(
                                WindowStyle.SingleBorderWindow, 
                                new PropertyChangedCallback(_OnWindowStyleChanged),
                                new CoerceValueCallback(CoerceWindowStyle)), 
                        new ValidateValueCallback(_ValidateWindowStyleCallback)); 

        ///  
        ///     Defines the visual style of the window (3DBorderWindow,
        ///     SingleBorderWindow, ToolWindow, none).
        /// 
        ///  
        ///     Default will be SingleBorderWindow.
        ///  
        public WindowStyle WindowStyle 
        {
            get 
            {
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing 
                // WindowStyle is not allowed
                VerifyApiSupported(); 
 
                return (WindowStyle) GetValue(WindowStyleProperty);
            } 
            set
            {
                VerifyContextAndObjectState();
                // this call ends up throwing an exception if accessing 
                // WindowStyle is not allowed
                VerifyApiSupported(); 
 
                SetValue(WindowStyleProperty, value);
            } 
        }

        private static object CoerceWindowStyle(DependencyObject d, object value)
        { 
            value = VerifyAccessCoercion(d, value);
 
            if (!((Window)d).IsSourceWindowNull) 
            {
                ((Window)d).VerifyConsistencyWithAllowsTransparency(); 
            }

            return value;
        } 

        ///  
        ///     The DependencyProperty for WindowStateProperty. 
        ///     Flags:              None
        ///     Default Value:      WindowState.Normal 
        /// 
        public static readonly DependencyProperty WindowStateProperty =
                DependencyProperty.Register("WindowState", typeof(WindowState), typeof(Window),
                        new FrameworkPropertyMetadata( 
                                WindowState.Normal,
                                FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, 
                                new PropertyChangedCallback(_OnWindowStateChanged), 
                                new CoerceValueCallback(VerifyAccessCoercion)),
                        new ValidateValueCallback(_ValidateWindowStateCallback)); 

        /// 
        ///     Current state of the window.  Valid options are Maximized, Minimized,
        ///     or Normal.  The host window may choose to ignore a request to change 
        ///     the current window state.
        ///  
        public WindowState WindowState 
        {
            get 
            {
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing 
                // WindowState is not allowed
                VerifyApiSupported(); 
 
                return (WindowState) GetValue(WindowStateProperty);
            } 
            set
            {
                VerifyContextAndObjectState();
                // this call ends up throwing an exception if accessing 
                // WindowState is not allowed
                VerifyApiSupported(); 
 
                SetValue(WindowStateProperty, value);
            } 
        }

        /// 
        ///     The DependencyProperty for the ResizeMode property. 
        ///     Flags:                  AffectsMeasure
        ///     Default Value:      false 
        ///  
        public static readonly DependencyProperty ResizeModeProperty =
                DependencyProperty.Register("ResizeMode", typeof(ResizeMode), typeof(Window), 
                        new FrameworkPropertyMetadata(ResizeMode.CanResize,
                                FrameworkPropertyMetadataOptions.AffectsMeasure,
                                new PropertyChangedCallback(_OnResizeModeChanged),
                                new CoerceValueCallback(VerifyAccessCoercion)), 
                        new ValidateValueCallback(_ValidateResizeModeCallback));
 
        ///  
        ///     Current state of the window.  Valid options are Maximized, Minimized,
        ///     or Normal.  The host window may choose to ignore a request to change 
        ///     the current window state.
        /// 
        public ResizeMode ResizeMode
        { 
            get
            { 
                VerifyContextAndObjectState(); 

                // this call ends up throwing an exception if accessing 
                // ResizeMode is not allowed
                VerifyApiSupported();

                return ((ResizeMode) GetValue(ResizeModeProperty)); 
            }
            set 
            { 
                VerifyContextAndObjectState();
                // this call ends up throwing an exception if accessing 
                // ResizeMode is not allowed
                VerifyApiSupported();

                SetValue(ResizeModeProperty, value); 
            }
        } 
 
        /// 
        ///     The DependencyProperty for TopmostProperty. 
        ///     Flags:              None
        ///     Default Value:      false
        /// 
        public static readonly DependencyProperty TopmostProperty = 
                DependencyProperty.Register("Topmost",
                        typeof(bool), 
                        typeof(Window), 
                        new FrameworkPropertyMetadata(BooleanBoxes.FalseBox,
                                new PropertyChangedCallback(_OnTopmostChanged), 
                                new CoerceValueCallback(VerifyAccessCoercion)));

        /// 
        ///     Determines if this window is always on the top. 
        /// 
        public bool Topmost 
        { 
            get
            { 
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing
                // Topmost is not allowed 
                VerifyApiSupported();
 
                return (bool) GetValue(TopmostProperty); 
            }
            set 
            {
                VerifyContextAndObjectState();
                // this call ends up throwing an exception if accessing
                // Topmost is not allowed 
                VerifyApiSupported();
 
                SetValue(TopmostProperty, BooleanBoxes.Box(value)); 
            }
        } 

        public static readonly DependencyProperty ShowActivatedProperty =
                DependencyProperty.Register("ShowActivated",
                        typeof(bool), 
                        typeof(Window),
                        new FrameworkPropertyMetadata(BooleanBoxes.TrueBox, 
                                null, 
                                new CoerceValueCallback(VerifyAccessCoercion)));
 
        /// 
        ///     Determines if this window is activated when shown (default = true).
        /// 
        ///  
        ///     Not supported for RBW.
        ///  
        public bool ShowActivated 
        {
            get 
            {
                VerifyContextAndObjectState();

                // this call ends up throwing an exception if accessing 
                // ShowActivated is not allowed
                VerifyApiSupported(); 
 
                return (bool)GetValue(ShowActivatedProperty);
            } 
            set
            {
                VerifyContextAndObjectState();
 
                // this call ends up throwing an exception if accessing
                // ShowActivated is not allowed 
                VerifyApiSupported(); 

                SetValue(ShowActivatedProperty, BooleanBoxes.Box(value)); 
            }
        }

        #endregion Public Properties 

        //--------------------------------------------------- 
        // 
        // Public Events
        // 
        //----------------------------------------------------
        #region Public Events

        ///  
        ///     This event is raised after the window source is created before it is shown
        ///  
        public event EventHandler SourceInitialized 
        {
            add { Events.AddHandler(EVENT_SOURCEINITIALIZED, value); } 
            remove { Events.RemoveHandler(EVENT_SOURCEINITIALIZED, value); }
        }

        ///  
        ///     This event is raised when the window is activated
        ///  
        public event EventHandler Activated 
        {
            add { Events.AddHandler(EVENT_ACTIVATED, value); } 
            remove { Events.RemoveHandler(EVENT_ACTIVATED, value); }
        }

        ///  
        ///     This event is raised when the window is deactivated
        ///  
        public event EventHandler Deactivated 
        {
            add { Events.AddHandler(EVENT_DEACTIVATED, value); } 
            remove { Events.RemoveHandler(EVENT_DEACTIVATED, value); }
        }

        ///  
        ///     This event is raised when the window state is changed
        ///  
        public event EventHandler StateChanged 
        {
            add { Events.AddHandler(EVENT_STATECHANGED, value); } 
            remove { Events.RemoveHandler(EVENT_STATECHANGED, value); }
        }

        ///  
        ///     This event is raised when the window location is changed
        ///  
        public event EventHandler LocationChanged 
        {
            add { Events.AddHandler(EVENT_LOCATIONCHANGED, value); } 
            remove { Events.RemoveHandler(EVENT_LOCATIONCHANGED, value); }
        }

        ///  
        ///     This event is raised before the window is closed
        ///  
        ///  
        ///     The user can set the CancelEventArg.Cancel property to true to prevent
        ///     the window from closing. However, if the Applicaiton is shutting down 
        ///     the window closing cannot be cancelled
        /// 
        public event CancelEventHandler Closing
        { 
            add { Events.AddHandler(EVENT_CLOSING, value); }
            remove { Events.RemoveHandler(EVENT_CLOSING, value); } 
        } 

        ///  
        ///     This event is raised when the window is closed.
        /// 
        public event EventHandler Closed
        { 
            add { Events.AddHandler(EVENT_CLOSED, value); }
            remove { Events.RemoveHandler(EVENT_CLOSED, value); } 
        } 

        ///  
        ///     This event is raised when the window and its content is rendered.
        /// 
        public event EventHandler ContentRendered
        { 
            add { Events.AddHandler(EVENT_CONTENTRENDERED, value); }
            remove { Events.RemoveHandler(EVENT_CONTENTRENDERED, value); } 
        } 

        #endregion Public Events 

        //---------------------------------------------------
        //
        // Protected Methods 
        //
        //--------------------------------------------------- 
        #region Protected Methods 

        ///  
        /// Creates AutomationPeer ()
        /// 
        protected override AutomationPeer OnCreateAutomationPeer()
        { 
            return new WindowAutomationPeer(this);
        } 
 
        /// 
        /// OnVisualParentChanged is called when the parent of the Visual is changed. 
        /// 
        /// Old parent or null if the Visual did not have a parent before.
        protected internal sealed override void OnVisualParentChanged(DependencyObject oldParent)
        { 
            VerifyContextAndObjectState();
            base.OnVisualParentChanged(oldParent); 
 
            // Checking for Visual parent here covers all the scenarios
            // including the following: 

            // Window w1 = new Window();
            // Window w2 = new WIndow();
            // w1.Show(); 
            // w2.Show();
            // w1.VisualChildren.Add(w2); 
 

            // Window w1 = new Window(); 
            // Window w2 = new WIndow();
            // w1.Show();
            // w1.VisualChildren.Add(w2);
            //  w2.Show(); 

            if ( VisualTreeHelper.GetParent(this) != null ) 
            { 
                throw new InvalidOperationException(SR.Get(SRID.WindowMustBeRoot));
            } 
        }

        /// 
        ///     Measurement override. Implements content sizing logic. 
        /// 
        ///  
        ///     Deducts the frame size from the constraint and then passes it on 
        ///     to it's child.  Only supports one Visual child (just like control)
        ///  
        protected override Size MeasureOverride(Size availableSize)
        {
            VerifyContextAndObjectState();
 
            // hamidm: WOSB 1330752 Window content should respect Window's Max/Min size
            // setting in a SizeToContent Window. 
            // 
            // Take Min/Max[Width/Height] into consideration.  The logic here is similar to
            // that used in FE.MeasureCore but is limited to Min/Max restriction.  Furthermore, 
            // we have our own version of MinMax struct called WindowMinMax that takes
            // SizeToContent into account when calculating the min/max values for height/width.
            //
            // We don't do anything special in ArrangeOverride the Arrange size is guaranteed 
            // to be the available hwnd size which should be atleast as big as the desired size.
 
            Size frameworkAvailableSize = new Size(availableSize.Width, availableSize.Height); 

            WindowMinMax mm = GetWindowMinMax(); 

            frameworkAvailableSize.Width  = Math.Max(mm.minWidth,  Math.Min(frameworkAvailableSize.Width, mm.maxWidth));
            frameworkAvailableSize.Height = Math.Max(mm.minHeight, Math.Min(frameworkAvailableSize.Height, mm.maxHeight));
 
            //  call to specific layout to measure
            Size desiredSize = MeasureOverrideHelper(frameworkAvailableSize); 
 
            //  maximize desiredSize with user provided min size
            desiredSize = new Size( 
                Math.Max(desiredSize.Width, mm.minWidth),
                Math.Max(desiredSize.Height, mm.minHeight));

            return desiredSize; 
        }
 
        ///  
        ///     ArrangeOverride allows for the customization of the positioning of children.
        ///  
        /// 
        ///     Deducts the frame size of the window from the constraint and then
        ///     arranges it's child.  Supports only one child.
        ///  
        protected override Size ArrangeOverride(Size arrangeBounds)
        { 
            VerifyContextAndObjectState(); 

            // hamidm: WOSB 1330752 Window content should respect Window's Max/Min size 
            // setting in a SizeToContent Window.

            // We don't do anything special in ArrangeCore regarding min/max size since
            // for BypassLayoutPolicies (Avalon Window case), the Arrange size is guaranteed 
            // to be the available hwnd size which should be atleast as big as the desired size.
 
 
            // Three primary cases
            //      1) hwnd does not exist  -- don't do anything 
            //      1a) CompositionTarget is invalid -- don't do anything
            //      2) Child visual exists  -- arrange child at arrangeBounds - window frame size
            //      3) No Child visual      -- don't do anything
 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            { 
                return arrangeBounds;
            } 

            if (this.VisualChildrenCount > 0)
            {
                UIElement child = this.GetVisualChild(0) as UIElement; 
                if (child != null)
                { 
                    // Find out the size of the window frame x. 
                    // (constraint - x) is the size we pass onto
                    // our child 
                    Size frameSize = GetHwndNonClientAreaSizeInMeasureUnits();

                    // In some instances (constraint size - frame size) can be negative. One instance
                    // is when window is set to minimized before layout has happened.  Apparently, Win32 
                    // gives a rect(-32000, -32000, -31840, -31975) for GetWindowRect when hwnd is
                    // minimized.  However, when we calculate the frame size we get width = 8 and 
                    // height = 28!!!  Here, we will take the max of zero and the difference b/w the 
                    // hwnd size and the frame size
                    // 
                    // PS Windows OS Bug: 955861

                    Size childArrangeBounds = new Size();
                    childArrangeBounds.Width = Math.Max(0.0, arrangeBounds.Width - frameSize.Width); 
                    childArrangeBounds.Height = Math.Max(0.0, arrangeBounds.Height - frameSize.Height);
 
                    child.Arrange(new Rect(childArrangeBounds)); 

                    // Windows OS bug # 928719, 953458 
                    // The default impl of FlowDirection is that it adds a transform on the element
                    // on whom the FlowDirection property is RlTb.  However, transforms work only if
                    // there is a parent visual.  In the window case, we are the root and thus this
                    // does not work.  Thus, we add the same transform to our child, if our 
                    // FlowDireciton = Rltb.
                    if (FlowDirection == FlowDirection.RightToLeft) 
                    { 
                        InternalSetLayoutTransform(child, new MatrixTransform(-1.0, 0.0, 0.0, 1.0, childArrangeBounds.Width, 0.0));
                    } 

                }
            }
            return arrangeBounds; 
        }
 
        ///  
        ///     This method is invoked when the Content property changes.
        ///  
        /// The old value of the Content property.
        /// The new value of the Content property.
        protected override void OnContentChanged(object oldContent, object newContent)
        { 
            base.OnContentChanged(oldContent, newContent);
 
            // hamidm 01/12/2005 
            // WOSB 1010151 FxCop: ConstructorsShouldNotCallBaseClassVirtualMethods::
            // System.Windows (presentationframework.dll 2 violation) 
            //
            // We can't set IWS property in the cctor since it results
            // in calling some virtual.  So, as an alternative we set it
            // when content is changed and when we set the root visual. 
            // We set it here, b/c once window has logical children, they
            // can query for inherited IWS property. 
            SetIWindowService(); 

            // We post a dispatcher work item to fire ContentRendered 
            // only if this is Loaded in the tree.  If not, we will
            // post it from the LoadedHandler.  This guarantees that
            // we don't fire ContentRendered on a subtree that is not
            // connected to a PresentationSource 
            if (IsLoaded == true)
            { 
                PostContentRendered(); 
            }
            else 
            {
                // _postContentRenderedFromLoadedHandler == true means
                // that we deferred to the Loaded event to PostConetentRendered
                // for the previous content change and Loaded has not fired yet. 
                // Thus we don't want to hook up another event handler
                if (_postContentRenderedFromLoadedHandler == false) 
                { 
                    this.Loaded += new RoutedEventHandler(LoadedHandler);
                    _postContentRenderedFromLoadedHandler = true; 
                }
            }
        }
 
        /// 
        ///     This even fires after the window source is created before it is shown. This event is non cancelable and is 
        ///     for user infromational purposes 
        /// 
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass
        ///     the event. If you override this method - you need to call Base.OnSourceInitialized(...) for
        ///     the corresponding event to be raised. 
        /// 
        ///  
        protected virtual void OnSourceInitialized(EventArgs e) 
        {
            VerifyContextAndObjectState(); 
            EventHandler handler = (EventHandler)Events[EVENT_SOURCEINITIALIZED];
            if (handler != null) handler(this, e);
        }
 
        /// 
        ///     This even fires when window is activated. This event is non cancelable and is 
        ///     for user infromational purposes 
        /// 
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass
        ///     the event. If you override this method - you need to call Base.OnClosed(...) for
        ///     the corresponding event to be raised. 
        /// 
        ///  
        protected virtual void OnActivated(EventArgs e) 
        {
            VerifyContextAndObjectState(); 
            EventHandler handler = (EventHandler)Events[EVENT_ACTIVATED];
            if (handler != null) handler(this, e);
        }
 
        /// 
        ///     This even fires when window is deactivated. This event is non cancelable and is 
        ///     for user infromational purposes 
        /// 
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass
        ///     the event. If you override this method - you need to call Base.OnClosed(...) for
        ///     the corresponding event to be raised. 
        /// 
        protected virtual void OnDeactivated(EventArgs e) 
        { 
            VerifyContextAndObjectState();
            EventHandler handler = (EventHandler)Events[EVENT_DEACTIVATED]; 
            if (handler != null) handler(this, e);
        }

        ///  
        ///     This even fires when window state is changed. This event is non
        ///     cancelable and is for user infromational purposes 
        ///  
        /// 
        ///     This method follows the .Net programming guideline of having a protected virtual 
        ///     method that raises an event, to provide a convenience for developers
        ///     that subclass the event. If you override this method - you need to call
        ///     Base.OnClosed(...) for the corresponding event to be raised.
        ///  
        protected virtual void OnStateChanged(EventArgs e)
        { 
            VerifyContextAndObjectState(); 
            EventHandler handler = (EventHandler)Events[EVENT_STATECHANGED];
            if (handler != null) handler(this, e); 
        }

        /// 
        ///     This event fires when window location changes. This event is not 
        ///     cancelable and is for user infromational purposes
        ///  
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass 
        ///     the event. If you override this method - you need to call Base.OnClosed(...) for
        ///     the corresponding event to be raised.
        /// 
        protected virtual void OnLocationChanged(EventArgs e) 
        {
            VerifyContextAndObjectState(); 
            EventHandler handler = (EventHandler)Events[EVENT_LOCATIONCHANGED]; 
            if (handler != null) handler(this, e);
        } 

        /// 
        ///     This event fires when window is Closing. This event is cancelable and thus the
        ///     user can set the CancelEventArgs.Cancel property to true to dismiss window 
        ///     closing
        ///  
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual
        ///     method that raises an event, to provide a convenience for developers that subclass 
        ///     the event. If you override this method - you need to call Base.OnClosing(...) for
        ///     the corresponding event to be raised.
        /// 
        protected virtual void OnClosing(CancelEventArgs e) 
        {
            VerifyContextAndObjectState(); 
            CancelEventHandler handler = (CancelEventHandler)Events[EVENT_CLOSING]; 
            if (handler != null) handler(this, e);
        } 

        /// 
        ///     This event fires when window is closed. This event is non cancelable and is
        ///     for user infromational purposes 
        /// 
        ///  
        ///     This method follows the .Net programming guideline of having a protected virtual 
        ///     method that raises an event, to provide a convenience for developers that subclass
        ///     the event. If you override this method - you need to call Base.OnClosed(...) for 
        ///     the corresponding event to be raised.
        /// 
        protected virtual void OnClosed(EventArgs e)
        { 
            VerifyContextAndObjectState();
            EventHandler handler = (EventHandler)Events[EVENT_CLOSED]; 
            if (handler != null) handler(this, e); 
        }
 
        /// 
        ///     This override fires the ContentRendered event.
        /// 
        ///  
        protected virtual void OnContentRendered(EventArgs e)
        { 
            VerifyContextAndObjectState(); 

            // After the content is rendered we want to check if there is an element that needs to be focused 
            // If there is - set focus to it
            DependencyObject doContent = Content as DependencyObject;
            if (doContent != null)
            { 
                IInputElement focusedElement = FocusManager.GetFocusedElement(doContent) as IInputElement;
                if (focusedElement != null) 
                    focusedElement.Focus(); 
            }
 
            EventHandler handler = (EventHandler)Events[EVENT_CONTENTRENDERED];
            if (handler != null) handler(this, e);
        }
        #endregion Protected Methods 

        //--------------------------------------------------- 
        // 
        // Internal Methods
        // 
        //----------------------------------------------------
        #region Internal Methods
        ///
        ///     Critical - calls a method that elevates - CompositionTarget 
        ///     TreatAsSafe - We only use the CompositionTarget to do device to logical unit conversion.
        /// 
        [SecurityCritical, SecurityTreatAsSafe] 
        internal Point DeviceToLogicalUnits(Point ptDeviceUnits)
        { 
            Invariant.Assert(IsCompositionTargetInvalid == false, "IsCompositionTargetInvalid is supposed to be false here");
            Point ptLogicalUnits = _swh.CompositionTarget.TransformFromDevice.Transform(ptDeviceUnits);
            return ptLogicalUnits;
        } 

        /// 
        ///     Critical - calls a method that elevates - CompositionTarget 
        ///     TreatAsSafe - We only use the CompositionTarget to do logical to device unit conversion.
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        internal Point LogicalToDeviceUnits(Point ptLogicalUnits)
        {
            Invariant.Assert(IsCompositionTargetInvalid == false, "IsCompositionTargetInvalid is supposed to be false here"); 
            Point ptDeviceUnits = _swh.CompositionTarget.TransformToDevice.Transform(ptLogicalUnits);
            return ptDeviceUnits; 
        } 

        internal static bool VisibilityToBool(Visibility v) 
        {
            switch (v)
            {
                case Visibility.Visible: 
                    return true;
                case Visibility.Hidden: 
                case Visibility.Collapsed: 
                    return false;
                default: 
                    return false;
            }
        }
 
        /// 
        ///     Called by ResizeGrip control to set its reference in the Window object 
        ///  
        /// 
        ///     RBW doesn't need ResizeGrip and hence it doesn't do 
        ///     anything in this virtual
        /// 
        internal virtual void SetResizeGripControl(Control ctrl)
        { 
            _resizeGripControl = ctrl;
        } 
 
        internal virtual void ClearResizeGripControl(Control oldCtrl)
        { 
            if (oldCtrl == _resizeGripControl)
            {
                _resizeGripControl = null;
            } 
        }
 
        internal virtual void TryClearingMainWindow() 
        {
            if (IsInsideApp && this == App.MainWindow) 
            {
                App.MainWindow = null;
            }
        } 

        ///  
        ///     Send a WM_CLOSE message to close the window. When the WM_CLOSE message is 
        ///     processed by the WindowFilterMessage function, the Closing event is fired.
        ///     Closing event is cancelable and thus can dismiss window closing. 
        /// 
        /// Specifies whether the app should shutdown or not
        /// Specifies whether cancelling closing should be ignored 
        /// 
        ///     Critical - as this code calls UnsafeSendMessage that has a SUC.
        /// 
        [SecurityCritical] 
        internal void InternalClose(bool shutdown, bool ignoreCancel)
        { 
            VerifyNotClosing();

            if (_disposed == true)
            { 
                return;
            } 
 
            _appShuttingDown = shutdown;
            _ignoreCancel = ignoreCancel; 

            if ( IsSourceWindowNull )
            {
                _isClosing = true; 

                // Event handler exception continuality: if exception occurs in Closing event handler, the 
                // cleanup action is to finish closing. 
                CancelEventArgs e = new CancelEventArgs(false);
                try 
                {
                    OnClosing(e);
                }
                catch 
                {
                    CloseWindowBeforeShow(); 
                    throw; 
                }
 
                if (ShouldCloseWindow(e.Cancel))
                {
                    CloseWindowBeforeShow();
                } 
                else
                { 
                    _isClosing = false; 
                    // 03/14/2006 -- hamidm
                    // WOSB 1560557 Dialog does not close with ESC key after it has been cancelled 
                    //
                    // No need to reset DialogResult to null here since source window is null.  That means
                    // that ShowDialog has not been called and thus no need to worry about DialogResult.
                } 
            }
            else 
            { 
                // close window synchronously
 
                // We demand for UIPermission AllWindows at the public API, Window.Close(), level.
                // It can be called when shutting down the app.
                // The public entry to that code path Application.Shutdown is
                // also protected with a demand for UIPermission with AllWindow access 

                // SendMessage's return value is dependent on the message send.  WM_CLOSE 
                // return value just signify whether the WndProc handled the 
                // message or not, so it is not interesting
#pragma warning disable 6523 
                UnsafeNativeMethods.UnsafeSendMessage(CriticalHandle, NativeMethods.WM_CLOSE, new IntPtr(), new IntPtr());
#pragma warning enable 6523
            }
        } 

        // NOTE: hamidm  05/18/03 -- PS # 843776 
        // We fire Closing and Closed envent even if the hwnd is not 
        // created yet i.e. window is not shown.
        /// 
        ///     Critical: Calls critical code: Window.InternalDispose
        ///
        [SecurityCritical]
        private void CloseWindowBeforeShow() 
        {
            InternalDispose(); 
 
            // raise Closed event
            OnClosed(EventArgs.Empty); 
        }

        ///
        ///     Critical - as this accesses critical data. 
        ///     TreatAsSafe - as this function just tests to see whether _sourceWindow has been created.
        ///                          Ok to expose publically. Equivalent to is Window visible. 
        /// 
        internal bool IsSourceWindowNull
        { 
            [ SecurityCritical, SecurityTreatAsSafe ]
            get
            {
                if ( _swh != null ) 
                {
                    return _swh.IsSourceWindowNull; 
                } 
                return true;
            } 
        }

        ///
        ///     Critical - as this accesses critical data. 
        ///     TreatAsSafe - as this function just tests to see whether CompositionTarget is valid.
        ///                          Ok to expose publically. 
        /// 
        internal bool IsCompositionTargetInvalid
        { 
            [ SecurityCritical, SecurityTreatAsSafe ]
            get
            {
                if (_swh != null) 
                {
                    return _swh.IsCompositionTargetInvalid; 
                } 
                return true;
            } 
        }

        internal NativeMethods.RECT WorkAreaBoundsForNearestMonitor
        { 
            get
            { 
                Debug.Assert( _swh != null ); 
                return _swh.WorkAreaBoundsForNearestMonitor;
            } 
        }

        internal Size WindowSize
        { 
            get
            { 
                Debug.Assert( _swh != null ); 
                return _swh.WindowSize;
            } 
        }

        // This is currently exposed just for DRTs.
        // PLEASE NOTE THAT IF YOU ARE CALLING THIS WITHIN AVALON CODE - YOU ARE CALLING A SECURITY 

 
 

 
        internal HwndSource HwndSourceWindow
        {
            [SecurityCritical, SecurityTreatAsSafe ]
            get 
            {
                SecurityHelper.DemandUIWindowPermission(); 
 
                if ( _swh != null )
                    return _swh.HwndSourceWindow; 
                else
                    return null;
            }
        } 

        // 
 

 



 

        // NOTE: added on 10/03/02 
        // We should set our _hwndSource reference to null here. 
        // Else, if the hwndSource is not null, users can call
        // public APIs that use hwndSource and it will fail 

        /// 
        ///     can be used by internal derived class
        ///  
        ///
        ///     Critical: It calls critical code: Window.UpdateWindowListsOnClose and it 
        ///     is used to dispose of the native handles which link demands in safe handle 
        ///
        [SecurityCritical] 
        private void InternalDispose()
        {
            _disposed = true;
 
            // UpdateWindowLists here instead of in WM_CLOSE for 2 reasons.
            // 1. WM_CLOSE is not fired for child window. An example would be RootBrowserWindow (bug 1754467). 
            // 2. It is not fired as a result of calling Dispose directly on HwndSource (HwndSource distroy the window). 
            UpdateWindowListsOnClose();
 
#if DISPOSE
            // detach all events
            if (_events != null)
            { 
                _events.Dispose();
                _events = null; 
            } 
#endif
            // NOTE: hamidm 
            // This InternalDispose method is called while
            // processing WM_DESTROY msg. Once we're done
            // processing this msg, HwndWrapper does it's processing.
            // We don't need to dispose _swh here b/c 
            // HwndWrapper fires the hwndDisposed event while
            // processing WM_DESTROY msg. HwndSource listens to 
            // this event and disposes itself i.e. the CompositionTarget etc. 
            // If we call dispose here, HwndWrapper.Dispose sends
            // a WM_DESTROY msg and it is a duplicate msg. 

            // According to .NET guidelines, Dispose() should
            // never throw, but we're doing try/finally to be
            // on the safe side.  We cannot afford to exit 
            // this method in an inconsistent state where
            // variables are not nulled out. 
            try 
            {
                ClearSourceWindow(); 

                if ( _hiddenWindow != null )
                {
                    _hiddenWindow.Dispose(); 
                }
 
                if (_defaultLargeIconHandle != null) 
                {
                    _defaultLargeIconHandle.Dispose(); 
                }

                if (_defaultSmallIconHandle != null)
                { 
                    _defaultSmallIconHandle.Dispose();
                } 
 
                if (_currentLargeIconHandle != null)
                { 
                    _currentLargeIconHandle.Dispose();
                }

                if (_currentSmallIconHandle != null) 
                {
                    _currentSmallIconHandle.Dispose(); 
                } 
            }
            finally 
            {
                _hiddenWindow = null;
                _defaultLargeIconHandle = null;
                _defaultSmallIconHandle = null; 
                _currentLargeIconHandle = null;
                _currentSmallIconHandle = null; 
 
                _isClosing = false;
            } 
        }

        /// 
        ///     This is a callback called to set the window Visual. It is called after 
        ///     the source window has been created.
        ///  
        internal override void OnAncestorChanged() 
        {
            base.OnAncestorChanged(); 
            if (Parent != null)
            {
                throw new InvalidOperationException(SR.Get(SRID.WindowMustBeRoot));
            } 
        }
 
        ///  
        ///     Initializes the _style and _styleEx bits.
        ///  
        //CASRemoval:[StrongNameIdentityPermissionAttribute(SecurityAction.InheritanceDemand, PublicKey=Microsoft.Internal.BuildInfo.WCP_PUBLIC_KEY_STRING)]
        internal virtual void CreateAllStyle()
        {
            // we don't need to set to WS_OVERLAPPEDWINDOW since all the styles are set 
            // manually depending on window properties.
            // 
            // We always have the sysmenu 
            // If the Window has a Caption, then this also
            // shows the icon and the close box 

            _Style = NativeMethods.WS_CLIPCHILDREN | NativeMethods.WS_SYSMENU;
            _StyleEx = 0;
 
            CreateWindowStyle();
            CreateWindowState(); 
 
            // do all the other checks and update style bits
 
            // Visibility bits
            if ( _isVisible )
            {
                _Style |= NativeMethods.WS_VISIBLE; 
            }
 
            SetTaskbarStatus(); 
            CreateTopmost();
            CreateResizibility(); 
            CreateRtl();
        }

        ///  
        ///     Create the window
        ///     Virtual so that subclasses ( currently only RootBrowserWindow) - may assert for HwndSource creation. 
        ///  
        /// 
        ///     This methods does the following: 
        ///     CalculateLocation of the window:
        ///         Calculates location of window. If either Top/Left is CW_USEDEFAULT,
        ///         we have to make sure that window displays on the screen. Details in
        ///         the methods. 
        ///
        ///     Calculate size: 
        ///         Calculates size. If either one of Width/Height is set, then we 
        ///         create a window with both set to default and then resizing it
        ///         to the set value 
        ///
        ///     Update Properties:
        ///         After the hwnd is created, we updated our property values for various
        ///         properties 
        /// 
        /// 
        ///     Critical - as this method accesses critical data and creates a window which it stores locally 
        ///
        [SecurityCritical] 
        internal virtual void CreateSourceWindowImpl()
        {
            // we need to cache initial requested top and left as the very first thing
            // since updating the styles etc (as for borderless case below) fires 
            // WM_MOVE and update Top/Left.  Also, for RBW case, Top/Left is returned
            // as 0,0 since they are inconsequential. 
 
            double requestedTop = 0;
            double requestedLeft = 0; 
            double requestedWidth = 0;
            double requestedHeight = 0;

            GetRequestedDimensions(ref requestedLeft, ref requestedTop, ref requestedWidth, ref requestedHeight); 

            using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd)) 
            { 
                // set window style and styleEx bits
                // CreateAllStyle is internal virtual. RBW overrides it to set style to WS_CHILD and 
                // set parent handle
                CreateAllStyle();

                // create the Win32 Window 
                HwndSourceParameters param = new HwndSourceParameters(Title, NativeMethods.CW_USEDEFAULT, NativeMethods.CW_USEDEFAULT);
                param.UsesPerPixelOpacity = AllowsTransparency; 
                param.WindowStyle = _Style; 
                param.ExtendedWindowStyle = _StyleEx;
                param.ParentWindow = _ownerHandle; 
                param.AdjustSizingForNonClientArea = true;
                param.HwndSourceHook = new HwndSourceHook(WindowFilterMessage); // hook to process window messages

 
                // HwndSource disposes itself when HwndWrapper process the WM_DESTROY message.
                // Window sends WM_CLOSE (which in turn sends WM_DESTROY) to the hwnd when 
                // Window.Close() is called.  Thus, this HwndSource created by window is always 
                // disposed by HwndSource itself
#pragma warning disable 56518 
                HwndSource source = new HwndSource(param);
#pragma warning enable 56518
                _swh = new SourceWindowHelper(source);
                source.SizeToContentChanged += new EventHandler(OnSourceSizeToContentChanged); 

                // since we created the window with the style, mark 
                // sm as not dirty so that we don't unneccessarialy update 
                // the Win32 style bits.
                sm.Dirty = false; 

                // NOTE: hamidm
                // HwndSource COULD ADD STYLE/STYLEEX BITS TO THE ONES SUPPLIED. TODAY,
                // HwndSource ADDS WS_CLIPCHILDREN TO THE STYLE WHICH MAY NOT 
                // BE REFLECTED IN OUR CACHED STYLE BITS.  IF WE WERE
                // TO UPDATE THE WIN32 SYTLE, THE STYLES ADDED BY HWNDSOURCE 
                // WOULD BE LOST.  IF IN THE 

 



 
                // Since RBW cannot access WindowStyle, hence it overrides
                // this virtual and does nothing it it. 
                CorrectStyleForBorderlessWindowCase(); 

            } // end using StyleManager 

            // We don't do anything that uses the Window styles below so we might as
            // well close the using so that we update the new style to the hwnd.
            // This change was made for WOSB 1051710 where SizeToContent.WidthAndHeight borderless 
            // windows where actually bigger than the content size.  This was b/c of
            // the fact that we didn't update the style of the hwnd before setting 
            // the RootVisual which inturn calls MeasureOverride on Window from 
            // where we calculating the non-client area size using the stale
            // style bits from the hwnd. 

            // Add Disposed event handler
            _swh.AddDisposedHandler ( new EventHandler(OnSourceWindowDisposed) );
 
            // Sub classes can have different intialization. RBW does very minimalistic
            // stuff in its override 
            SetupInitialState(requestedTop, requestedLeft, requestedWidth, requestedHeight); 

            // Fire SourceInitialized event 
            OnSourceInitialized(EventArgs.Empty);
        }

        private void OnSourceSizeToContentChanged(object sender, EventArgs args) 
        {
            SizeToContent = HwndSourceSizeToContent; 
        } 

        internal virtual void CorrectStyleForBorderlessWindowCase() 
        {
            // We create an OverLapped window for which user adds WS_CAPTION
            // to the passed in style.  If we were creating a borderless window,
            // remove WS_CAPTION from the hwnd. 
            //
            // We should really be using WS_POPUP for borderless windows, but 
            // there's a bug with default sizing where user creates the popup 
            // window with 0,0 size.
            // 

            using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd))
            {
                if (WindowStyle == WindowStyle.None) 
                {
                    _Style = _swh.StyleFromHwnd; 
                    _Style &= ~NativeMethods.WS_CAPTION; 
                }
            } 
        }

        internal virtual void GetRequestedDimensions(ref double requestedLeft, ref double requestedTop, ref double requestedWidth, ref double requestedHeight)
        { 
            requestedTop = this.Top;
            requestedLeft = this.Left; 
            requestedWidth = this.Width; 
            requestedHeight = this.Height;
        } 

        ///
        ///     Critical - as this method accesses critical data (CriticalHandle) and
        ///                 resizes/repositions the window 
        ///     It also calls critical method (SetRootVisual)
        /// 
        [SecurityCritical] 
        internal virtual void SetupInitialState(double requestedTop, double requestedLeft, double requestedWidth, double requestedHeight)
        { 
            // Push the current SizeToContent value to HwndSource after it's created. Initial [....] up.
            HwndSourceSizeToContent = (SizeToContent) GetValue(SizeToContentProperty);
            UpdateIcon();
 
            NativeMethods.RECT rc = WindowBounds;
            Size sizeDeviceUnits = new Size(rc.right - rc.left, rc.bottom - rc.top); 
            double xDeviceUnits = rc.left; 
            double yDeviceUnits = rc.top;
 
            bool updateHwndPlacement = false;

            // This code is absolutely necessary here.  This is the initial [....] up
            // for Left/Top.  We don't do this in WM_MOVE if sourceWindow is 
            // null (it is null b/c the call to create HwndSource has not returned at the point)
            // and we are not listening to WM_CREATE either.  The reasons for not 
            // doing so is b/c if sourceWindow is null, we can't get to the CompositionTarget 
            // to convert b/w device and logical pixels
            Point currentLocationLogicalUnits = DeviceToLogicalUnits(new Point(xDeviceUnits, yDeviceUnits)); 

            // Update our current hwnd ActualTop/ActualLeft values
            // The _actualLeft and _actualTop need to be updated before we coerce Top and Left.
            // See CoerceTop for more info. 
            _actualLeft = currentLocationLogicalUnits.X;
            _actualTop = currentLocationLogicalUnits.Y; 
            // Coerce Top and Left value to be the intial value used in CreateWindowEx. 
            try
            { 
                _updateHwndLocation = false;
                CoerceValue(TopProperty);
                CoerceValue(LeftProperty);
            } 
            finally
            { 
                _updateHwndLocation = true; 
            }
 
            Point requestedSizeDeviceUnits = LogicalToDeviceUnits(new Point(requestedWidth, requestedHeight));
            Point requestedLocationDeviceUnits = LogicalToDeviceUnits(new Point(requestedLeft, requestedTop));

            // if Width was specified and is not the same as the current width, then update it 
            if ((!DoubleUtil.IsNaN(requestedWidth)) && (!DoubleUtil.AreClose(sizeDeviceUnits.Width, requestedSizeDeviceUnits.X)))
            { 
                // at this stage, ActualWidth/Height is not set since 
                // layout has not happened (it happens when we set the
                // RootVisual of the HwndSource) 

                updateHwndPlacement = true;
                sizeDeviceUnits.Width = requestedSizeDeviceUnits.X;
 
                // SetWindowPlacement for Width/Height when Width/Height is set and WindowState is maximized/minimized.
                // No need to do it for Top/Left since that is taken care of in CoerceTop/Left. 
                // Width/Height is different from Top/Left. For the actual value, there are ActualWidth/Height. 
                // That is why the same Top/Left coerce logic won't work for Width/Height.
                if (WindowState != WindowState.Normal) 
                {
                    UpdateHwndRestoreBounds(requestedWidth, BoundsSpecified.Width);
                }
            } 

            // if Height was specified and is not the same as the current height, then update it 
            if (!DoubleUtil.IsNaN(requestedHeight) && (!DoubleUtil.AreClose(sizeDeviceUnits.Height, requestedSizeDeviceUnits.Y))) 
            {
                // at this stage, ActualWidth/Height is not set since 
                // layout has not happened (it happens when we set the
                // RootVisual of the HwndSource)

                updateHwndPlacement = true; 
                sizeDeviceUnits.Height = requestedSizeDeviceUnits.Y;
 
                // SetWindowPlacement for Width/Height when Width/Height is set and WindowState is maximized/minimized. 
                // No need to do it for Top/Left since that is taken care of in CoerceTop/Left.
                // Width/Height is different from Top/Left. For the actual value, there are ActualWidth/Height. 
                // That is why the same Top/Left coerce logic won't work for Width/Height.
                if (WindowState != WindowState.Normal)
                {
                    UpdateHwndRestoreBounds(requestedHeight, BoundsSpecified.Height); 
                }
            } 
 
            // if left was specified and is not the same as the current left, then update it
            if (!DoubleUtil.IsNaN(requestedLeft) && (!DoubleUtil.AreClose(xDeviceUnits, requestedLocationDeviceUnits.X))) 
            {
                updateHwndPlacement = true;
                xDeviceUnits = requestedLocationDeviceUnits.X;
            } 

            // if top was specified and is not the same as the current top, then update it 
            if (!DoubleUtil.IsNaN(requestedTop) && (!DoubleUtil.AreClose(yDeviceUnits, requestedLocationDeviceUnits.Y))) 
            {
                updateHwndPlacement = true; 
                yDeviceUnits = requestedLocationDeviceUnits.Y;
            }

            Point minSizeDeviceUnits = LogicalToDeviceUnits(new Point(MinWidth, MinHeight)); 
            Point maxSizeDeviceUnits = LogicalToDeviceUnits(new Point(MaxWidth, MaxHeight));
 
            // We need this here b/c when WM_GETMINMAXINFO is handled as a result of 
            // creating the hwnd, _swh is null and thus we cannot get to the CompositionTarget
            // to convert b/w device and logical units.  Thus, once the hwnd is created, we 
            // need to check to make sure that the hwnd is within the min/max boundaries.
            //
            // Here is idea it to detect if we are outside the min/max range and if yes, cause
            // a resize.  This resize will call WM_GETMINMAXINFO and that will further take 
            // care of the bounds
 
            if (!Double.IsPositiveInfinity(maxSizeDeviceUnits.X) && (sizeDeviceUnits.Width > maxSizeDeviceUnits.X)) 
            {
                updateHwndPlacement = true; 
                sizeDeviceUnits.Width = maxSizeDeviceUnits.X;
            }

            if (!Double.IsPositiveInfinity(minSizeDeviceUnits.Y) && (sizeDeviceUnits.Height > maxSizeDeviceUnits.Y)) 
            {
                updateHwndPlacement = true; 
                sizeDeviceUnits.Height = maxSizeDeviceUnits.Y; 
            }
 
            if (sizeDeviceUnits.Width < minSizeDeviceUnits.X)
            {
                updateHwndPlacement = true;
                sizeDeviceUnits.Width = minSizeDeviceUnits.X; 
            }
 
            if (sizeDeviceUnits.Height < minSizeDeviceUnits.Y) 
            {
                updateHwndPlacement = true; 
                sizeDeviceUnits.Height = minSizeDeviceUnits.Y;
            }

            // Now that we know the window Width/Height/Left/Top, we want to calculate 
            // the location based on WindowStartupLocation enum.  All inputs to
            // CalculateWindowLocation must be in DEVICE units.  It will return true, 
            // if it updated theinput values of left, top. 
            //
            updateHwndPlacement = (CalculateWindowLocation(ref xDeviceUnits, ref yDeviceUnits, sizeDeviceUnits)? true: updateHwndPlacement); 

            // We need to update the hwnd size before we set RootVisual b/c setting RootVisual
            // results in a Measure/Arrange/Layout and we want to set the correct hwnd size
            // now so that layout happens at the correct size. 
            //
            if (updateHwndPlacement == true) 
            { 
                if (WindowState == WindowState.Normal)
                { 
                    UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle),
                        new HandleRef(null, IntPtr.Zero),
                        DoubleUtil.DoubleToInt(xDeviceUnits),
                        DoubleUtil.DoubleToInt(yDeviceUnits), 
                        DoubleUtil.DoubleToInt(sizeDeviceUnits.Width),
                        DoubleUtil.DoubleToInt(sizeDeviceUnits.Height), 
                        NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE 
                        );
 
                    // The value of Top and Left is affected by WindowState and WindowStartupLocation.
                    // we need to coerce Top and Left whenever these deciding factors change.
                    // More info in CoerceTop.
                    try 
                    {
                        _updateHwndLocation = false; 
                        _updateStartupLocation = true; 
                        CoerceValue(TopProperty);
                        CoerceValue(LeftProperty); 
                    }
                    finally
                    {
                        _updateHwndLocation = true; 
                        _updateStartupLocation = false;
                    } 
                } 
            }
 
            SetRootVisual();

            // if SizeToContent, we would need to set the location again if
            // WSL is CenterOwner or CenterScreen b/c size may have changed 
            // after we set the RootVisual on HwndSource.
            if (SizeToContent != SizeToContent.Manual) 
            { 
                // inputs to CalculateWindowLocation must be in DEVICE units
                Point newSizeDeviceUnits = LogicalToDeviceUnits(new Point(this.ActualWidth, this.ActualHeight)); 
                if (CalculateWindowLocation(ref xDeviceUnits, ref yDeviceUnits, new Size(newSizeDeviceUnits.X, newSizeDeviceUnits.Y)))
                {
                    if (WindowState == WindowState.Normal)
                    { 
                        UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle),
                            new HandleRef(null, IntPtr.Zero), 
                            DoubleUtil.DoubleToInt(xDeviceUnits), 
                            DoubleUtil.DoubleToInt(yDeviceUnits),
                            0, 
                            0,
                            NativeMethods.SWP_NOSIZE | NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE
                            );
 
                        // The value of Top and Left is affected by WindowState and WindowStartupLocation.
                        // we need to coerce Top and Left whenever these deciding factors change. 
                        // More info in CoerceTop. 
                        try
                        { 
                            _updateHwndLocation = false;
                            _updateStartupLocation = true;
                            CoerceValue(TopProperty);
                            CoerceValue(LeftProperty); 
                        }
                        finally 
                        { 
                            _updateHwndLocation = true;
                            _updateStartupLocation = false; 
                        }
                    }
                }
            } 
        }
 
        /// 
        ///     Critical - as this method accesses critical method (_swh.RootVisual)
        /// 
        [SecurityCritical]
        internal void SetRootVisual()
        {
            // hamidm 01/12/2005 
            // WOSB 1010151 FxCop: ConstructorsShouldNotCallBaseClassVirtualMethods::
            // System.Windows (presentationframework.dll 2 violation) 
            // 
            // We can't set IWS property in the cctor since it results
            // in calling some virtual.  So, as an alternative we set it 
            // when content is changed and when we set the root visual.
            // We set it here, b/c once RootVisual is set, the visual tree
            // can/is created and visual children can query for inherited
            // IWS property. 
            SetIWindowService();
 
            // 
            // We are intentionally not merging the above SetWindowPos with the one below.  The reason is
            // that if Width or Height is set we initially create the hwnd with both as default win32 size 
            // and later (above call to SetWindowPos) resizes it to reflect the specified Width or Height.
            // After this is done, we set RootVisual which results in a layout with the correct size of
            // the hwnd.
            // 
            // If we merge the above call to SetWindowPos with the one below, then for the scenario where
            // Width or Height is set initially, we create the hwnd with win32 default size.  Setting RootVisual 
            // would cause layout to happen at that default size.  Now, we resize the window to reflect the 
            // specified size which will result in another layout.
            // 
            // The third option is to set RootVisual after doing all resizes.  This is not possible to do for
            // the SizeToContent case since we don't know the size of hwnd until RootVisual is set and layout
            // has happened.
            // 

            // set root visual  synchronously, shell request 
            if ( IsSourceWindowNull == false ) 
            {
                _swh.RootVisual = this; 
            }
        }

        ///  
        ///     Create the style bits depending on the WindowStyle property
        ///  
        ///  
        ///     This method does not clear the bits, so the style bits should be cleared
        ///     before calling this method 
        /// 
        private void CreateWindowStyle()
        {
            // Clear the style bits related to WindowStyle 
            _Style &= ~NativeMethods.WS_CAPTION;
            _StyleEx &= ~(NativeMethods.WS_EX_CLIENTEDGE | NativeMethods.WS_EX_TOOLWINDOW); 
 
            // WS_CAPTION == WS_BORDER | WS_DLGFRAME (0x00C00000L)
            // Thus no need to set/clear WS_BORDER when we are 
            // already seting/clearing WS_CAPTION
            switch (WindowStyle)
            {
                case WindowStyle.None: 
                    _Style &= (~NativeMethods.WS_CAPTION);
                    break; 
 
                case WindowStyle.SingleBorderWindow:
                    _Style |= NativeMethods.WS_CAPTION; 
                    break;

                case WindowStyle.ThreeDBorderWindow:
                    _Style |= NativeMethods.WS_CAPTION; 
                    _StyleEx |= NativeMethods.WS_EX_CLIENTEDGE;
                    break; 
 
                case WindowStyle.ToolWindow:
                    _Style |= NativeMethods.WS_CAPTION; 
                    _StyleEx |= NativeMethods.WS_EX_TOOLWINDOW;
                    break;
#if Never
                case WindowBorderStyle.Sizable: 
                    _startSettings.Style |= NativeMethods.WS_BORDER | NativeMethods.WS_THICKFRAME;
                    break; 
 
                case WindowBorderStyle.FixedDialog:
                    _startSettings.Style |= NativeMethods.WS_BORDER; 
                    _startSettings.StyleEx |= NativeMethods.WS_EX_DLGMODALFRAME;
                    break;
                case WindowBorderStyle.SizableToolWindow:
                    _startSettings.Style |= NativeMethods.WS_BORDER | NativeMethods.WS_THICKFRAME; 
                    _startSettings.StyleEx |= NativeMethods.WS_EX_TOOLWINDOW;
                    break; 
#endif 
            }
        } 

        // called as a result of title property changing to propagate it to the hwnd
        /// 
        ///     Critical: As this accesses Handle 
        ///     TreatAsSafe: There will be a demand from SetWindowText
        ///  
        [SecurityCritical,SecurityTreatAsSafe] 
        internal virtual void UpdateTitle(string title)
        { 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if ( IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            {
                UnsafeNativeMethods.SetWindowText(new HandleRef(this, CriticalHandle), title); 
            }
        } 
 
        // called as a result of Height/MinHeight/MaxHeight and Width/MinWidth/MaxWidth property changing to update the hwnd size
        ///  
        ///     Critical: This code accesses CriticalHandle
        ///     TreatAsSafe: This code only works under RBW code path , this operation is ok since
        ///     RBW window is bound to the restrictions of its parent window which is the browser
        ///  
        [SecurityCritical, SecurityTreatAsSafe]
        private void UpdateHwndSizeOnWidthHeightChange(double widthLogicalUnits, double heightLogicalUnits) 
        { 
            if (!_inTrustedSubWindow)
            { 
                 SecurityHelper.DemandUIWindowPermission();
            }
            Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull cannot be true when calling this function");
 
            Point ptDeviceUnits = LogicalToDeviceUnits(new Point(widthLogicalUnits, heightLogicalUnits));
            UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle), 
                        new HandleRef(null, IntPtr.Zero), 
                        0,
                        0, 
                        DoubleUtil.DoubleToInt(ptDeviceUnits.X),
                        DoubleUtil.DoubleToInt(ptDeviceUnits.Y),
                        NativeMethods.SWP_NOMOVE | NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE
                        ); 
        }
 
        // Activate or Deactivate window 
        internal void HandleActivate(bool windowActivated)
        { 
            // hamidm -- 12/10/04
            //
            // This method is called by WM_ACTIVATE msg hander for the stand alone
            // window case.  WM_ACTIVATE is sent twice when activating a minimized 
            // window by mouse click; once with window state minimized and then again
            // with window state normal.  Thus, we have the following if conditions 
            // to fire Activated/Deactivated events only if we're activating/deactivating 
            // the window and the window was previously deactivated/activated.
            // 
            // Please look at WOSB 990841 (Activated event fires twice on window when
            // you minimize and restore a window) on this issue.
            //
 
            // Event handler exception continuality: if exception occurs in Activated/Deactivated event handlers, our state will not be
            // corrupted because the state related to Activated/Deactivated, IsActive is set before the event is fired. 
            // Please check Event handler exception continuality if the logic changes. 
            if ((windowActivated == true) && (IsActive == false))
            { 
                SetValue(IsActivePropertyKey, BooleanBoxes.TrueBox);
                OnActivated(EventArgs.Empty);
            }
            else if ((windowActivated == false) && (IsActive == true)) 
            {
                SetValue(IsActivePropertyKey, BooleanBoxes.FalseBox); 
                OnDeactivated(EventArgs.Empty); 
            }
        } 

        internal virtual void UpdateHeight(double newHeight)
        {
            if (WindowState == WindowState.Normal) 
            {
                // We cannot save the current hwnd height in logical units in WmSizeChanged b/c the HwndSource 
                // might not be completely created at that time (when we call new HwndSource from CreateSourceWindowImpl) 
                // and DeviceToLogicalUnits fails.  Thus we convert to logical units here before we call
                // UpdateHwndSizeonWidthHeightChange since that expects logical units. 
                Point sizeLogicalUnits = DeviceToLogicalUnits(new Point(_currentHwndWidthDevicePixels, 0));
                UpdateHwndSizeOnWidthHeightChange(sizeLogicalUnits.X, newHeight);
            }
            else 
            {
                UpdateHwndRestoreBounds(newHeight, BoundsSpecified.Height); 
            } 
        }
 
        internal virtual void UpdateWidth(double newWidth)
        {
            if (WindowState == WindowState.Normal)
            { 
                // We cannot save the current hwnd width in logical units in WmSizeChanged b/c the HwndSource
                // might not be completely created at that time (when we call new HwndSource from CreateSourceWindowImpl) 
                // and DeviceToLogicalUnits fails.  Thus we convert to logical units here before we call 
                // UpdateHwndSizeonWidthHeightChange since that expects logical units.
                Point sizeLogicalUnits = DeviceToLogicalUnits(new Point(0, _currentHwndHeightDevicePixels)); 
                UpdateHwndSizeOnWidthHeightChange(newWidth, sizeLogicalUnits.Y);
            }
            else
            { 
                // set restore width
                UpdateHwndRestoreBounds(newWidth, BoundsSpecified.Width); 
            } 
        }
 
        ///
        /// Critical - This code is used to block off api in rbw
        /// TreatAsSafe - This is critical only because we want to track change
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        internal virtual void VerifyApiSupported() 
        { 
            // don't do anything here since we allow this API in Window.
            // Subclasses can throw exception in their override if 
            // they don't allow the api.
        }
        #endregion Internal Methods
 

        //---------------------------------------------- 
        // 
        // Internal Properties
        // 
        //----------------------------------------------
        #region Internal Properties

        internal bool IsDisposed 
        {
            get 
            { 
                return _disposed;
            } 
        }

        /// 
        /// This tells whether user has set Visible or not. It's currently used in Application 
        /// where if Visibility has not been set when the Window is navigated to, we set it to
        /// Visible 
        ///  
        internal bool IsVisibilitySet
        { 
            get
            {
                VerifyContextAndObjectState();
                return _isVisibilitySet; 
            }
        } 
 
        /// 
        ///     Exposes the hwnd of the window. This property is used by the WindowInteropHandler 
        ///     class
        /// 
        /// 
        ///     Critical: This code exposes handle 
        /// 
        internal IntPtr CriticalHandle 
        { 
            [SecurityCritical]
            get 
            {
                VerifyContextAndObjectState();
                if (_swh != null)
                { 
                    return _swh.CriticalHandle;
                } 
                else 
                return IntPtr.Zero;
            } 
        }

        /// 
        ///     Enables to get/set the owner handle for this window. This property is used by 
        ///     the WindowInteropHelper class
        ///  
        /// 
        ///     This API is currently not available for use in Internet Zone.
        /// 
        ///
        /// Critical - accesses _ownerHandle, calls SetParentHandle.
        /// TreatAsSafe - get/set protected by Demand's.
        /// 
        internal IntPtr OwnerHandle
        { 
            [SecurityCritical,SecurityTreatAsSafe] 
            get
            { 
                SecurityHelper.DemandUIWindowPermission();

                VerifyContextAndObjectState();
                return _ownerHandle; 
            }
            [SecurityCritical, SecurityTreatAsSafe] 
            set 
            {
                SecurityHelper.DemandUIWindowPermission(); 

                VerifyContextAndObjectState();

                if ( _showingAsDialog == true ) 
                {
                    throw new InvalidOperationException(SR.Get(SRID.CantSetOwnerAfterDialogIsShown)); 
                } 

                if (_ownerHandle != value) 
                {
                    _ownerHandle = value;
                    SetParentHandle(value);
                } 
            }
        } 
 
        /// 
        ///     This is used by RBW to set the correct win32 style 
        /// 
        internal int Win32Style
        {
            get 
            {
                VerifyContextAndObjectState(); 
                return _Style; 
            }
            set 
            {
                VerifyContextAndObjectState();

                // The reason this is not wrapped by a manager is that it should never 
                // be invoked outside the scope on an already established manager.
                Debug.Assert(Manager != null, "HwndStyleManager must have a valid value here"); 
                _Style = value; 
            }
        } 

        /// 
        ///    Critical: This code causes style to be set and acceses a critical resource
        ///    TreatAsSafe: There exists a demand on set since SET is not safe 
        /// 
        internal int _Style 
        { 
            get
            { 
                if (Manager != null)
                {
                    return _styleDoNotUse.Value;
 
                }
                else if ( IsSourceWindowNull ) 
                { 
                    return _styleDoNotUse.Value;
 
                }
                else
                {
                    return _swh.StyleFromHwnd; 
                }
            } 
            [SecurityCritical,SecurityTreatAsSafe] 
            set
            { 
                SecurityHelper.DemandUIWindowPermission();
                _styleDoNotUse= new SecurityCriticalDataForSet(value);
                Manager.Dirty = true;
            } 
        }
 
        ///  
        ///    Critical: This code causes style to be set
        ///    TreatAsSafe: There exists a demand on set since SET is not safe 
        /// 
        internal int _StyleEx
        {
            get 
            {
                if (Manager != null) 
                { 
                    return _styleExDoNotUse.Value;
 
                }
                else if (IsSourceWindowNull == true  )
                {
                    return _styleExDoNotUse.Value; 

                } 
                else 
                {
                    return _swh.StyleExFromHwnd; 
                }
                }
            [SecurityCritical, SecurityTreatAsSafe]
            set 
            {
                SecurityHelper.DemandUIWindowPermission(); 
                _styleExDoNotUse= new SecurityCriticalDataForSet((int)value); 
                Manager.Dirty = true;
            } 
        }

        internal HwndStyleManager Manager
        { 
            get { return _manager; }
            set { _manager = value; } 
        } 

        bool IWindowService.UserResized 
        {
            get { return _userResized; }
        }
        #endregion Internal Properties 

        //---------------------------------------------- 
        // 
        // Internal Fields
        // 
        //----------------------------------------------
        #region Internal Fields

        ///  
        /// DialogCancel Command. It closes window if it's dialog and return false as the dialog value.
        ///  
        ///  
        /// Right now this is only used by Cancel Button to close the dialog.
        ///  
        internal static readonly RoutedCommand DialogCancelCommand = new RoutedCommand("DialogCancel", typeof(Window));

        #endregion Internal Fields
 

        //---------------------------------------------- 
        // 
        // Internal Types
        // 
        //----------------------------------------------
        #region Internal Types
        // similar to the one in FE except that it takes care of SizeToContent
        // while determining the min/max values for height and width. 
        internal struct WindowMinMax
        { 
            internal double minWidth; 
            internal double maxWidth;
            internal double minHeight; 
            internal double maxHeight;

            internal WindowMinMax(double minSize, double maxSize)
            { 
                minWidth = minSize;
                maxWidth = maxSize; 
                minHeight = minSize; 
                maxHeight = maxSize;
            } 
        }
        #endregion Internal Types

        //---------------------------------------------- 
        //
        // Private Methods 
        // 
        //----------------------------------------------
        #region Private Methods 
        private Size MeasureOverrideHelper(Size constraint)
        {
            // need to handle infinity
            // return the entire client area of the window 
            // Measure children properly.
 
            // Three primary cases 
            //      1)  hwnd does not exist  -- return 0,0
            //      1a) CompositionTarget is invalid -- return 0,0 
            //      2)  Child visual exists  -- we return child.DesiredSize + frame size
            //      3)  No Child visual      -- return the hwnd size (this should be the same
            //                                  as the one passed into MeasureOverride for our framework)
 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            { 
                // No need to use CompositionTarget.TransformFromDevice
                // since size is 0,0 
                return new Size(0,0);
            }

            if (this.VisualChildrenCount > 0) 
            {
                UIElement child = this.GetVisualChild(0) as UIElement; 
                if (child != null) // UIElement children 
                {
                    // Find out the size of the window frame x. 
                    // (constraint - x) is the size we pass onto
                    // our child

                    Size frameSize = GetHwndNonClientAreaSizeInMeasureUnits(); 

                    // In some instances (constraint size - frame size) can be negative. One instance 
                    // is when window is set to minimized before layout has happened.  Apparently, Win32 
                    // gives a rect(-32000, -32000, -31840, -31975) for GetWindowRect when hwnd is
                    // minimized.  However, when we calculate the frame size we get width = 8 and 
                    // height = 28!!!  Here, we will take the max of zero and the difference b/w the
                    // hwnd size and the frame size
                    //
                    // PS Windows OS Bug: 955861 
                    Size childConstraint = new Size();
                    childConstraint.Width = ((constraint.Width == Double.PositiveInfinity) ? Double.PositiveInfinity : Math.Max(0.0, (constraint.Width - frameSize.Width))); 
                    childConstraint.Height = ((constraint.Height == Double.PositiveInfinity) ? Double.PositiveInfinity : Math.Max(0.0, (constraint.Height - frameSize.Height))); 

                    child.Measure(childConstraint); 
                    Size childDesiredSize = child.DesiredSize;
                    return new Size(childDesiredSize.Width + frameSize.Width, childDesiredSize.Height + frameSize.Height);
                }
            } 

            // if we reach here, we return the input size 
            return _swh.GetSizeFromHwndInMeasureUnits(); 
        }
 
        // Similar logic as in FE.MinMax and takes care of max/min size allowed by win32 for the hwnd.  However, we
        // don't take Height/Width into consideration.  This is because of the following reasons:
        //
        // 1) Window Height/Width info doesn't matter here since we just need to ensure that the child element is 
        //    layed out within the Max/Min restrictions of the window.  Window is layed out at the size sent into MO/AO
        //    and Height and Width of the window does not play a part MO/AO stage. 
        // 
        // 2) We had WOSB 1399028 FlowDocumentReader: When the maximise button is clicked on the window with FDR the
        //    content don't reflow to fill in the entire window) and the fix for that is to simply not use H/W here. 
        //    GetWindowMinMax fixes the following bugs:
        //
        //    WOSB 1330752 Window content should respect Window's Max/Min size
        //    WOSB 1030000 Wrong window actual size returned if Autosize window content is smaller than the actual 
        //    window (seems to return content size as opposed to window size)
        // 
        //  This method is called by both MeasureOverride( ) and WmGetMinMaxInfo( ). 
        //  It will calculate a final Min/Max size in logic units for this HWND based on Win32 restricted value and
        //  current Min/Max setting in this instance. 
        //
        internal virtual WindowMinMax GetWindowMinMax()
        {
            WindowMinMax mm = new WindowMinMax( ); 

            Invariant.Assert(IsCompositionTargetInvalid == false, "IsCompositionTargetInvalid is supposed to be false here"); 
 
            // convert the max/min size (taken in to account the hwnd size restrictions by win32) into logical units
            Point trackMaxSizeLogicalUnits = DeviceToLogicalUnits(new Point(_trackMaxWidthDeviceUnits, _trackMaxHeightDeviceUnits)); 
            Point trackMinSizeLogicalUnits = DeviceToLogicalUnits(new Point(_trackMinWidthDeviceUnits, _trackMinHeightDeviceUnits));

            //
            // Get the final Min/Max Width 
            //
            mm.minWidth = Math.Max(this.MinWidth, trackMinSizeLogicalUnits.X); 
 
            // Min's precedence is higher than Max; If Min is greater than Max, use Min.
            if (MinWidth > MaxWidth) 
            {
                mm.maxWidth = Math.Min(MinWidth, trackMaxSizeLogicalUnits.X);
            }
            else 
            {
                if (!Double.IsPositiveInfinity(MaxWidth)) 
                { 
                    mm.maxWidth = Math.Min(MaxWidth, trackMaxSizeLogicalUnits.X);
                } 
                else
                {
                    mm.maxWidth = trackMaxSizeLogicalUnits.X;
                } 
            }
 
            // 
            // Get the final Min/Max Height
            // 
            mm.minHeight = Math.Max(this.MinHeight, trackMinSizeLogicalUnits.Y);

            // Min's precedence is higher than Max; If Min is greater than Max, use Min.
            if (MinHeight > MaxHeight) 
            {
                mm.maxHeight = Math.Min(this.MinHeight, trackMaxSizeLogicalUnits.Y); 
            } 
            else
            { 
                if (!Double.IsPositiveInfinity(MaxHeight))
                {
                    mm.maxHeight = Math.Min(MaxHeight, trackMaxSizeLogicalUnits.Y);
                } 
                else
                { 
                    mm.maxHeight = trackMaxSizeLogicalUnits.Y; 
                }
            } 

            return mm;
        }
 
        private void LoadedHandler(object sender, RoutedEventArgs e)
        { 
            if (_postContentRenderedFromLoadedHandler == true) 
            {
                PostContentRendered(); 
                _postContentRenderedFromLoadedHandler = false;
                this.Loaded -= new RoutedEventHandler(LoadedHandler);
            }
        } 

        ///  Keep this method in [....] with Frame.PostContentRendered().  
        private void PostContentRendered() 
        {
            // Post the firing of ContentRendered as Input priority work item so 
            // that ContentRendered will be fired after render query empties.
            if (_contentRenderedCallback != null)
            {
                // Content was changed again before the previous rendering completed (or at least 
                // before the Dispatcher got to Input priority callbacks).
                _contentRenderedCallback.Abort(); 
            } 
            _contentRenderedCallback = Dispatcher.BeginInvoke(DispatcherPriority.Input,
                                   (DispatcherOperationCallback) delegate (object unused) 
                                   {
                                       // Event handler exception continuality: there are no state related/depending on ContentRendered event.
                                       // If an exception occurs in event handler, our state will not be corrupted.
                                       // Please check event handler exception continuality if the logic changes. 
                                       _contentRenderedCallback = null;
                                       OnContentRendered(EventArgs.Empty); 
                                       return null; 
                                   },
                                   this); 
        }

        /// 
        /// Ensure Dialog command is registered with the CommandManager 
        /// 
        private void EnsureDialogCommand() 
        { 
            // _dialogCommandAdded is a static variable, however, we're not synchronizing
            // access to it.  The reason is that, CommandManager is thread safe and according 
            // to KiranKu we don't want to take the overhead of locking here.  For multiple
            // threaded cases, we could end up calling the CommandManager more than once but
            // KiranKu is okay with that perf hit in the corner case.
            if (!_dialogCommandAdded) 
            {
                // Right now we only have DialogCancel Command, which closes window if it's dialog and return false as the dialog's result. 
                CommandBinding binding = new CommandBinding(DialogCancelCommand); 
                binding.Executed += new ExecutedRoutedEventHandler(OnDialogCommand);
                CommandManager.RegisterClassCommandBinding(typeof(Window), binding); 

                _dialogCommandAdded = true;
            }
        } 

        ///  
        /// Dialog Command Execute handler 
        /// Right now we only have DialogCancel Command, which closes window if it's dialog and return false for DialogResult.
        ///  
        /// 
        /// 
        private static void OnDialogCommand(object target, ExecutedRoutedEventArgs e)
        { 
            //close dialog & return result
            Window w = target as Window; 
 
            Debug.Assert(w != null, "Target must be of type Window.");
            w.OnDialogCancelCommand(); 
        }

        /// 
        /// Close window if it's dialog and return false for DialogResult. 
        /// 
        private void OnDialogCancelCommand() 
        { 
            if (_showingAsDialog)
            { 
                DialogResult = false;
            }
        }
 
        /// 
        /// The callback function for EnumThreadWindows 
        ///  
        /// 
        ///  
        /// 
        private bool ThreadWindowsCallback(IntPtr hWnd, IntPtr lparam)
        {
            Debug.Assert(_threadWindowHandles != null, "_threadWindowHandles must not be null at this point"); 

            // the dialog's hwnd has not been created yet when calling into this function. 
            // so its hwnd won't be in the list. 

            // We only do visible && enabled windows. 
            // We need to check Visible because there might be hidden windows that do message looping,
            // We don't want to disable them.
            if (SafeNativeMethods.IsWindowVisible(new HandleRef(null, hWnd)) &&
                SafeNativeMethods.IsWindowEnabled(new HandleRef(null, hWnd))) 
            {
                _threadWindowHandles.Add(hWnd); 
            } 

            return true; 
        }

        /// 
        /// Enables/disables all Windows on this thread 
        /// 
        ///  
        ///  
        ///     Critical: This code calls into IsWindow and EnableWindow
        ///  
        [SecurityCritical]
        private void EnableThreadWindows(bool state)
        {
 
            Debug.Assert(_threadWindowHandles != null, "_threadWindowHandles must not be null at this point");
 
            for (int i = 0; i < _threadWindowHandles.Count; i++) 
            {
                IntPtr hWnd = (IntPtr)_threadWindowHandles[i]; 

                if (UnsafeNativeMethods.IsWindow(new HandleRef(null, hWnd)))
                {
                    // Calls EnableWindow which returns the previous Window state 
                    // (enable/disable) and we don't care about that here
#pragma warning disable 6523 
                    UnsafeNativeMethods.EnableWindowNoThrow(new HandleRef(null, hWnd), state); 
#pragma warning enable 6523
 
                }
            }

            // EnableThreadWindows is called with true only when dialog is going away.  Now 
            // we've enabled the windows that we had earlier disabled; thus, disposing
            // _threadWindowHandles. 
            if (state == true) 
            {
                _threadWindowHandles = null; 
            }
        }

        ///  
        /// Intialization when Window is constructed
        ///  
        ///     Initializes the Width/Height, Top/Left properties to use windows 
        ///     default. Updates Application object properties if inside app.
        /// 
        ///     Also, window style is set to WS_CHILD inside CreateSourceWindow
        ///     for browser hosted case
        private void Initialize()
        { 
            // AVTempUIPermission avtUIPermission = new AVTempUIPermission(AVTUIPermissionNewWindow.LaunchNewWindows);
            // CASRemoval:avtUIPermission.Demand(); 
 
            //  this makes MeasureCore / ArrangeCore to defer to direct MeasureOverride and ArrangeOverride calls
            //  without reading Width / Height properties and modifying input constraint size parameter... 
            BypassLayoutPolicies = true;

            // check if within an app && on the same thread
            if (IsInsideApp == true) 
            {
                if (Application.Current.Dispatcher.Thread == Dispatcher.CurrentDispatcher.Thread) 
                { 
                    // add to window collection
                    // use internal version since we want to update the underlying collection 
                    App.WindowsInternal.Add(this);
                    if (App.MainWindow == null)
                    {
                        App.MainWindow = this; 
                    }
                } 
                else 
                {
                    App.NonAppWindowsInternal.Add(this); 
                }
            }
        }
 

        internal void VerifyContextAndObjectState() 
        { 
            // Verify that we are executing on the right context
            VerifyAccess(); 

        //

 
#if DISPOSE
            if (_disposed) 
            { 
                throw new ObjectDisposedException(null, SR.Get(SRID.WindowDisposed));
            } 
#endif
        }

        private void VerifyCanShow() 
        {
            if (_disposed == true) 
            { 
                throw new InvalidOperationException(SR.Get(SRID.ReshowNotAllowed));
            } 
        }

        private void VerifyNotClosing()
        { 
            if (_isClosing == true)
            { 
                throw new InvalidOperationException(SR.Get(SRID.InvalidOperationDuringClosing)); 
            }
 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == true)
            {
                throw new InvalidOperationException(SR.Get(SRID.InvalidCompositionTarget));
            } 
        }
 
        ///  
        ///     sets the IWindowService attached property
        ///  
        private void SetIWindowService()
        {
            if (GetValue(IWindowServiceProperty) == null)
            { 
                SetValue(IWindowServiceProperty, (IWindowService)this);
            } 
        } 

        /// 
        ///     Critical - calls a method that elevates - GetCursorPos
        ///     TreatAsSafe - as there's a demand.
        ///
        [SecurityCritical, SecurityTreatAsSafe] 
        IntPtr GetCurrentMonitorFromMousePosition()
        { 
            SecurityHelper.DemandUnmanagedCode(); 
            // center on the screen on which the mouse is on
            NativeMethods.POINT pt = new NativeMethods.POINT(); 

            UnsafeNativeMethods.TryGetCursorPos(pt);

            NativeMethods.POINTSTRUCT ptStruct = new NativeMethods.POINTSTRUCT(pt.x, pt.y); 
            return SafeNativeMethods.MonitorFromPoint(ptStruct, NativeMethods.MONITOR_DEFAULTTONEAREST);
        } 
 
        // 
        //     Calculates the window location based on the WindowStartupLocation property 
        //     If values for CenterScreen, CenterOwner cannot be determined, then we return
        //     unmodified values.
        // 
        //  
        //     This method can be called before or after the hwnd is created.  So, we have
        //     to accout for both scenarios. 
        //  
        // 
        //  
        // 
        /// 
        ///     Critical: This code accesses handle and calls critical method GetNormalRectDeviceUnits
        ///     TreatAsSafe: This data is ok to give out 
        /// 
        [SecurityCritical,SecurityTreatAsSafe] 
        private bool CalculateWindowLocation(ref double leftDeviceUnits, ref double topDeviceUnits, Size currentSizeDeviceUnits) 
        {
            Debug.Assert(IsSourceWindowNull == false, "_swh should not be null here"); 
            double inLeft = leftDeviceUnits;
            double inTop = topDeviceUnits;

            switch (_windowStartupLocation) 
            {
                case WindowStartupLocation.Manual: 
                    break; 
                case WindowStartupLocation.CenterScreen:
                    // NOTE: hamidm 05/19/04 
                    // Bug (Windows OS Bugs) # 843790 -- Which screen to center the
                    // window on?
                    //
                    // If Window has a parent handle, then center the Window on the 
                    // same monitor as the parent hwnd.  If theres no parent hwnd,
                    // center the Window on the monitor where the mouse is currently 
                    // on. 
                    //
                    // The exception to this rule is when ShowInTaskbar is set to false 
                    // and we parent to window to achieve that.  That's the reason for
                    // having the extra condition in the if statement below
                    //
 
                    IntPtr hMonitor = IntPtr.Zero;
                    if ((_ownerHandle == IntPtr.Zero) || 
                        ((_hiddenWindow != null) && (_hiddenWindow.Handle == _ownerHandle))) 
                    {
                        hMonitor = GetCurrentMonitorFromMousePosition(); 
                    }
                    else
                    {
                        // have a parent hwnd; center on the screen on 
                        // which our parent hwnd is.
                        hMonitor = SafeNativeMethods.MonitorFromWindow(new HandleRef(this, _ownerHandle), NativeMethods.MONITOR_DEFAULTTONEAREST); 
                    } 

                    if (hMonitor != IntPtr.Zero) 
                    {
                        CalculateCenterScreenPosition(new HandleRef(this, hMonitor), currentSizeDeviceUnits, ref leftDeviceUnits, ref topDeviceUnits);
                    }
                    break; 
                case WindowStartupLocation.CenterOwner:
                    Rect ownerRectDeviceUnits = Rect.Empty; 
 
                    // If the owner is WPF window. The owner can be non-WPF window. It can be set via WindowInteropHelper.Owner.
                    if (CanCenterOverWPFOwner == true) 
                    {
                        // if owner hwnd is created, we use ActualWidth/Height to get its size
                        // otherwise we use Width/Height
                        double ownerWidthLogicalUnits = (Owner.CriticalHandle == IntPtr.Zero ? Owner.Width : Owner.ActualWidth); 
                        double ownerHeightLogicalUnits = (Owner.CriticalHandle == IntPtr.Zero ? Owner.Height : Owner.ActualHeight);
 
                        Point ownerSizeDeviceUnits = Owner.LogicalToDeviceUnits(new Point(ownerWidthLogicalUnits, ownerHeightLogicalUnits)); 
                        // A minimized window doesn't have valid Top,Left; that's why RestoreBounds.TopLeft is used.
                        Point ownerLocationDeviceUnits = Owner.LogicalToDeviceUnits( 
                            Owner.WindowState == WindowState.Minimized ?
                                Owner.RestoreBounds.TopLeft : new Point(Owner.Left, Owner.Top));

                        ownerRectDeviceUnits = new Rect(ownerLocationDeviceUnits.X, ownerLocationDeviceUnits.Y, 
                                            ownerSizeDeviceUnits.X, ownerSizeDeviceUnits.Y);
                    } 
                    else 
                    {
                        // non-WPF owner 
                        if ((_ownerHandle != IntPtr.Zero) && UnsafeNativeMethods.IsWindow(new HandleRef(null, _ownerHandle)))
                        {
                            ownerRectDeviceUnits = GetNormalRectDeviceUnits(_ownerHandle);
                        } 
                    }
 
                    if (! ownerRectDeviceUnits.IsEmpty) 
                    {
                        leftDeviceUnits = ownerRectDeviceUnits.X + ((ownerRectDeviceUnits.Width - currentSizeDeviceUnits.Width) / 2); 
                        topDeviceUnits = ownerRectDeviceUnits.Y + ((ownerRectDeviceUnits.Height - currentSizeDeviceUnits.Height) / 2);
                    }
                    break;
                default: 
                    break;
            } 
            return (!DoubleUtil.AreClose(inLeft, leftDeviceUnits) || !DoubleUtil.AreClose(inTop, topDeviceUnits)); 
        }
 

        /// 
        /// Calculates the left and right coordinates of a window
        /// when centered on a given monitor. 
        /// 
        /// Handle to the monitor to center the window on 
        /// Size of the window, in device units 
        /// Receives the new left location in device units
        /// Receives the new top location in device units 
        internal static void CalculateCenterScreenPosition(HandleRef hMonitor, Size currentSizeDeviceUnits, ref double leftDeviceUnits, ref double topDeviceUnits)
        {
            NativeMethods.MONITORINFOEX monitorInfo = new NativeMethods.MONITORINFOEX();
            monitorInfo.cbSize = SecurityHelper.SizeOf(typeof(NativeMethods.MONITORINFOEX)); 

            SafeNativeMethods.GetMonitorInfo(hMonitor, monitorInfo); 
            NativeMethods.RECT workAreaRectDeviceUnits = monitorInfo.rcWork; 

            // We're using Width/Height here as opposed to ActualWidth/Height 
            // as layout hasn't happened yet.
            double workAreaWidthDeviceUnits = workAreaRectDeviceUnits.right - workAreaRectDeviceUnits.left;
            double workAreaHeightDeviceUnits = workAreaRectDeviceUnits.bottom - workAreaRectDeviceUnits.top;
 
            Debug.Assert(workAreaWidthDeviceUnits >= 0, String.Format("workAreaWidth ({0})for monitor ({1}) is negative", hMonitor, workAreaWidthDeviceUnits));
            Debug.Assert(workAreaHeightDeviceUnits >= 0, String.Format("workAreaHeight ({0}) for monitor ({1}) is negative", hMonitor, workAreaHeightDeviceUnits)); 
 
            leftDeviceUnits = (workAreaRectDeviceUnits.left + ((workAreaWidthDeviceUnits - currentSizeDeviceUnits.Width) / 2));
            topDeviceUnits = (workAreaRectDeviceUnits.top + ((workAreaHeightDeviceUnits - currentSizeDeviceUnits.Height) / 2)); 
        }

        private bool CanCenterOverWPFOwner
        { 
            get
            { 
                Debug.Assert(IsSourceWindowNull == false, "_swh should not be null here"); 

                // if Owner is null, we cannot CenterOwner 
                if (Owner == null)
                {
                    return false;
                } 

                // if Owner._sourceWindow is null, and if Owner's Width or Height is not specified 
                // then we cannot CenterOwner 
                if (Owner.IsSourceWindowNull)
                { 
                    if ((DoubleUtil.IsNaN(Owner.Width)) ||
                        (DoubleUtil.IsNaN(Owner.Height)))
                    {
                        return false; 
                    }
                } 
 
                // if Owner's Top or Left is not specified, we cannot CenterOwner
                if ((DoubleUtil.IsNaN(Owner.Left)) || 
                    (DoubleUtil.IsNaN(Owner.Top)))
                {
                    return false;
                } 
                return true;
            } 
        } 

        /// 
        ///     Critical - calls a method that elevates - GetWindowLong, GetWindowPlacement
        ///
        [SecurityCritical]
        private Rect GetNormalRectDeviceUnits(IntPtr hwndHandle) 
        {
            int styleEx = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, hwndHandle), NativeMethods.GWL_EXSTYLE); 
 
            NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT();
            wp.length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT)); 
            UnsafeNativeMethods.GetWindowPlacement(new HandleRef(this, hwndHandle), ref wp);
            Point locationDeviceUnits = new Point(wp.rcNormalPosition_left, wp.rcNormalPosition_top);

            // GetWindowPlacement returns workarea co-ods for a top level window whose 
            // WS_EX_TOOLWINDOW bit is clear.  If this bit is set, then the co-ods
            // returned are relative to the screen co-ods of the monitor. 
            // TransfromWorkAreaScreenArea can transform a point from work area co-ods 
            // to screen area co-ods and vice versa depending on TransformType value passed.
            // So, in our case, if the window is not a ToolWindow we want to transform 
            // the point from work area co-ods to screen co-ods.
            if ((styleEx & NativeMethods.WS_EX_TOOLWINDOW) == 0)
            {
                locationDeviceUnits = TransformWorkAreaScreenArea(locationDeviceUnits, TransformType.WorkAreaToScreenArea); 
            }
 
            Point sizeDeviceUnits = new Point(wp.rcNormalPosition_right - wp.rcNormalPosition_left, 
                                              wp.rcNormalPosition_bottom - wp.rcNormalPosition_top);
 
            return new Rect(locationDeviceUnits.X, locationDeviceUnits.Y, sizeDeviceUnits.X, sizeDeviceUnits.Y);
        }

        /// 
        ///     Critical - calls critical method GetNormalRectDeviceUnits
        /// 
        [SecurityCritical] 
        private Rect GetNormalRectLogicalUnits(IntPtr hwndHandle)
        { 
            Rect rectDeviceUnits = GetNormalRectDeviceUnits(hwndHandle);

            Point sizeLogicalUnits = DeviceToLogicalUnits(new Point(rectDeviceUnits.Width, rectDeviceUnits.Height));
            Point locationLogicalUnits = DeviceToLogicalUnits(new Point(rectDeviceUnits.X, rectDeviceUnits.Y)); 

            return new Rect(locationLogicalUnits.X, locationLogicalUnits.Y, sizeLogicalUnits.X, sizeLogicalUnits.Y); 
        } 

        ///  
        ///     Update style bits for window state
        /// 
        private void CreateWindowState()
        { 
            switch (WindowState)
            { 
                case WindowState.Normal: 
                    break;
                case WindowState.Maximized: 
                    _Style |= NativeMethods.WS_MAXIMIZE;
                    break;
                case WindowState.Minimized:
                    _Style |= NativeMethods.WS_MINIMIZE; 
                    break;
#if THEATRE_FULLSCREEN 
                case WindowState.Theatre: 
                    throw new NotImplementedException(SR.Get(SRID.NotImplementedException));
 
                case WindowState.FullScreen:
                    throw new NotImplementedException(SR.Get(SRID.NotImplementedException));
#endif //THEATRE_FULLSCREEN
            } 
        }
 
        ///  
        ///     creates topmost window
        ///  
        private void CreateTopmost()
        {
            // check for topmost
            if ( Topmost ) 
            {
                _StyleEx |= NativeMethods.WS_EX_TOPMOST; 
            } 
            else
            { 
                _StyleEx &= ~NativeMethods.WS_EX_TOPMOST;
            }
        }
 
        /// 
        ///     set's resizibility for the window 
        ///  
        private void CreateResizibility()
        { 
            _Style &= ~(NativeMethods.WS_THICKFRAME | NativeMethods.WS_MAXIMIZEBOX | NativeMethods.WS_MINIMIZEBOX);


            switch(ResizeMode) 
            {
                case ResizeMode.NoResize: 
                    break; 
                case ResizeMode.CanMinimize:
                    _Style |= NativeMethods.WS_MINIMIZEBOX; 
                    break;
                case ResizeMode.CanResize:
                case ResizeMode.CanResizeWithGrip:
                    _Style |= NativeMethods.WS_THICKFRAME | NativeMethods.WS_MAXIMIZEBOX | NativeMethods.WS_MINIMIZEBOX; 
                    break;
                default: 
                    Debug.Assert(false, "Invalid value for ResizeMode"); 
                    break;
            } 
        }

        /// 
        ///     Updates the window icon 
        /// 
        /// 
        /// Critical as we perform an elevation - ( UnsafeNativeMethods.SendMessage) will have a SUC on it soon. 
        /// TreatAsSafe: This method ok to use on window and does nothing on RBW.
        /// 
        //

        [SecurityCritical, SecurityTreatAsSafe]
        private void UpdateIcon() 
        {
 
            // NOTE: hamidm -- bug 963275 AppModel: Set Window.Icon = null 
            // causes NullReferenceException
 
            // if _icon is null, set _defaultLargeIconHandle and _defaultSmallIconHandle
            //  to the app icon (embedded in the exe).  _icon is used as window icon if it
            // is not null, else default icons from exe are used.  If both are null,
            // we set IntPtr.Zero as the icons for the window and Win32 defaults 
            // come into play.
            // 
 
            NativeMethods.IconHandle largeIconHandle = new NativeMethods.IconHandle();
            NativeMethods.IconHandle smallIconHandle = new NativeMethods.IconHandle(); 


            if (_icon != null)
            { 
                IconHelper.GetIconHandlesFromBitmapFrame(this, _icon, ref largeIconHandle, ref smallIconHandle);
            } 
            else 
            {
                // these both should be null before we've queried that exe for icons. 
                // Once, we looked in the exe, these are no longer null and hence we
                // don't want to re-query in the exe anymore
                if (_defaultLargeIconHandle == null && _defaultSmallIconHandle == null)
                { 
                     // sets the default small and large icon handles
                     IconHelper.GetDefaultIconHandles(this, ref largeIconHandle, ref smallIconHandle); 
                    _defaultLargeIconHandle = largeIconHandle; 
                    _defaultSmallIconHandle = smallIconHandle;
                } 
                else
                {
                    largeIconHandle = _defaultLargeIconHandle;
                    smallIconHandle = _defaultSmallIconHandle; 
                }
                // get default icons 
            } 

 
            UnsafeNativeMethods.SendMessage(
                                    new HandleRef(this, CriticalHandle),
                                    NativeMethods.WM_SETICON,
                                    (IntPtr)NativeMethods.ICON_BIG, 
                                    largeIconHandle);
 
            UnsafeNativeMethods.SendMessage( 
                                    new HandleRef(this, CriticalHandle),
                                    NativeMethods.WM_SETICON, 
                                    (IntPtr)NativeMethods.ICON_SMALL,
                                    smallIconHandle);

            // dispose the previous icon handle if it's not the default handle 
            if (_currentLargeIconHandle != null && _currentLargeIconHandle != _defaultLargeIconHandle)
            { 
                _currentLargeIconHandle.Dispose(); 
            }
 
            if (_currentSmallIconHandle != null && _currentSmallIconHandle != _defaultSmallIconHandle)
            {
                _currentSmallIconHandle.Dispose();
            } 

            _currentLargeIconHandle = largeIconHandle; 
            _currentSmallIconHandle = smallIconHandle; 
        }
 
        /// 
        ///     Sets the parent hwnd for this window. This could be called as a result of
        ///     setting one of the following
        /// 
        ///         Window Owner {set;}
        ///         IntPtr OwnerHandle {set;}  -- this is used by WindowInteropHelper 
        ///  
        /// IntPtr of the parent window
        /// 
        /// Critical - sets _ownerHandle to the value got as a param
        ///
        [SecurityCritical]
        private void SetParentHandle(IntPtr parentHandle) 
        {
            // Note: hamidm 9/1/2005 
            // 1278098 "SetWindowLong failed.  Error = 1400" appears in console when setting 
            // Window.Owner to a Window hasn't been shown (chk build)
            // 
            // SetWindowLong with GWL_HWNDPARENT fails if the new parent/owner is IntPtr.Zero
            // and the old owner was also IntPtr.Zero.  The if check below works around this
            // issue.
 
            if (_ownerHandle == parentHandle)
            { 
                return; 
            }
 
            _ownerHandle = parentHandle;

            if ( IsSourceWindowNull == false)
            { 

                UnsafeNativeMethods.SetWindowLong(new HandleRef(null, CriticalHandle), 
                    NativeMethods.GWL_HWNDPARENT, 
                    _ownerHandle);
 
                // Update and reset the Owner Window if this is set through WindowInteropHelper.
                // We want to do this because once we are passed in the IntPtr for
                // the parent window, the Owner window is not the parent anymore.
 
                if ( (_ownerWindow != null) && (_ownerWindow.CriticalHandle != _ownerHandle) )
                { 
                    _ownerWindow.OwnedWindowsInternal.Remove(this); 
                    _ownerWindow = null;
                } 
            }
        }

        ///  
        ///     This is called back into when HwndSouce being used by this object is disposed, or if the
        ///     hwnd is destroyed. 
        /// 
        ///     When that happens on the same thread, we receive WM_CLOSE, WM_DESTROY and
        ///     everything works fine.  However, if that happened on another thread, we don't get 
        ///     WM_CLOSE, WM_DESTROY until later, but we get this disposed callback and we
        ///     set dispose this object.  If we don't do this, there could be timing related issues if
        ///     we get called into after the HwndSource or hwnd has been disposed/destoyed but before
        ///     we receive WM_CLOSE, WM_DESTROY messages. 
        /// 
        ///  
        ///  
        /// 
        /// 
        ///     Critical: Is used to dispose of the native handles which link demands in safe handle via the call to
        ///     InternalDispose
        ///
        [SecurityCritical] 
        private void OnSourceWindowDisposed(object sender, EventArgs e)
        { 
            if ( _disposed == false) 
            {
                InternalDispose(); 
            }
        }

        ///  
        ///     This is the hook to HwndSource that is called when window messages related to
        ///     this window occur. Currently, we listen to the following messages 
        /// 
        ///         WM_CLOSE        : We listen to this message in order to fire the Closing event.
        ///                           If the user cancels window closing, we set handled to true so 
        ///                           that the DefWindowProc does not handle this message. Otherwise,
        ///                           we set handled to false.
        ///         WM_DESTROY      : We listen to this message in order to fire the Closed event.
        ///                           Handled is always set to false. 
        ///         WM_ACTIVATE     : Used for Activated and deactivated events
        ///         WM_SIZE         : Used for SizeChanged, StateChanged events. Also, helps us keep our 
        ///                           size updated 
        ///         WM_MOVE:        : Used for location changed event and to keep our cached top/left
        ///                           updated 
        ///         WM_GETMINMAXINFO: Used to enforce Max/MinHeight and Max/MinWidth
        /// 
        /// 
        ///  
        /// 
        ///  
        ///  
        /// 
        /// 
        ///     Critical: Calls critical code: Window.WmClose()
        ///
        [SecurityCritical]
        private IntPtr WindowFilterMessage( IntPtr hwnd, 
            int msg,
            IntPtr wParam, 
            IntPtr lParam, 
            ref bool handled)
        { 
            IntPtr retInt = IntPtr.Zero ;

            // hamidm - 10/27/2005
            // we need to process WM_GETMINMAXINFO before _swh is assigned to 
            // b/c we want to store the max/min size allowed by win32 for the hwnd
            // which is later used in GetWindowMinMax.  WmGetMinMaxInfo can handle 
            // _swh == null case. 
            switch (msg)
            { 
                case NativeMethods.WM_GETMINMAXINFO:
                    handled = WmGetMinMaxInfo(lParam);
                    break;
                case NativeMethods.WM_SIZE: 
                    handled = WmSizeChanged(wParam, lParam);
                    break; 
            } 

            if(_swh != null && _swh.CompositionTarget != null) // For extraneous messages during shutdown 
            {
                switch (msg)
                {
                    case NativeMethods.WM_CLOSE: 
                        handled = WmClose();
                        break; 
                    case NativeMethods.WM_DESTROY: 
                        handled = WmDestroy();
                        break; 
                    case NativeMethods.WM_ACTIVATE:
                        handled = WmActivate(wParam);
                        break;
                    case NativeMethods.WM_ENTERSIZEMOVE: 
                        // If we are here, it means user is resizing.
                        // We do want to set Top&Left Width&Height local values when user resizes. 
                        // We don't get this message when user maximizes or minimizes. 
                        // We don't set local values when user maximizes or minimized.
                        _inUserSizeMove = true; 
                        _userResized = true;
                        handled = false;
                        break;
                    case NativeMethods.WM_EXITSIZEMOVE: 
                        // User resizing over.
                        _inUserSizeMove = false; 
                        handled = false; 
                        break;
                    case NativeMethods.WM_MOVE: 
                        handled = WmMoveChanged(hwnd, lParam);
                        break;
                    case NativeMethods.WM_NCHITTEST:
                        handled = WmNcHitTest(lParam, ref retInt); 
                        break;
                    case NativeMethods.WM_SHOWWINDOW: 
                        handled = WmShowWindow(wParam, lParam); 
                        break;
                    default: 
                        handled = false;
                        break;
                }
            } 

            return retInt; 
        } 

        ///  
        ///     Called on WM_CLOSE message. Fires the Closing event.
        /// 
        /// 
        ///     True if we want to stop the window from closing, else false 
        /// 
        private bool WmClose() 
        { 
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called
            // synchronously from CreateWindowEx call and we run into issues if 
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want
            // to explicitly add the null check below at all other places.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            { 
                return false;
            } 

            // if DialogResult is set from within a Closing event then
            // the window is in the closing state.  In such a case, we
            // should not call Close() from DialogResult.set and thus 
            // we have this variable.
            // 
            // Note: Windows OS bug # 934500 Setting DialogResult 
            // on the Closing EventHandler of a Dialog causes StackOverFlowException
            _isClosing = true; 

            // Event handler exception continuality: if exception occurs in Closing event handler, the
            // cleanup action is to finish closing.
            CancelEventArgs e = new CancelEventArgs(false); 
            try
            { 
                OnClosing(e); 
            }
            catch 
            {
                CloseWindowFromWmClose();
                throw;
            } 

            if (ShouldCloseWindow(e.Cancel)) 
            { 
                CloseWindowFromWmClose();
                return false; 
            }
            else
            {
                // close cancelled 
                _isClosing = false;
 
                // 03/14/2006 -- hamidm 
                // WOSB 1560557 Dialog does not close with ESC key after it has been cancelled
                // 
                // Since closing is cancelled, DialogResult should be reset to null b/c
                // 1) DialogResult = true/false means that dialog has been accepeted/rejected (since dialog didn't
                //                   close (closing cancelled), DialogResult should be null)
                _dialogResult = null; 

                return true; 
            } 
        }
 
        private void CloseWindowFromWmClose()
        {
            if (_showingAsDialog)
            { 
                DoDialogHide();
            } 
 
            // We should ClearRootVisual here instead of in InternalDispose. InternalDispose is called either as a result of HwndSource
            // disposing itself or it will try to dispose HwndSource. HwndSource will clear the root visual when it is disposed. 
            ClearRootVisual();

            // We should also ClearHiddenWindow here, because in InternalDispose the window handle could be null if the dispose happens as
            // a result of HwndSource dispose. Our InternalDispose has been changed to handle reantrance, so the issue (bug 953988) described in 
            // ClearHiddenWindowIfAny should not happen any more.
            ClearHiddenWindowIfAny(); 
        } 

        private bool ShouldCloseWindow(bool cancelled) 
        {
            // if shutdown Closing cannot be cancelled
            // if parent window is closing, child window Closing cannot be cancelled.
            return ((!cancelled) || (_appShuttingDown) || (_ignoreCancel)); 
        }
 
        ///  
        /// Critical - This code calls EnableThreadWindows and accesses _dialogPreviousActiveHandle
        /// TreatAsSafe - There is a demand for unmanaged code 
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        private void DoDialogHide()
        { 
            SecurityHelper.DemandUnmanagedCode();
 
            Debug.Assert(_showingAsDialog == true, "_showingAsDialog must be true when DoDialogHide is called"); 

            bool wasActive = false; 

            //It's possible that _dispatcherFrame could be null at this time.
            //The scenario is: When showing the window as a modal dialog, the window Activated event is fired
            //before _dispatcherFrame is instantiated. In the Activated handler, if user closes the 
            //window (setting DialogResult fires the WM_CLOSE event), the _dispatcherFrame is still null.
            //Bug 874463 addressed this. 
            if (_dispatcherFrame != null) 
            {
                // un block the push frame call 
                _dispatcherFrame.Continue = false;
                _dispatcherFrame = null;
            }
 
            // 03/03/2006 -- hamidm
            // Fix for 1388606 Close Dialog Window should not return null 
            // 
            // The consensus here is that DialogResult should never be null when ShowDialog returns
            // As such, we coerce it to be false.  Furthermore, we don't use the DialogResult property 
            // to update _dialogResult here since that does more than just updating the underlying
            // variable
            if (_dialogResult == null)
            { 
                _dialogResult = false;
            } 
 
            // clears _showingAsDialog
            _showingAsDialog = false; 

            // enable previous window stuff goes here...
            wasActive = _swh.IsActiveWindow;
 
            // NOTE: hamidm -- 01/22/04
            // We assert here b/c I think _threadWindowHandles should never be null when we get 
            // called in here. 
            //
            // However, if inside ShowDialog we hit an exception after showing the dialog and the 
            // exception handler is run, then _threadWindowHandles will be null here.
            //
            // Keeping this as assert.  If this turn out to be an over active assert, we'll switch to
            // an if condition. 
            Debug.Assert(_threadWindowHandles != null, "_threadWindowHandles must not be null at this point");
            // reenable windows in the thread that were disabled 
            EnableThreadWindows(true); 

            // if dialog that is closing was active window and there was a previously active window, 
            // set the active window.  The owner window may not be the previously active window. See DevDiv bug 122467 for details.
            // Furthermore, verify that _dialogPreviousActiveHandle is still a window b/c it
            // could have been destroyed by now by some other thread/codepath etc.
            // WOSB 1098573 (BVT BLOCKER: System.ComponentModel.Win32Exception thrown when 
            // trying to shutdown app inside a Dialog Window)
            if ((wasActive == true) && 
                (_dialogPreviousActiveHandle != IntPtr.Zero) && 
                (UnsafeNativeMethods.IsWindow(new HandleRef(this, _dialogPreviousActiveHandle)) == true))
            { 
                UnsafeNativeMethods.SetActiveWindow(new HandleRef(this, _dialogPreviousActiveHandle));
            }
            else
            { 
                //
 
 

                // rare situation, figure this out later 
                // talk to user team as to what we need to do here
            }
        }
 
        ///
        ///     Critical: Calls critical code: Window.InternalClose and Application.CriticalShutdown 
        /// 
        [SecurityCritical]
        private void UpdateWindowListsOnClose() 
        {
            // Close all owned windows
            // use internal version since we want to update the underlying collection
            WindowCollection ownedWindows = OwnedWindowsInternal; 

            // 
 

 
            while (ownedWindows.Count > 0)
            {
                // if parent window is closing, child window Closing cannot be cancelled.
                ownedWindows[0].InternalClose(false, true /* Ignore cancel */); 
            }
 
            Debug.Assert(ownedWindows.Count == 0, "All owned windows should now be gone"); 

            // Update OwnerWindows of our Owner 
            if (IsOwnerNull == false)
            {
                // use internal version since we want to update the underlying collection
                Owner.OwnedWindowsInternal.Remove(this); 
            }
 
            if (this.IsInsideApp) 
            {
                if (Application.Current.Dispatcher.Thread == Dispatcher.CurrentDispatcher.Thread) 
                {
                    // use internal version since we want to update the underlying collection
                    App.WindowsInternal.Remove(this);
 
                    // Check to see if app should shut down--this behavior really belongs in Application
                    if (_appShuttingDown == false) 
                    { 
                        // If this is the last window that's closing and shutdownmode is onlastwindowclose, or
                        // if this is the main window closing and shutdownmode is onmainwindowclose, shutdown 
                        // the app
                        if (((App.Windows.Count == 0) && (App.ShutdownMode == ShutdownMode.OnLastWindowClose))
                         || ((App.MainWindow == this) && (App.ShutdownMode == ShutdownMode.OnMainWindowClose)))
                        { 
                            App.CriticalShutdown(0);
                        } 
                    } 

                    TryClearingMainWindow(); 
                }
                else
                {
                    App.NonAppWindowsInternal.Remove(this); 
                }
            } 
 
        }
        /// 
        ///     Critical: This can be used to dispose a window which is a secure resource
        ///
        [SecurityCritical]
        private bool  WmDestroy() 
        {
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called 
            // synchronously from CreateWindowEx call and we run into issues if 
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want 
            // to explicitly add the null check below at all other places.
            if (IsSourceWindowNull)
            {
                return false; 
            }
 
            if (_disposed == false) 
            {
                InternalDispose(); 
            }

            // hamidm - WOSB 1453012 STRESS: System.NullReferenceException @ System.Windows.Window.DeviceToLogicalUnits
            // 
            // We're intentionally not adding a check for IsCompositionTargetInvlaid here since we
            // feel that it is okay to fire the Closed event to notify the developer that window has 
            // closed. 

            // Event handler exception continuality: if exception occurs in Closed event handler, the 
            // cleanup action is to finish closing.
            // raise Closed event
            OnClosed(EventArgs.Empty);
 
            return false;
        } 
 
        private bool WmActivate( IntPtr wParam )
        { 
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called
            // synchronously from CreateWindowEx call and we run into issues if
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want 
            // to explicitly add the null check below at all other places.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            { 
                return false;
            }

            int loWord = NativeMethods.SignedLOWORD(wParam); 
            bool windowActivated;
 
 
            if ( loWord == NativeMethods.WA_INACTIVE )
            { 
                windowActivated = false;
            }
            else
            { 
                windowActivated = true;
            } 
 
            HandleActivate(windowActivated);
 
            return false;
        }

        private void AdjustWindowRectEx(ref NativeMethods.RECT rc) 
        {
            // HwndSource expands the client area to cover the entire window when it is in UsesPerPixelOpacity mode, 
            // So there is no need to adjust window rect. 
            if (! AllowsTransparency)
            { 
                SafeNativeMethods.AdjustWindowRectEx(ref rc, _Style, false, _StyleEx);
            }
        }
 
        private bool WmSizeChanged( IntPtr wParam, IntPtr lParam )
        { 
            // hamidm 11/07/2005 
            // 1378397  HOT: Window Width and Height overrides the other when set in Style
            // 
            // This bug is caused b/c of using ActualHeight/Width and UpdateWidth/Height method.
            // ActualHeight/Width is zero when Width/Height is invalidated after hwnd creation and
            // before 1st layout happens.  We hit this when Width/Height is set in style of the window
            // 
            // The fix is to cache the current hwnd size and use that instead.  We cache the size
            // even if sourceWindow is null b/c we might need to use this cache value before another 
            // WM_SIZE is received 

            int width = NativeMethods.SignedLOWORD(lParam); 
            int height = NativeMethods.SignedHIWORD(lParam);

            NativeMethods.RECT rc = new NativeMethods.RECT(0, 0, width, height);
            AdjustWindowRectEx(ref rc); 

            _currentHwndWidthDevicePixels = (rc.right - rc.left); 
            _currentHwndHeightDevicePixels = (rc.bottom - rc.top); 

            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called 
            // synchronously from CreateWindowEx call and we run into issues if
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want
            // to explicitly add the null check below, at all other places. 
            //
            // Adding IsCompositionTargetInvalid check here for fix of WOSB 1453012. 
            // Add this check here means that we won't fire WindowStateChanged event. 
            // However, since the hwnd is going away anyways, not firing StateChanged
            // should not be a big deal.  The other side effect is that Width/Height DPs 
            // won't be updated that should be fine too since window is going away.
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            {
                return false; 
            }
 
            Point ptLogicalUnits = DeviceToLogicalUnits(new Point(rc.right - rc.left, rc.bottom - rc.top)); 

            // Only set Width/Height local value when user resizes 
            if (_inUserSizeMove)
            {
                try
                { 
                    _updateHwndSize = false;
                    SetValue(FrameworkElement.WidthProperty, ptLogicalUnits.X); 
                    SetValue(FrameworkElement.HeightProperty, ptLogicalUnits.Y); 
                }
                finally 
                {
                    _updateHwndSize = true;
                }
            } 

            switch ((int)wParam) 
            { 
                // We introduced _previousWindowState for the following scenario:
                // 
                // win1.WindowState = WindowState.Maximized; // or stateA
                // ...
                // win1.WindowState = WindowState.Normal; // or stateB
                // 
                // Developer sets WindowState to Maximized/Minimized then return to Normal.
                // OnStateChanged should be fired. However, We were comparing that to WindowState.Normal. 
                // The value in property engine had been updated to Normal in the CLR setter, so OnStateChanged 
                // was never fired.
                // This is addressed in bug 937458. 
                //
                // Another reason for remembering the previous state is that
                // WM_SIZE is sent when the client area size of the hwnd changes.
                // Thus, if the hwnd is maximized, and the border style changes, 
                // WM_SIZE is sent.  In such cases, we don't want to fire
                // StateChanged since the previous state was maximized too. 
                // See WOSB 1097658 (NullReferenceException thrown when changing ResizeMode from CanMinimize 
                // to CanResizeWithGrip inside StateChanged event handler).
                // 
                // There are two places we update _previousWindowState.

                // WindowState can be changed as a result of the following two passes
                // 1. User interaction changes WindowState 
                // 2. Developer programmatically changes WindowState
                // We update _previousWindowState at two places 
                // 1. Before Hwnd is created, when developer programmatically changes WindowState, we update it when WindowState is invalidated. 
                // 2. After Hwnd is created, we update it here because both passes comes here eventually.
 
                // Event handler exception continuality: if exception occurs in StateChanged event handler, our state will not be
                // corrupted because the state related to StateChanged, WindowStateProperty and _previousWindowState, are set before the event is fired.
                // Please check Event handler exception continuality if the logic changes.
                case NativeMethods.SIZE_MAXIMIZED: 
                    if (_previousWindowState != WindowState.Maximized)
                    { 
                        // Do not set local value unless it is from user interaction. 
                        // User interaction is considered as the same pri as SetValue
                        // If WindowState is not the same as the current win32 value, it means the change is 
                        // not from the DP system but from user interaction.
                        if (WindowState != WindowState.Maximized)
                        {
                            WindowState = WindowState.Maximized; 
                        }
                        _previousWindowState = WindowState.Maximized; 
                        OnStateChanged(EventArgs.Empty); 
                    }
                    break; 
                case NativeMethods.SIZE_MINIMIZED:
                    if (_previousWindowState != WindowState.Minimized)
                    {
                        if (WindowState != WindowState.Minimized) 
                        {
                            WindowState = WindowState.Minimized; 
                        } 
                        _previousWindowState = WindowState.Minimized;
                        OnStateChanged(EventArgs.Empty); 
                    }
                    break;
                case NativeMethods.SIZE_RESTORED:
                    if (_previousWindowState != WindowState.Normal) 
                    {
                        if (WindowState != WindowState.Normal) 
                        { 
                            WindowState = WindowState.Normal;
                        } 
                        _previousWindowState = WindowState.Normal;
                        OnStateChanged(EventArgs.Empty);
                    }
                    break; 
                default:
                    break; 
            } 

            // DON'T DO ANYTHIHG HERE SINCE WE FIRE STATECHANGED ABOVE.  USER CODE 
            // RUNS IN STATE CHANGED AND WINDOW COULD HAVE BEEN CLOSED.  THUS, THE
            // STATE OF VARIABLES IS UNKNOWN.

            // HwndSource passes the win32 msgs to the public hookds first before 
            // passing layout hook etc.  Thus we get the WM_SIZE msg before
            // layout filter has processed it and we were reporting stale 
            // value for height/width.  Now, UIElement fires SizeChanged event. 

            return false; 
        }
        /// 
        ///     Critical: This code accesses CriticalHandle
        ///  
        [SecurityCritical]
        private bool WmMoveChanged(IntPtr hwnd, IntPtr lParam) 
        { 
            // We want to listen to WM_MOVE synchronously since if a Window is
            // created minimized/maximized we get this message as a result of 
            // calling CreateWindowEx.  Here, sourceWindow is null but we still
            // need to update _actual[Top/Left] to reflect the correct Top/Left
            // when Show() returns.  Thus we input hwnd and process top/left info
            // 
            // We won't fire LocationChanged unless Show has returned meaning
            // IsSourceWindowNull is false.  Furthermore, LocationChanged is 
            // fired only if the top/left values really changed 

            // Adding IsCompositionTargetInvalid check here for WOSB 1453012. 
            // Since hwnd is going away, not updating Top/Left DPs and not firing
            // LocationChanged should not matter.
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            { 
                return false;
            } 
 
            if (!_inTrustedSubWindow)
            { 
                SecurityHelper.DemandUIWindowPermission();
            }

            // the input lparam gives the client location, thus we have to 
            // convert it to the window location.
            NativeMethods.RECT rc = new NativeMethods.RECT(0,0,0,0); 
            SafeNativeMethods.GetClientRect(new HandleRef(this, hwnd), ref rc); 

            int left = NativeMethods.SignedLOWORD( lParam ); 
            int top = NativeMethods.SignedHIWORD( lParam );
            int right = left + rc.right;
            int bottom = top + rc.bottom;
 
            rc = new NativeMethods.RECT(left, top, right, bottom);
 
            AdjustWindowRectEx(ref rc); 

            Point ptLogicalUnits = DeviceToLogicalUnits(new Point(rc.left, rc.top)); 


            if (!DoubleUtil.AreClose(_actualLeft, ptLogicalUnits.X) ||
                !DoubleUtil.AreClose(_actualTop, ptLogicalUnits.Y)) 
            {
                _actualLeft = ptLogicalUnits.X; 
                _actualTop = ptLogicalUnits.Y; 

 
                // In Window, WmMoveChangedHelper write the local value of Top/Left
                // (if necessary) or updates the property system values for
                // Top/Left by calling CoerceValue.  Furthermore, it fires the
                // LocationChanged event.  RBW overrides WmMoveChangedHelper to do 
                // nothing as writing Top/Left is not supported for RBW and
                // LocationChanged is never fired for it either. 
                WmMoveChangedHelper(); 

                //Invalidate AutomationPeer if it was created/used by Automation. 
                //This will schedule a deferred update of bounding rectangle and
                //corresponding notification to the Automation layer.
                AutomationPeer peer = UIElementAutomationPeer.FromElement(this);
                if(peer != null) 
                {
                    peer.InvalidatePeer(); 
                } 

            } 

            return false;
        }
 
        // This method updates the Left/Top values and fires the location changed event.
        // It is virtual so that RBW can override it. 
        internal virtual void WmMoveChangedHelper() 
        {
 
            // Only set Top&Left local value when user resizes
            if (_inUserSizeMove)
            {
                try 
                {
                    _updateHwndLocation = false; 
                    SetValue(LeftProperty, _actualLeft); 
                    SetValue(TopProperty, _actualTop);
                } 
                finally
                {
                    _updateHwndLocation = true;
                } 
            }
            else 
            { 
                // hamidm -- 5/15/2007
                // WOSB 1447707 Window Left and Top properties do not update in Multi-Mon Scenario 
                //      1813033 Window.Left/Top/Width/Height return incorrect value after changing screen resolution / orientation
                //
                // The above were caused b/c of the fact that we didn't have this else block and thus
                // ignoring the WM_MOVE that we sent as a result of system level changes. 
                // Now, we coerce Top/Left with the actual value for location (even when it is not
                // sent as a result of user resize).  Note that coercing does not write the local value 
 
                try
                { 
                    _coercedFromWmMoveChanged = true;
                    _updateHwndLocation = false;
                    CoerceValue(TopProperty);
                    CoerceValue(LeftProperty); 
                }
                finally 
                { 
                    _updateHwndLocation = true;
                    _coercedFromWmMoveChanged = false; 
                }
            }

 
            // Event handler exception continuality: if exception occurs in LocationChanged event handler, our state will not be
            // corrupted because the states related to LocationChanged, LeftProperty, TopProperty, Left and Top are set before the event is fired. 
            // Please check event handler exception continuality if the logic changes. 
            OnLocationChanged(EventArgs.Empty);
        } 


        /// 
        ///     Critical:This calls into pointer to structure which is critical 
        /// 
        [SecurityCritical] 
        private bool WmGetMinMaxInfo( IntPtr lParam ) 
        {
            NativeMethods.MINMAXINFO mmi = (NativeMethods.MINMAXINFO)UnsafeNativeMethods.PtrToStructure( lParam, typeof(NativeMethods.MINMAXINFO)); 

            //
            // For Bug 1380569: Window SizeToContent does not work after changing Max size properties
            // 
            // When Min/Max size is changed in this Window instance, we want to make sure the correct
            // final Min/Max size is used to measure the window layout and notify the Win32 of the required 
            // Min/Max size. 
            //
            // This method is responsible to notify Win32 of the new Min/Max size. 
            // MeasureOverride( ) is responisble to use the right Min/Max size to calculate the desired layout size.
            //
            // But only this method knows the Win32 restricted Min/Max value for the HWND when it responds to WM_GETMINMAXINFO message.
            // 
            // To generate the right final Min/Max size value in both places ( here and MeasureOverride), we should
            // cache the Win32 restricted size here. 
            // 

 
            // hamidm -- 10/27/2005
            // We need to store the max/min size the hwnd can take.  This is used in GetWindowMinMax to determine
            // the size passed to children for their layout.  These are stored in device units here so later
            // we change them to logical units.  Fixes the following bugs: 
            //
            // WOSB: 1030000 Wrong window actual size returned if Autosize window 
            // content is smaller than the actual window (seems to return content 
            // size as opposed to window size)
            // 
            // WOSB: 1330752 Window content should respect Window's Max/Min size

            _trackMinWidthDeviceUnits = mmi.ptMinTrackSize.x;
            _trackMinHeightDeviceUnits = mmi.ptMinTrackSize.y; 
            _trackMaxWidthDeviceUnits = mmi.ptMaxTrackSize.x;
            _trackMaxHeightDeviceUnits = mmi.ptMaxTrackSize.y; 
 
            // if IsCompositionTargetInvalid is true, then it means that the CompositionTarget is not available.
            // This can happen at hwnd creation or destruction time. 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            {
                //
                // Get the final MinMax size for this HWND based on Win32 track value and Min/Max setting 
                // in this instance.
                // 
                WindowMinMax finalMinMax = GetWindowMinMax( ); 

                // The finalMinMax struct keeps the desired Min/Max size for this hwnd in Logic Units. 
                Point minSizeDeviceUnits = LogicalToDeviceUnits(new Point(finalMinMax.minWidth, finalMinMax.minHeight));
                Point maxSizeDeviceUnits = LogicalToDeviceUnits(new Point(finalMinMax.maxWidth, finalMinMax.maxHeight));

                // Put the new value in mmi 
                mmi.ptMinTrackSize.x = DoubleUtil.DoubleToInt(minSizeDeviceUnits.X);
                mmi.ptMinTrackSize.y = DoubleUtil.DoubleToInt(minSizeDeviceUnits.Y); 
 
                mmi.ptMaxTrackSize.x = DoubleUtil.DoubleToInt(maxSizeDeviceUnits.X);
                mmi.ptMaxTrackSize.y = DoubleUtil.DoubleToInt(maxSizeDeviceUnits.Y); 

                // Notify Win32 of the new Min/Max value for this HWND.

                Marshal.StructureToPtr(mmi, lParam, true); 
            }
 
            return true; 
        }
 
        private bool WmNcHitTest( IntPtr lParam, ref IntPtr refInt )
        {
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called
            // synchronously from CreateWindowEx call and we run into issues if 
            // _sourceWindow in null.  We only care to listen to WM_CREATE &
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want 
            // to explicitly add the null check below at all other places. 
            //
            // Adding check for IsCompositionTargetInvalid as the fix for WOSB 1453012. 
            // This can be true either at HwndSource creation time or when hwnd is going
            // away.
            if (IsSourceWindowNull || IsCompositionTargetInvalid)
            { 
                return false;
            } 
 
            // WmNcHitTest is necessary to enable ResizeGrip and it only
            // relevant for Window.  Doing this processing in a virtual so 
            // that RBW can override it
            return HandleWmNcHitTestMsg(lParam, ref refInt);
        }
 
        internal virtual bool HandleWmNcHitTestMsg(IntPtr lParam, ref IntPtr refInt)
        { 
            // 

 



 

            if ((_resizeGripControl == null) || (ResizeMode != ResizeMode.CanResizeWithGrip)) 
            { 
                return false;
            } 

            // mouse position wrt to the left/top of the screen
            int x = NativeMethods.SignedLOWORD(lParam);
            int y = NativeMethods.SignedHIWORD(lParam); 

            // Find the client area 0,0 of the Window wrt the screen 
            // This will be used to transform the mouse position from screen co-od 
            // to window's client area co-od.  We need this to be able to figure out
            // whether the mouse is currently over the resize grip control or not 


            NativeMethods.POINT pt = GetPointRelativeToWindow(x, y);
            Point ptLogicalUnits = DeviceToLogicalUnits(new Point(pt.x, pt.y)); 

            // Now, (ptLogicalUnits.X, ptLogicalUnits.Y) is the mouse postion wrt to the 
            // Window's client region. 
            // The next step is to find out whether the mouse is on top of the
            // ResizeGrip control 
            // For this we first need to find out mouse location wrt to the ResizeGrip
            // control and then check whether the mouse location is on the control
            // Conditions when mouse is on top of the control:
            //     x,y should be not be less than zero 
            //     x,y should not be greater than RenderSize.Width and RenderSize.Height
 
            GeneralTransform transfromFromWindow = this.TransformToDescendant(_resizeGripControl); 
            Point mousePositionWRTResizeGripControl = ptLogicalUnits;
            if (transfromFromWindow == null || transfromFromWindow.TryTransform(ptLogicalUnits, out mousePositionWRTResizeGripControl) == false) 
            {
                return false;
            }
 
            // check if the mouse is outside the ResizeGripControl region
            if ((mousePositionWRTResizeGripControl.X < 0) || 
                (mousePositionWRTResizeGripControl.Y < 0 ) || 
                (mousePositionWRTResizeGripControl.X > _resizeGripControl.RenderSize.Width) ||
                (mousePositionWRTResizeGripControl.Y > _resizeGripControl.RenderSize.Height)) 
            {
                // mouse not over ResizeGripControl; just let the DefWndProc handle this
                return false;
            } 

            if (FlowDirection == FlowDirection.RightToLeft) 
            { 
                refInt = new IntPtr(NativeMethods.HTBOTTOMLEFT);
            } 
            else
            {
                refInt = new IntPtr(NativeMethods.HTBOTTOMRIGHT);
            } 
            // we've handled the WM_NCHITTEST msg thus return true
            return true; 
        } 

        private bool WmShowWindow(IntPtr wParam, IntPtr lParam) 
        {
            // For WS_CHILD window, WM_SIZE, WM_MOVE (and maybe others) are called
            // synchronously from CreateWindowEx call and we run into issues if
            // _sourceWindow in null.  We only care to listen to WM_CREATE & 
            // WM_GETMINMAXINFO synchronously from CreateWindowEx thus we want
            // to explicitly add the null check below at all other places. 
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull || IsCompositionTargetInvalid) 
            {
                return false;
            }
 
            //lParam has five values: 0(programtically show/hide), 1(SW_PARENTCLOSING),
            //2(SW_OTHERMAXIMIZED), 3(SW_PARENTOPENING), 4(SW_OTHERRESTORED). We only care 
            //about 1 and 3. 
            switch (NativeMethods.IntPtrToInt32(lParam))
            { 
                //The window's owner window is being minimized.
                //In Win32, when lParam is SW_PARENTCLOSING, wParam is false,
                //which means the window is being hidden.
                case NativeMethods.SW_PARENTCLOSING: 
                    //This window will be hidden. Update _isVisible to reflect the
                    // new state.  Furthermore update visibility such that we 
                    // do not call ShowHelper again and thus calling 
                    // UpdateVisibilityProperty.
                    _isVisible = false; 
                    UpdateVisibilityProperty(Visibility.Hidden);
                    break;

                //The window's owner window is being restored. 
                //In Win32, when lParam is SW_PARENTOPENING, wParam is true,
                //which means the window is being shown. 
                case NativeMethods.SW_PARENTOPENING: 
                    //This window will be shown. Update _isVisible to reflect the
                    // new state.  Furthermore update visibility such that we 
                    // do not call ShowHelper again and thus calling
                    // UpdateVisibilityProperty.
                    _isVisible = true;
                    UpdateVisibilityProperty(Visibility.Visible); 
                    break;
 
                default: 
                    break;
            } 

            return false;
        }
 
        private static void _OnIconChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = (Window)d; 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
 
            BitmapFrame bf;

            // setting icon value to null or something that is a BitmapFrame is allowed.
            // Why only BitmapFrame, b/c when an ImageSource is created using an .ico, it 
            // always returns a BitmapFrame.  Moreover, we want APIs that are on BitmapFrame.
            // Also, we don't support any other source of image besides an ico for icons yet. 
            if (e.NewValue == null) 
            {
                bf = null; 
            }
            else
            {
                bf = e.NewValue as BitmapFrame; 

                if (bf == null) 
                { 
                    throw new InvalidOperationException(SR.Get(SRID.IconMustBeBitmapFrame));
                } 
            }
            w.OnIconChanged(bf);
        }
 

        private void OnIconChanged(BitmapFrame newIcon) 
        { 
            // No need to dispose previous _icon.
            // _icon is a ref to the ImageSource object 
            // set by the developer.  Since the dev created
            // the ImageSource object it is his responsibility to
            // dispose it.
            _icon = newIcon; 

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            {
                UpdateIcon(); 
            }
        }

        private static void _OnTitleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = (Window)d; 
            Debug.Assert(w != null, "DependencyObject must be of type Window."); 

            w.OnTitleChanged(); 
        }

        private static bool _ValidateText(object value)
        { 
            return (value != null);
        } 
 
        private void OnTitleChanged()
        { 
            UpdateTitle(Title);
        }

        private static void _OnShowInTaskbarChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = (Window)d; 
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnShowInTaskbarChanged(); 
        }

        /// 
        ///     Critical: This code accesses hwnd 
        ///     TreatAsSafe: This function simply minimizes and maximises that is ok, also this will only
        ///     work in RBW code path and that is ok since this is bounded to parent 
        ///  
        [SecurityCritical,SecurityTreatAsSafe]
        private void OnShowInTaskbarChanged() 
        {
            if (!_inTrustedSubWindow)
            {
 
                SecurityHelper.DemandUIWindowPermission();
            } 
 
            // this call ends up throwing an exception if accessing
            // ShowInTaskbar is not allowed 
            VerifyApiSupported();

            // There are 2 cases
            // Case 1 : being set before source window is created 
            // Case 2 : being set after the source window is created
            // Case 3 : bet set when CompositionTarget is invalid meaning we're in a bad state 
 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if ( IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            {
                bool fHideWindow = false;
                // Win32 bug. For ShowInTaskbar to change dynamically, we need to hide then show the window.
                // It is recommended to hide the window, chnage the style bits and then show it again. 
                if (_isVisible)
                { 
                    UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle), NativeMethods.NullHandleRef, 0, 0, 0, 0, 
                                       NativeMethods.SWP_NOMOVE |
                                       NativeMethods.SWP_NOSIZE | 
                                       NativeMethods.SWP_NOZORDER |
                                       NativeMethods.SWP_NOACTIVATE |
                                       NativeMethods.SWP_NOSENDCHANGING |
                                       NativeMethods.SWP_HIDEWINDOW); 
                    fHideWindow = true;
                } 
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd  )) 
                {
                    SetTaskbarStatus(); 
                }
                // Use fHideWindow instead of _isVisible in case if we listen to HideWindow messages and update _isVisible value,
                // it won't break this code.
                if (fHideWindow) 
                {
                    UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle), NativeMethods.NullHandleRef, 0, 0, 0, 0, 
                                                    NativeMethods.SWP_NOMOVE | 
                                                    NativeMethods.SWP_NOSIZE |
                                                    NativeMethods.SWP_NOZORDER | 
                                                    NativeMethods.SWP_NOACTIVATE |
                                                    NativeMethods.SWP_NOSENDCHANGING |
                                                    NativeMethods.SWP_SHOWWINDOW);
                } 
            }
        } 
 
        private static bool _ValidateWindowStateCallback(object value)
        { 
            return IsValidWindowState((WindowState)value);
        }

        private static void _OnWindowStateChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = (Window)d; 
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnWindowStateChanged((WindowState) e.NewValue); 
        }

        /// 
        ///     Critical: This code can cause window to maximize and minimize and used hwnd 
        ///     TreatAsSafe: This has a demand
        ///  
        [SecurityCritical,SecurityTreatAsSafe] 
        private void OnWindowStateChanged(WindowState windowState)
        { 
            SecurityHelper.DemandUIWindowPermission();

            //
 

 
 

 



 

            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            { 
                if (_isVisible == true)
                { 
                    HandleRef hr = new HandleRef(this,  CriticalHandle);

                    int style = _Style;
 
                    // Only call ShowWindow if window is in a different state
                    switch (windowState) 
                    { 
                        case WindowState.Normal:
                            if ((style & NativeMethods.WS_MAXIMIZE) == NativeMethods.WS_MAXIMIZE) 
                            {
                                //
                                // The old behavior of this case is to restore the window using SW_RESTORE.
                                // With the ShowActivated property set to false we want this restore operation 
                                // to take the current activation state into account when restoring the window.
                                // 
                                if (ShowActivated || IsActive) 
                                    UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_RESTORE);
                                else 
                                    UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_SHOWNOACTIVATE);
                            }
                            else if ((style & NativeMethods.WS_MINIMIZE) == NativeMethods.WS_MINIMIZE)
                            { 
                                //
                                // We query to WINDOWPLACEMENT to get an indication about the state before the 
                                // minimize operation happened. If we were coming from a maximized state and now we 
                                // switch to normal, we want activation to happen since the maximized state is always
                                // activated and transitioning from activated to non-activated would be weird. 
                                //
                                NativeMethods.WINDOWPLACEMENT placement = new NativeMethods.WINDOWPLACEMENT();
                                placement.length = Marshal.SizeOf(placement);
                                UnsafeNativeMethods.GetWindowPlacement(hr, ref placement); 

                                if ((placement.flags & NativeMethods.WPF_RESTORETOMAXIMIZED) == NativeMethods.WPF_RESTORETOMAXIMIZED) 
                                    UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_RESTORE); 
                                else
                                { 
                                    if (ShowActivated)
                                        UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_RESTORE);
                                    else
                                        UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_SHOWNOACTIVATE); 
                                }
                            } 
                            break; 

                        case WindowState.Maximized: 
                            if ((style & NativeMethods.WS_MAXIMIZE) != NativeMethods.WS_MAXIMIZE)
                            {
                                //
                                // The OS doesn't provide support for non-activated maximized windows. 
                                //
                                UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_MAXIMIZE); 
                            } 
                            break;
 
                        case WindowState.Minimized:
                            if ((style & NativeMethods.WS_MINIMIZE) != NativeMethods.WS_MINIMIZE)
                            {
                                // 
                                // Historically, we used SW_MINIMIZE in here which activates the next top-level
                                // window in the Z order. Therefore, our ShowActivated property can't affect the 
                                // minimized state since this would incur a breaking change requiring us to use 
                                // SW_SHOWMINIMIZED instead in case ShowActivated is set to true (bw compat case).
                                // 
                                UnsafeNativeMethods.ShowWindow(hr, NativeMethods.SW_MINIMIZE);
                            }
                            break;
                        // 

 
 
                    }
                } 
            }
            else
            {
                // WindowState can be changed as a result of the following two passes 
                // 1. User interaction changes WindowState
                // 2. Developer programmatically changes WindowState 
                // We update _previousWindowState at two places 
                // 1. Before Hwnd is created, when developer programmatically changes WindowState, we update it here.
                // 2. After Hwnd is created, we update it when we get to WM_SIZE because both passes eventally meet there. 
                _previousWindowState = windowState;
            }

            // The value of Top and Left is affected by WindowState and WindowStartupLocation. 
            // we need to coerce Top and Left whenever these deciding factors change.
            // More info in CoerceTop. 
            try 
            {
                _updateHwndLocation = false; 
                CoerceValue(TopProperty);
                CoerceValue(LeftProperty);
            }
            finally 
            {
                _updateHwndLocation = true; 
            } 
        }
 
        private static bool _ValidateWindowStyleCallback(object value)
        {
            return IsValidWindowStyle((WindowStyle)value);
        } 

        private static void _OnWindowStyleChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            Window w = (Window)d;
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnWindowStyleChanged((WindowStyle) e.NewValue);
        }
 
        private void OnWindowStyleChanged(WindowStyle windowStyle)
        { 
            //Per our conversation with Aaron today, in M6 we are going to demand UnrestrictedFullScreen permission for 
            //setting WindowStyle to None. But there will be changes in M7 so that we can differentiate between FullScreen
            //and NoBorder window, so we comment this section out for future references. 
            //if ((value == WindowStyle.None) && (WindowState == WindowState.Maximized))
            //if (windowStyle == WindowStyle.None)
            //{
            //    AVTempUIPermission avtUIPermission = new AVTempUIPermission(AVTUIPermissionFullScreen.UnrestrictedFullScreen); 

                //CASRemoval:avtUIPermission.Demand(); 
            //} 

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            {
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd ))
                { 
                    CreateWindowStyle();
                } 
            } 
        }
 
        private static void _OnTopmostChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            Window w = (Window)d;
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnTopmostChanged((bool) e.NewValue); 
        } 

        /// 
        /// There is an explicit demand here - to enforce not being able to set this DP in Internet Zone.
        /// this should remanin here until Window spoofing work is done.
        ///     Critical as this accesses critical data - (CriticalHandle )
        ///     TreatAsSafe - as there is a demand. 
        ///
        [SecurityCritical, SecurityTreatAsSafe ] 
        private void OnTopmostChanged(bool topmost) 
        {
            SecurityHelper.DemandUIWindowPermission(); // Demand UI permission for topmost. 

            // this call ends up throwing an exception if accessing
            // Topmost is not allowed
            VerifyApiSupported(); 

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false  && IsCompositionTargetInvalid == false) 
            {
                HandleRef hWnd = topmost ? NativeMethods.HWND_TOPMOST : NativeMethods.HWND_NOTOPMOST; 
                UnsafeNativeMethods.SetWindowPos(new HandleRef(null, CriticalHandle),
                       hWnd,
                       0, 0, 0, 0,
                       NativeMethods.SWP_NOMOVE | NativeMethods.SWP_NOSIZE | NativeMethods.SWP_NOACTIVATE); 
            }
        } 
 
        private static object CoerceVisibility(DependencyObject d, object value)
        { 
            Window w = (Window)d;

            Visibility newValue = (Visibility)value;
            if (newValue == Visibility.Visible) 
            {
                w.VerifyCanShow(); 
                w.VerifyConsistencyWithAllowsTransparency(); 
                w.VerifyNotClosing();
                w.VerifyConsistencyWithShowActivated(); 
            }

            return value;
        } 

        ///  
        /// Called when VisiblityProperty is invalidated 
        /// The actual window is created when the Visibility property is set
        /// to Visibility.Visible for the first time or when Show is called. 
        /// For Window, Visibility.Visible means the Window is visible.
        /// Visibility.Hidden and Visibility.Collapsed mean the Window is not visible.
        /// Visibility.Hidden and Visibility.Collapsed are treated the same.
        ///  
        private static void _OnVisibilityChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = (Window)d; 

            // Indicate Visibility has been set 
            // This works fine because Window is always the root.  So Visibility property
            // would not be invalidated usless it is set to a value.  But if that changes,
            // we will get invalidation when Window it added to the tree and this would be broken.
            w._isVisibilitySet = true; 

            // _visibilitySetInternally is used to identify a call from Show/Hide in 
            // _OnVisibilityInvalidated callback.  If a call originates in Show/Hide, 
            // we DO NOT want to do anything in the _OnVisibilityCallback since, we
            // synchronously call ShowHelper from Show/Hide 
            if (w._visibilitySetInternally == true)
            {
                return;
            } 

            bool visibilityValue = VisibilityToBool((Visibility) e.NewValue); 
 
            w.Dispatcher.BeginInvoke(
                DispatcherPriority.Normal, 
                new DispatcherOperationCallback(w.ShowHelper),
                visibilityValue ? BooleanBoxes.TrueBox : BooleanBoxes.FalseBox);

        } 

        ///  
        ///     Critical: This code causes an elevation to all Window permission and 
        ///               calls into CreateSourceWindowImpl
        ///     TreatAsSafe: This code causes window to be created if it was null, 
        ///                  calling it over and over has no affect. Also in this case
        ///                 the code only creates the window if this is under an RBW
        ///                 code path and if it has been called via the internal constructor chain
        ///  
        [SecurityCritical, SecurityTreatAsSafe]
        private void SafeCreateWindow() 
        { 
            //this is true the first time the window is created
            if (IsSourceWindowNull == true) 
            {
                //this is true only if called via RBW
                if (!_inTrustedSubWindow)
                { 
                   SecurityHelper.DemandUIWindowPermission();
                } 
                // _isVisible is false at this moment.  Thus CreateAllStyle 
                // called by CreateSourceWindow does not set WS_VISIBLE style
 
                CreateSourceWindowImpl();
            }
        }
 
        // We set/clear ShowKeyboardCue when Show(ShowDialog)/Hide is called.
        // We do not clear the state of ShowKeyboardCue when Window is closed. 
        private void SetShowKeyboardCueState() 
        {
            // set property on AccessKey control indicating the 
            // invocation device
            if (KeyboardNavigation.IsKeyboardMostRecentInputDevice())
            {
                _previousKeyboardCuesProperty = (bool)GetValue(KeyboardNavigation.ShowKeyboardCuesProperty); 
                SetValue(KeyboardNavigation.ShowKeyboardCuesProperty, BooleanBoxes.TrueBox);
                _resetKeyboardCuesProperty = true; 
            } 
        }
 
        // We set/clear ShowKeyboardCue when Show(ShowDialog)/Hide is called.
        // We do not clear the state of ShowKeyboardCue when Window is closed.
        private void ClearShowKeyboardCueState()
        { 
            // if we set KeyboradNavigation.ShowKeyboardCuesProperty in ShowDialog,
            // set it to false here. 
            if (_resetKeyboardCuesProperty == true) 
            {
                _resetKeyboardCuesProperty = false; 
                SetValue(KeyboardNavigation.ShowKeyboardCuesProperty, BooleanBoxes.Box(_previousKeyboardCuesProperty));
            }
        }
 
        private void UpdateVisibilityProperty(Visibility value)
        { 
            // _visibilitySetInternally is used to identify a call (in _OnVisibilityInvalidated 
            // callback) for updating the property value only and not changing the actual
            // visibility state of the hwnd. 
            try
            {
                _visibilitySetInternally = true;
                Visibility = value; 
            }
            finally 
            { 
                _visibilitySetInternally = false;
            } 
        }

        /// 
        /// update _isVisible and call CreateSourceWindow if 
        /// it's the first time window is set to Visibile
        ///  
        ///  
        ///     Critical: Acceses CriticalHandle
        ///     TreatAsSafe: Code only creates window in RBW path 
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        private object ShowHelper(object booleanBox)
        { 
            // Setting Visiblilty is async. When this is called from the async callback,
            // check whether the window is already closed. 
            // E.g. window.Visibility = true; 
            //      ...
            //      window.Close(); 
            // We should not do anything if the window is already closed.
            if (_disposed == true)
            {
                return null; 
            }
 
            bool value = (bool) booleanBox; 
            _isClosing = false;
 
            // hamidm 9/7/2005 WOSB 1223920 (BVT Blocker: Invariant Assert when calling
            // Window.Show after setting Visibility=Hidden)

            // We should optimize for when visibilityValue == _isVisible only in ShowHelper 
            // since this is called from a [....] and async call.  We cannot optimize it there
            // since _isVisible may not reflect the exact state requested by the OM call. 
            if (_isVisible == value) 
            {
                return null; 
            }

            // _isVisible should always be set after calling SafeCreateWindow, because
            // if exception occurs in Loading event (fired as a result of setting Visibility to visible) handler, 
            // we set Visibility back to Collapsed. Otherwise we could get into a loop.
            if (value == true) 
            { 
                if (Application.IsShuttingDown)
                    return null; 

                SetShowKeyboardCueState();

                //create window only if under rbw 
                SafeCreateWindow();
                _isVisible = true; 
            } 
            else
            { 
                //demand in case you are trying to hide this window
                if (!_inTrustedSubWindow)
                {
                    SecurityHelper.DemandUIWindowPermission(); 
                }
 
                ClearShowKeyboardCueState(); 

                if (_showingAsDialog == true) 
                {
                    DoDialogHide();
                }
                _isVisible = false; 
            }
 
            // we need this check here again, b/c creating the window fires the 
            // Activted event and if user closes the window from it, then by
            // the time we get to this point _sourceWindow is already disposed. 
            if ( IsSourceWindowNull == false )
            {
                // NOTE: hamidm 08/24/04
                // PS Windows OS bug # 950580 Specifying an Avalon app to start 
                // maximized from a shortcut does not work.
 
                // ShowWindow MSDN documentation says that the first time ShowWindow 
                // is called, nCmd passed in STARTUPINFO is used instead of the one
                // passed in via ShowWindow call. However, that is not the case. 
                // ShowWindow implementation in user32 uses nCmd of STARTUPINFO only
                // if we pass SW_SHOW, SW_SHOWNORMAL, SW_SHOWDEFAULT to ShowWindow.
                // If anything else is passed, it does not use nCmd of STARTUPINFO.
 
                int nCmd = 0;
                if (value == true) 
                { 
                    // nCmdForShow access WindowState which is inaccessible for RBW.
                    // Thus doing so in a virtual that RBW overrides 
                    nCmd = nCmdForShow();
                }
                else
                { 
                    nCmd = NativeMethods.SW_HIDE;
                } 
                UnsafeNativeMethods.ShowWindow(new HandleRef(this, CriticalHandle), nCmd); 

                // We already did a ShowWindow upabove and then because of the using, we will flush which 
                // will cause us to set the visibility. Ideally I would like to simply not have the ShowWindow
                // call above, *but* there is this SHOWNA stuff which is tied to Focus/Activation cleanup
                // scheduled for M8.
                //set the style 
                SafeStyleSetter();
            } 
 

            // dialog functionality; start dispatcher loop to block the call 
            if ((_showingAsDialog == true) && (_isVisible == true))
            {
                // hamidm -- 07/07/04
                // PS Bug # 992107, 935429 
                //
                // Since we exited the Context, we need to make sure 
                // we enter it before returning even if there is an 
                // exception
                // 
                Debug.Assert(_dispatcherFrame == null, "_dispatcherFrame must be null here");

                try
                { 
                    // tell users we're going modal
                    ComponentDispatcher.PushModal(); 
 
                    _dispatcherFrame = new DispatcherFrame();
                    Dispatcher.PushFrame(_dispatcherFrame); 
                }
                finally
                {
                    // tell users we're going non-modal 
                    ComponentDispatcher.PopModal();
                } 
            } 

            return null; 
        }

        internal virtual int nCmdForShow()
        { 
            int nCmd = 0;
            switch(WindowState) 
            { 
                case WindowState.Maximized:
                    nCmd = NativeMethods.SW_SHOWMAXIMIZED; // The OS doesn't provide support for non-activated maximized windows. 
                    break;
                case WindowState.Minimized:
                    nCmd = ShowActivated ? NativeMethods.SW_SHOWMINIMIZED : NativeMethods.SW_SHOWMINNOACTIVE;
                    break; 
                 default:
                    nCmd = ShowActivated ? NativeMethods.SW_SHOW : NativeMethods.SW_SHOWNA; 
                    break; 
            }
            return nCmd; 
        }

        /// 
        ///     Critical: This code elevates 
        ///     TreatAsSafe: This code is safe to call since it is not configurable and sets a preallowed style
        ///  
        [SecurityCritical,SecurityTreatAsSafe] 
        private void SafeStyleSetter()
        { 
            (new UIPermission(UIPermissionWindow.AllWindows)).Assert();
            try//blessed assert to toggle visibility, this does not let random styles from being set
            {
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd)) 
                {
                    _Style = _isVisible ? (_Style | NativeMethods.WS_VISIBLE) : _Style; 
                } 
            }
            finally 
            {
                UIPermission.RevertAssert();
            }
        } 
        private static bool _ValidateSizeToContentCallback(object value)
        { 
            return IsValidSizeToContent((SizeToContent)value); 
        }
 
        /// 
        /// SizeToContent property GetValue override
        /// 
        ///  
        /// 
        private static object _SizeToContentGetValueOverride(DependencyObject d) 
        { 
            Window w = d as Window;
 
            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            return w.SizeToContent;
        }
 
        /// 
        /// SizeToContent property invalidation callback 
        ///  
        private static void _OnSizeToContentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = d as Window;

            Debug.Assert(w != null, "DependencyObject must be of type Window.");
            w.OnSizeToContentChanged((SizeToContent) e.NewValue); 
        }
 
        private void OnSizeToContentChanged(SizeToContent sizeToContent) 
        {
            // this call ends up throwing an exception if accessing 
            // SizeToContent is not allowed
            VerifyApiSupported();

            // Update HwndSource's SizeToContent. 
            // HwndSource will only update layout if the value has changed.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            { 
                HwndSourceSizeToContent = sizeToContent;
            }
        }
 
        /// 
        /// Validate [Max/Min]Width/Height and Top/Left value. 
        ///  
        /// Length takes Double; Win32 handles Int.
        /// We throw exception when the value goes below Int32Min and Int32Max. 
        /// WorkItem 26263: ValidateValueCallback needs to move to PropertyMetadata so Window can
        /// add its own validation and validate before invalid value is set. Right now, we can only
        /// validate this in PropertyInalidatinonCallback because of this. (We couldn't make it virtual on
        /// FrameworkELement because ValidateValueCallback doesn't provide context. Work item 25275). 
        private static void ValidateLengthForHeightWidth(double l)
        { 
            //basically, NaN and PositiveInfinity are ok, and then anything 
            //that can be converted to Int32
            if (!Double.IsPositiveInfinity(l) && !DoubleUtil.IsNaN(l) && 
                ((l > Int32.MaxValue) || (l < Int32.MinValue)))
            {
                throw new ArgumentException(SR.Get(SRID.ValueNotBetweenInt32MinMax, l));
            } 
        }
 
        private static void ValidateTopLeft(double length) 
        {
            // Values not allowed: PositiveInfinity, NegativeInfinity 
            // and values that are beyond the range of Int32
            if (Double.IsPositiveInfinity(length) ||
                Double.IsNegativeInfinity(length))
            { 
                throw new ArgumentException(SR.Get(SRID.InvalidValueForTopLeft, length));
            } 
 
            if ((length > Int32.MaxValue) ||
                (length < Int32.MinValue)) 
            {
                throw new ArgumentException(SR.Get(SRID.ValueNotBetweenInt32MinMax, length));
            }
        } 

        private static void _OnHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            Window w = d as Window;
            Debug.Assert(w != null, "d must be typeof Window"); 
            if (w._updateHwndSize)
            {
                w.OnHeightChanged((double) e.NewValue);
            } 
        }
 
        /// 
        /// There is an explicit demand here - to enforce not being able to set this DP in Internet Zone.
        /// this should remanin here until Window spoofing work is done. 
        ///
        private void OnHeightChanged(double height)
        {
            // WOSB 1018227:  Move ValidateLengthForHeightWidth calls from property 
            // invalidation callback to PropertyMetadata
            ValidateLengthForHeightWidth(height); 
 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false && !DoubleUtil.IsNaN(height)) 
            {
                UpdateHeight(height);
            }
        } 

        private static void _OnMinHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        { 
            Window w = d as Window;
            Debug.Assert(w != null, "d must be typeof Window"); 
            w.OnMinHeightChanged((double) e.NewValue);
        }

        private void OnMinHeightChanged(double minHeight) 
        {
            // this call ends up throwing an exception if accessing 
            // MinHeight is not allowed 
            VerifyApiSupported();
 
            ValidateLengthForHeightWidth(minHeight);
            // Only trigger immediate size update when hwnd has been created and MinHeight is not Auto and MinHeight is
            // greater then current ActualHeight.
            // If hwnd hasn't been created, size will be controlled when it is created. 
            // If MinHeight is Auto or ActualHeight is greater than MinHeight, there is no need update size of the window.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if ((IsSourceWindowNull == false ) && (IsCompositionTargetInvalid == false) && (minHeight > ActualHeight))
            { 
                if (WindowState == WindowState.Normal)
                {
                    UpdateHwndSizeOnWidthHeightChange(ActualWidth, minHeight);
                } 
                else
                { 
                    // no need to do anything.  When window is restored, we get WM_GETMINMAXINFO where 
                    // we restrict the max/min size of the window to [Max/Min][Height/Width]
                } 
            }
        }

        private static void _OnMaxHeightChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = d as Window; 
            Debug.Assert(w != null, "d must be typeof Window"); 
            w.OnMaxHeightChanged((double) e.NewValue);
        } 

        private void OnMaxHeightChanged(double maxHeight)
        {
            // this call ends up throwing an exception if accessing 
            // MaxHeight is not allowed
            VerifyApiSupported(); 
 
            ValidateLengthForHeightWidth(MaxHeight);
 
            // Only trigger immediate size update when hwnd has been created and MaxHeight is not Auto and
            // ActualHeight > MaxHeight
            //
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if ((IsSourceWindowNull == false) && (IsCompositionTargetInvalid == false) &&(maxHeight < ActualHeight))
            { 
                if (WindowState == WindowState.Normal) 
                {
                    UpdateHwndSizeOnWidthHeightChange(ActualWidth, maxHeight); 
                }
                else
                {
                    // no need to do anything.  When window is restored, we get WM_GETMINMAXINFO where 
                    // we restrict the max/min size of the window to [Max/Min][Height/Width]
                } 
            } 
        }
 
        private static void _OnWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            Window w = d as Window;
            Debug.Assert(w != null, "d must be typeof Window"); 
            if (w._updateHwndSize)
            { 
                w.OnWidthChanged((double) e.NewValue); 
            }
        } 

        private void OnWidthChanged(double width)
        {
            ValidateLengthForHeightWidth(width); 

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false && !DoubleUtil.IsNaN(width)) 
            {
                UpdateWidth(width); 
            }
        }

        private static void _OnMinWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = d as Window; 
            Debug.Assert(w != null, "d must be typeof Window"); 
            w.OnMinWidthChanged((double) e.NewValue);
        } 

        private void OnMinWidthChanged(double minWidth)
        {
            // this call ends up throwing an exception if accessing 
            // MinWidth is not allowed
            VerifyApiSupported(); 
 
            // WOSB 1018227:  Move ValidateLengthForHeightWidth calls from property
            // invalidation callback to PropertyMetadata 
            ValidateLengthForHeightWidth(minWidth);
            // Only trigger immediate size update when hwnd has been created and MinWidth is not Auto and MinWidth is
            // greater then current ActualWidth.
            // If hwnd hasn't been created, size will be controlled when it is created. 
            // If MinWidth is Auto or ActualWidth is greater than MinWidth, there is no need update size of the window.
            // 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if ((IsSourceWindowNull == false) && (IsCompositionTargetInvalid == false) && (minWidth > ActualWidth))
            { 
                if ( WindowState == WindowState.Normal)
                {
                    UpdateHwndSizeOnWidthHeightChange(minWidth, ActualHeight);
                } 
                else
                { 
                    // no need to do anything.  When window is restored, we get WM_GETMINMAXINFO where 
                    // we restrict the max/min size of the window to [Max/Min][Height/Width]
                } 
            }
        }

        private static void _OnMaxWidthChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = d as Window; 
            Debug.Assert(w != null, "d must be typeof Window"); 
            w.OnMaxWidthChanged((double) e.NewValue);
        } 

        private void OnMaxWidthChanged(double maxWidth)
        {
            // this call ends up throwing an exception if accessing 
            // MaxWidth is not allowed
            VerifyApiSupported(); 
 
            ValidateLengthForHeightWidth(maxWidth);
            // Only trigger immediate size update when hwnd has been created and MaxWidth is not Auto and 
            // ActualWidth > MaxWidth
            //
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if ((IsSourceWindowNull == false ) && (IsCompositionTargetInvalid == false) && (maxWidth < ActualWidth)) 
            {
                if (WindowState == WindowState.Normal) 
                { 
                    UpdateHwndSizeOnWidthHeightChange(maxWidth, ActualHeight);
                } 
                else
                {
                    // no need to do anything.  When window is restored, we get WM_GETMINMAXINFO where
                    // we restrict the max/min size of the window to [Max/Min][Height/Width] 
                }
            } 
        } 

        // Updates the restore bounds of the hwnd based on BoundsSpecified enum values 
        // OR-ing of BoundsSpecified enum is not supported.
        /// 
        ///     Critical: This code accesses CriticalHandle
        ///     TreatAsSafe:This code is disabled for all windows including RBW in PartialTrust 
        /// 
        [SecurityCritical,SecurityTreatAsSafe] 
        private void UpdateHwndRestoreBounds(double newValue, BoundsSpecified specifiedRestoreBounds) 
        {
            SecurityHelper.DemandUIWindowPermission(); 

            NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT();
            wp.length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT));
            UnsafeNativeMethods.GetWindowPlacement(new HandleRef(this, CriticalHandle), ref wp); 

            double convertedValue = (LogicalToDeviceUnits(new Point(newValue, 0))).X; 
            switch (specifiedRestoreBounds) 
            {
                case BoundsSpecified.Height: 
                    wp.rcNormalPosition_bottom = wp.rcNormalPosition_top + DoubleUtil.DoubleToInt(convertedValue);
                    break;
                case BoundsSpecified.Width:
                    wp.rcNormalPosition_right = wp.rcNormalPosition_left + DoubleUtil.DoubleToInt(convertedValue); 
                    break;
                case BoundsSpecified.Top: 
                    // convert input value into work-area co-ods 
                    double newTop = newValue;
                    // [Get/Set]WindowPlacement work with workarea co-ods for a top level 
                    // window whose WS_EX_TOOLWINDOW bit is clear.  If this bit is set,
                    // then the co-ods are expected to be in screen co-ods of the monitor.
                    // TransfromWorkAreaScreenArea can transform a point from work area co-ods
                    // to screen area co-ods and vice versa depending on TransformType value passed. 
                    // So, in our case, if the window is not a ToolWindow we want to transform
                    // the input value from screen co-ods to work area co-ods. 
                    if ((StyleExFromHwnd & NativeMethods.WS_EX_TOOLWINDOW) == 0) 
                    {
                        newTop = TransformWorkAreaScreenArea(new Point(0, newTop), TransformType.ScreenAreaToWorkArea).Y; 
                    }
                    newTop = (LogicalToDeviceUnits(new Point(0, newTop))).Y;
                    int currentHeight = wp.rcNormalPosition_bottom - wp.rcNormalPosition_top;
                    wp.rcNormalPosition_top = DoubleUtil.DoubleToInt(newTop); 
                    wp.rcNormalPosition_bottom = wp.rcNormalPosition_top + currentHeight;
                    break; 
                case BoundsSpecified.Left: 
                    // convert input value into work-area co-ods
                    double newLeft = newValue; 
                    // [Get/Set]WindowPlacement work with workarea co-ods for a top level
                    // window whose WS_EX_TOOLWINDOW bit is clear.  If this bit is set,
                    // then the co-ods are expected to be in screen co-ods of the monitor.
                    // TransfromWorkAreaScreenArea can transform a point from work area co-ods 
                    // to screen area co-ods and vice versa depending on TransformType value passed.
 
                    // So, in our case, if the window is not a ToolWindow we want to transform 
                    // the input value from screen co-ods to work area co-ods.
                    if ((StyleExFromHwnd & NativeMethods.WS_EX_TOOLWINDOW) == 0) 
                    {
                        newLeft = TransformWorkAreaScreenArea(new Point(newLeft, 0), TransformType.ScreenAreaToWorkArea).X;
                    }
                    newLeft = (LogicalToDeviceUnits(new Point(newLeft, 0))).X; 
                    int currentWidth = wp.rcNormalPosition_right - wp.rcNormalPosition_left;
                    wp.rcNormalPosition_left = DoubleUtil.DoubleToInt(newLeft); 
                    wp.rcNormalPosition_right = wp.rcNormalPosition_left + currentWidth; 
                    break;
                default: 
                    Debug.Assert(false, String.Format("specifiedRestoreBounds can't be {0}", specifiedRestoreBounds));
                    break;
            }
 
            UnsafeNativeMethods.SetWindowPlacement(new HandleRef(this, CriticalHandle), ref wp);
        } 
 
        // deltaX = workAreaOriginValue - screenOriginValue (both in virtual co-ods)
        // X(screenAreaCood) = x(workAreaCood) + deltaX 
        /// 
        /// Critical: This code acceses CriticalHandle
        ///     TreatAsSafe: This code only works under RBW code path , this operation is ok since
        ///     RBW window is bound to the restrictions of its parent window which is the browser 
        /// 
        [SecurityCritical,SecurityTreatAsSafe] 
        private Point TransformWorkAreaScreenArea(Point pt, TransformType transformType) 
        {
            int deltaX = 0; 
            int deltaY = 0;
            Point retPt;
            if (!_inTrustedSubWindow)
            { 
                SecurityHelper.DemandUIWindowPermission();
            } 
 
            // First we get the monitor on which the window is on.  [Get/Set]WindowPlacement
            // co-ods are dependent on the monitor on which the window is on. 
            IntPtr hMonitor = SafeNativeMethods.MonitorFromWindow(new HandleRef(this, CriticalHandle), NativeMethods.MONITOR_DEFAULTTONULL);

            if (hMonitor != IntPtr.Zero)
            { 
                NativeMethods.MONITORINFOEX monitorInfo = new NativeMethods.MONITORINFOEX();
                monitorInfo.cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX)); 
 
                SafeNativeMethods.GetMonitorInfo(new HandleRef(this, hMonitor), monitorInfo);
                NativeMethods.RECT workAreaRect = monitorInfo.rcWork; 
                NativeMethods.RECT screenAreaRect = monitorInfo.rcMonitor;
                deltaX = workAreaRect.left - screenAreaRect.left;
                deltaY = workAreaRect.top - screenAreaRect.top;
            } 

            if (transformType == TransformType.WorkAreaToScreenArea) 
            { 
                retPt = new Point(pt.X + deltaX, pt.Y + deltaY);
            } 
            else
            {
                retPt = new Point(pt.X - deltaX, pt.Y - deltaY);
            } 
            return retPt;
        } 
 
        // Hua Wang: The logic for coerce Top & Left
        // 1.   Before Window is first shown (w.IsSourceWindowNull == false) 
        //      The value can come from 3 parties
        //          a. default
        //          b. SetValue
        //          c. Style, trigger... 
        //      In all those 3 cases, we would like to pass the value because we don't have a
        //      different value from hwnd before it is shown. 
        // 
        // To understarnd the below 2 cases better, you will need to know the Window position API precedence as following:
        //      WindowState > WindowStartupLocation (only works the first time shown) > Top/Left 
        //
        // 2.   During show
        //      There are 3 places that can coerce value during show. Right now they are all in
        //      SetupInitialState. 
        //          a. After CreateWindowEx.
        //                  i. We should always update with the win32 default position when it is Nan. 
        //                  ii. If WindowState is maxmized, we should always return from the hwnd (_actualTop/Left), 
        //                  but update the hwnd restorebounds. So setting Top/Left WindowState to to Maxmized before show would
        //                  work for restorebounds (details in bug 1217802). 
        //          b. If Top/Left is set and/or WindowStartupLocation is effective.
        //                  WindowState must be normal here because it takes precedence over WindowStartupLocation and Top/Left.
        //                  Since WindowStartupLocation only works the first time shown, we have a flag (_updateStartupLocation)
        //                  to help indicating that. 
        //                  If StartupLocation is effective, we should return from the hwnd (_actualTop/Left).
        //          c. If SizeToContent is set and WindowStartupLocation is effective. 
        //                  Same as b. 
        //
        // 3.   After show 
        //      a. User moves the Window.
        //          If user resize, we set local value (SetValue).
        //      b. User maximizes or minimizes. Or WindowState is changed programmtically
        //          We coerce Top and Left's value when WindowState is changed no matter whether it is 
        //          from user action or programmtically.
        //      c. SetValue 
        //      hamidm -- 5/15/2007  WOSB 1447707, 1813033 
        //      d. WM_MOVE
        //          When we get WM_MOVE as a result of window moving, we coerce Top/Left to the actual location 
        //          of the hwnd. _coercedFromWmMoveChanged is used to identify this case
        //
        //      For b and c, when WindowState is max or min, the hwnd value should always be returned.
        //      The new value should be set as restorebounds. Otherwise update with the new value. 
        //
        // Note: as we can see from above logic, _actualTop/Left should always be updated with the current hwnd position before we 
        // coerce Top and Left after hwnd is created. 
        private static object CoerceTop(DependencyObject d, object value)
        { 
            Window w = d as Window;

            // this call ends up throwing an exception if accessing Top
            // is not allowed 
            w.VerifyApiSupported();
 
            double top = (double)value; 

            // WOSB 1018227:  Move ValidateTopLeft calls from property 
            // invalidation callback to PropertyMetadata
            ValidateTopLeft(top);

            if (double.IsNaN(top)) 
            {
                return w._actualTop; 
            } 
            else
            { 
                // If it is after hwnd has been created.
                // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
                if (w.IsSourceWindowNull == false && w.IsCompositionTargetInvalid == false)
                { 
                    if (w.WindowState != WindowState.Normal)
                    { 
                        // We need to update restore bounds here instead of in property changed callback. 
                        // It is because when WindowState is maximized (Top is 0) and then developer sets Top to 100,
                        // the coerce call back still returns 0 so GetValue will get the correct value. 
                        // Top property changed callback will not be called.
                        w.UpdateHwndRestoreBounds(top, BoundsSpecified.Top);
                        return w._actualTop;
 
                    }
                    else 
                    { 
                        if ((w._updateStartupLocation) && (w.WindowStartupLocation != WindowStartupLocation.Manual))
                        { 
                            return w._actualTop;
                        }
                    }
                } 
            }
 
            if (w._coercedFromWmMoveChanged) 
            {
                return w._actualTop; 
            }

            return value;
        } 

        private static void _OnTopChanged (DependencyObject d , DependencyPropertyChangedEventArgs e) 
        { 
            Window w = d as Window;
            Debug.Assert( w != null, "DependencyObject must be of type Window." ); 

            if (w._updateHwndLocation)
            {
                w.OnTopChanged((double) e.NewValue); 
            }
        } 
 
        private void OnTopChanged(double newTop)
        { 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            {
                // NaN is special and indicates using Win32 default, 
                // so we exclude that.
                if (DoubleUtil.IsNaN(newTop) == false) 
                { 
                    if (WindowState == WindowState.Normal)
                    { 
                        Invariant.Assert(!Double.IsNaN(_actualLeft), "_actualLeft cannot be NaN after show");
                        UpdateHwndPositionOnTopLeftChange(Double.IsNaN(Left) ? _actualLeft : Left, newTop);
                    }
                } 
            }
            else 
            { 
                // here the value is stored as measure units as newTop is in measure/logical units
                _actualTop = newTop; 
            }
        }

        // Please see comments for CoerceTop. 
        private static object CoerceLeft(DependencyObject d, object value)
        { 
            Window w = d as Window; 

            // this call ends up throwing an exception if setting property is not allowed 
            w.VerifyApiSupported();

            double left = (double)value;
 
            // WOSB 1018227:  Move ValidateTopLeft calls from property
            // invalidation callback to PropertyMetadata 
            ValidateTopLeft(left); 

            if (double.IsNaN(left)) 
            {
                return w._actualLeft;
            }
            else 
            {
                // If window is minmized ot maximized, if hwnd is created, should update the restore bounds 
                // shouldn't change the value 
                //
                // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
                if (w.IsSourceWindowNull == false && w.IsCompositionTargetInvalid == false)
                {
                    if (w.WindowState != WindowState.Normal)
                    { 
                        w.UpdateHwndRestoreBounds(left, BoundsSpecified.Left);
                        return w._actualLeft; 
                    } 
                    else
                    { 
                        if ((w._updateStartupLocation) && (w.WindowStartupLocation != WindowStartupLocation.Manual))
                        {
                            return w._actualLeft;
                        } 
                    }
                } 
            } 

            if (w._coercedFromWmMoveChanged) 
            {
                return w._actualLeft;
            }
 
            return value;
        } 
 
        private static void _OnLeftChanged (DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = d as Window;
            Debug.Assert( w != null, "DependencyObject must be of type Window." );

            if (w._updateHwndLocation) 
            {
                w.OnLeftChanged((double) e.NewValue); 
            } 
        }
 
        // _actualLeft is used to determine if LocationChanged should be fired in WMMoveChagnged.
        // We need it b/c we need to remember the last hwnd Left location to decide whether
        // we need to fire the event or not.  Why do we need to update here?  Well, for the following
        // scenario: 
        //    Window w = new Window();
        //    w.Left = 100; 
        //    w.WindowStyle = WindowStyle.None; 
        //    w.Show();
        // 
        //  In this case, we want to not fire LocationChanged from SetWindowPos called called
        //  from CorrectStyleForBorderlessWindowCase().
        //
        //  _actualLeft is update from the following places: 
        //
        // 
        // 1) In WM_MOVE handler 
        //
        // 2) In OnLeftChanged for the case when the hwnd is not created yet. 
        //
        // 3) SetupInitialState
        private void OnLeftChanged(double newLeft)
        { 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            { 
                // NaN is special and indicates using Win32 default,
                // so we exclude that here. 
                if (DoubleUtil.IsNaN(newLeft) == false)
                {
                    if (WindowState == WindowState.Normal)
                    { 
                        Invariant.Assert(!Double.IsNaN(_actualTop), "_actualTop cannot be NaN after show");
                        UpdateHwndPositionOnTopLeftChange(newLeft, Double.IsNaN(Top) ? _actualTop : Top); 
                    } 
                }
            } 
            else
            {
                // here the value is stored as measure units as newLeft is in measure/logical units
                _actualLeft = newLeft; 
            }
        } 
 
        /// 
        ///     Critical: This code accesses Hwnd and can be used to reposition window 
        ///     TreatAsSafe: Will not work on any window in partial trust
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        private void UpdateHwndPositionOnTopLeftChange(double leftLogicalUnits, double topLogicalUnits) 
        {
            Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull cannot be true when calling this function"); 
            SecurityHelper.DemandUIWindowPermission(); 

            Point ptDeviceUnits = LogicalToDeviceUnits(new Point(leftLogicalUnits, topLogicalUnits)); 

            UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle),
                        new HandleRef(null, IntPtr.Zero),
                        DoubleUtil.DoubleToInt(ptDeviceUnits.X), 
                        DoubleUtil.DoubleToInt(ptDeviceUnits.Y),
                        0, 
                        0, 
                        NativeMethods.SWP_NOSIZE | NativeMethods.SWP_NOZORDER | NativeMethods.SWP_NOACTIVATE
                        ); 
        }

        private static bool _ValidateResizeModeCallback(object value)
        { 
            return IsValidResizeMode((ResizeMode)value);
        } 
 
        private static void _OnResizeModeChanged (DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
            Window w = d as Window;
            Debug.Assert( w != null, "DependencyObject must be of type Window." );

            w.OnResizeModeChanged(); 
        }
 
        private void OnResizeModeChanged() 
        {
            // this call ends up throwing an exception if accessing 
            // ResizeMode is not allowed
            VerifyApiSupported();

            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012 
            if ( IsSourceWindowNull == false && IsCompositionTargetInvalid == false)
            { 
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd  )) 
                {
                    CreateResizibility(); 
                }
            }
        }
 
        private static object VerifyAccessCoercion(DependencyObject d, object value)
        { 
            // this call ends up throwing an exception if setting property is not allowed 
            ((Window)d).VerifyApiSupported();
 
            return value;
        }

        private static void _OnFlowDirectionChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
        {
            Window w = d as Window; 
            Debug.Assert(w != null, "DependencyObject must be of type Window."); 

            w.OnFlowDirectionChanged(); 
        }

        /// 
        ///     Right to Left 
        /// 
        private void OnFlowDirectionChanged() 
        { 
            // Adding check for IsCompositionTargetInvalid as part of the fix for WOSB 1453012
            if (IsSourceWindowNull == false && IsCompositionTargetInvalid == false) 
            {
                using (HwndStyleManager sm = HwndStyleManager.StartManaging(this, StyleFromHwnd, StyleExFromHwnd ))
                {
                    CreateRtl(); 
                }
            } 
        } 

        private static object CoerceRenderTransform(DependencyObject d, object value) 
        {
            Transform renderTransformValue = (Transform)value;

            if ((value == null) || 
                (renderTransformValue != null && renderTransformValue.Value != null && renderTransformValue.Value.IsIdentity == true))
            { 
                // setting this value is allowed. 
            }
            else 
            {
                throw new InvalidOperationException(SR.Get(SRID.TransformNotSupported));
            }
 
            return value;
        } 
 
        private static void _OnRenderTransformChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
        }

        private static object CoerceClipToBounds(DependencyObject d, object value)
        { 
            if (value != BooleanBoxes.FalseBox)
            { 
                throw new InvalidOperationException(SR.Get(SRID.ClipToBoundsNotSupported)); 
            }
            return value; 
        }

        private static void _OnClipToBoundsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        { 
        }
 
        ///  
        ///     sets taskbar status
        /// 
        ///


 

 
 

 



        [SecurityCritical, SecurityTreatAsSafe ] 
        private void SetTaskbarStatus()
        { 
            if (ShowInTaskbar == false) // don't show in taskbar 
            {
                SecurityHelper.DemandUIWindowPermission(); 

                // when this window is a top-level window
                if (_ownerHandle == IntPtr.Zero)
                { 
                    // need to parent this window to a hidden window
                    if (_hiddenWindow == null) 
                    { 
                        HwndSourceParameters param = new HwndSourceParameters("Hidden Window");
                        param.SetSize(NativeMethods.CW_USEDEFAULT, NativeMethods.CW_USEDEFAULT); 
                        param.SetPosition(NativeMethods.CW_USEDEFAULT, NativeMethods.CW_USEDEFAULT);
                        param.WindowStyle = NativeMethods.WS_OVERLAPPEDWINDOW;
                        _hiddenWindow = new HwndSource(param);
                    } 
                    SetParentHandle(_hiddenWindow.Handle);
                } 
                _StyleEx &= ~NativeMethods.WS_EX_APPWINDOW; 
            }
            else // (ShowInTaskbar == true) show in task bar 
            {
                _StyleEx |= NativeMethods.WS_EX_APPWINDOW;
                if( ! IsSourceWindowNull )
                { 
                    if ((_hiddenWindow != null) && ( _ownerHandle == _hiddenWindow.Handle))
                    { 
                        SetParentHandle(IntPtr.Zero); 
                    }
                } 
            }
        }

        private void CreateRtl() 
        {
            if ( this.FlowDirection == FlowDirection.LeftToRight ) 
            { 
                _StyleEx &= ~NativeMethods.WS_EX_LAYOUTRTL;
            } 
            else if ( this.FlowDirection == FlowDirection.RightToLeft )
            {
                _StyleEx |= NativeMethods.WS_EX_LAYOUTRTL;
            } 
            else
            { 
                throw new InvalidOperationException(SR.Get(SRID.IncorrectFlowDirection)); 
            }
 
        }

        /// 
        ///     Updates both style and styleEx for the window 
        ///
        /// 
 

 



 

 
        [SecurityCritical,SecurityTreatAsSafe] 
        internal void Flush()
        { 
            // hamidm - 07/13/2005: WOSB 1178019 (A NullReferenceException occurs when animating
            // the WindowStyle enum via a custom animation).  This bug contains details of
            // why we were seeing the null ref.
            // 
            // Sometimes, the SetWindowPos call below results in sending certain window messages
            // like (WM_SIZE) and their handling leads to setting some property on the Window leading 
            // to a call to HwndStyleManager.StartManaging.  Thus, we end up calling 
            // dispose on the "new" usage of the Manager before we complete this run of Flush method.
            // This resulted in null ref in setting the Dirty bit below since we were not using 
            // a local copy and the window member copy was already set to null by the "new" usage
            // of Manager.  To fix this bug, we do the following two things:
            //
            // 1) Keep a local copy of HwndStyleManager in this method to make it re-entrant. 
            // 2) null out _window.Manager in HwndStyleMangager.Dispose only if _window.Manager is
            //    this instance of the Manager. 
            // 
            HwndStyleManager manager = Manager;
            if (manager.Dirty && CriticalHandle != IntPtr.Zero) 
            {
                UnsafeNativeMethods.CriticalSetWindowLong(new HandleRef(this,CriticalHandle), NativeMethods.GWL_STYLE, (IntPtr)_styleDoNotUse.Value);
                UnsafeNativeMethods.CriticalSetWindowLong(new HandleRef(this,CriticalHandle), NativeMethods.GWL_EXSTYLE, (IntPtr)_styleExDoNotUse.Value);
 
                UnsafeNativeMethods.SetWindowPos(new HandleRef(this, CriticalHandle), NativeMethods.NullHandleRef, 0, 0, 0, 0,
                                               NativeMethods.SWP_NOMOVE | 
                                               NativeMethods.SWP_NOSIZE | 
                                               NativeMethods.SWP_NOZORDER |
                                               NativeMethods.SWP_FRAMECHANGED | 
                                               NativeMethods.SWP_DRAWFRAME |
                                               NativeMethods.SWP_NOACTIVATE);
                manager.Dirty = false;
            } 
        }
        private void ClearRootVisual() 
        { 
            _swh.ClearRootVisual();
        } 


        private NativeMethods.POINT GetPointRelativeToWindow( int x, int y )
        { 
            return _swh.GetPointRelativeToWindow( x, y, this.FlowDirection);
        } 
 
        //     If you're in the middle of changing the window's _style or _styleEx and call this function,
        //     you may get inconsistent results. 
        private Size GetHwndNonClientAreaSizeInMeasureUnits()
        {
            // HwndSource expands the client area to cover the entire window when it is in UsesPerPixelOpacity mode,
            // So non client area is (0,0) 
            return AllowsTransparency ? new Size(0, 0) : _swh.GetHwndNonClientAreaSizeInMeasureUnits();
        } 
 
        ///
        ///      Critical as this method accesses critical data. 
        ///      TreatAsSafe - this method "eliminates" critical data - ergo considered safe.
        ///
        [SecurityCritical, SecurityTreatAsSafe]
        private void ClearSourceWindow() 
        {
            if (_swh != null) 
            { 
                try
                { 
                    _swh.RemoveDisposedHandler(OnSourceWindowDisposed);
                }
                finally
                { 
                    HwndSource source = _swh.HwndSourceWindow;
                    _swh = null; 
 
                    if (source != null)
                    { 
                        source.SizeToContentChanged -= new EventHandler(OnSourceSizeToContentChanged);
                    }
                }
            } 
        }
 
        ///  
        /// Critical - accesses _ownerHandle and SetParentHandle.
        /// TreatAsSafe - doesn't disclose _ownerHandle; setting parent's handle to IntPtr.Zero is considered a safe operation. 
        /// 
        [SecurityCritical,SecurityTreatAsSafe]
        private void ClearHiddenWindowIfAny()
        { 
            // If there is a hiddenWindow and it's the owner of the current one as the result of setting ShowInTaskbar,
            // we need to unparent it. Because when we dipose the hiddenWindow, if it's still the parent 
            // of the current window, the current Window will get a second WM_DESTORY because its owner being distoried. 
            // See detail in bug 953988.
            // Unparent it in WM_CLOSE because when we get to WM_DESTROY, _sourceWindow.Handle could be IntPtr.Zero; 
            // InternalDispose() is where _hiddenWindow is disposed. It could be called from two places: 1. WmDestroy 2. OnSourceWindowDisposed.
            // When it's called from OnSourceWindowDisposed, _sourceWindow.Handle could have been set to IntPtr.Zero.
            if ((_hiddenWindow != null) && (_hiddenWindow.Handle == _ownerHandle))
            { 
                SetParentHandle(IntPtr.Zero);
            } 
        } 

        private void VerifyConsistencyWithAllowsTransparency() 
        {
            if (AllowsTransparency && WindowStyle != WindowStyle.None)
            {
                throw new InvalidOperationException(SR.Get(SRID.MustUseWindowStyleNone)); 
            }
        } 
 
        /// 
        /// Ciritical - accesses _inTrustedSubWindow. 
        /// TreatAsSafe - doesn't reveal _inTrustedSubWindow.
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        private void VerifyConsistencyWithShowActivated() 
        {
            // 
            // We don't support to show a maximized non-activated window. 
            // Don't check this consistency in a RBW (would break because Visibility is set when launching the RBW).
            // 
            if (!_inTrustedSubWindow && WindowState == WindowState.Maximized && !ShowActivated)
                throw new InvalidOperationException(SR.Get(SRID.ShowNonActivatedAndMaximized));
        }
 
        private static bool IsValidSizeToContent(SizeToContent value)
        { 
            return value == SizeToContent.Manual || 
                   value == SizeToContent.Width ||
                   value == SizeToContent.Height || 
                   value == SizeToContent.WidthAndHeight;
        }

        private static bool IsValidResizeMode(ResizeMode value) 
        {
            return value == ResizeMode.NoResize 
                || value == ResizeMode.CanMinimize 
                || value == ResizeMode.CanResize
                || value == ResizeMode.CanResizeWithGrip; 
        }

        private static bool IsValidWindowStartupLocation(WindowStartupLocation value)
        { 
            return value == WindowStartupLocation.CenterOwner
                || value == WindowStartupLocation.CenterScreen 
                || value == WindowStartupLocation.Manual; 
        }
 
        private static bool IsValidWindowState(WindowState value)
        {
            return value == WindowState.Maximized
                || value == WindowState.Minimized 
                || value == WindowState.Normal;
        } 
 
        private static bool IsValidWindowStyle(WindowStyle value)
        { 
            return value == WindowStyle.None
                || value == WindowStyle.SingleBorderWindow
                || value == WindowStyle.ThreeDBorderWindow
                || value == WindowStyle.ToolWindow; 
        }
 
        #endregion Private Methods 

        //---------------------------------------------- 
        //
        // Private Properties
        //
        //---------------------------------------------- 
        #region Private Properties
 
        private SizeToContent HwndSourceSizeToContent 
        {
            get 
            {
                return _swh.HwndSourceSizeToContent;
            }
            set 
            {
                _swh.HwndSourceSizeToContent = value; 
            } 
        }
 
        private NativeMethods.RECT WindowBounds
        {
            get
            { 
                Debug.Assert( _swh != null );
                return _swh.WindowBounds; 
            } 
        }
 
        private int StyleFromHwnd
        {
            get
            { 
                return _swh != null ? _swh.StyleFromHwnd : 0;
            } 
        } 

        private int StyleExFromHwnd 
        {
            get
            {
                return _swh != null ? _swh.StyleExFromHwnd : 0; 
            }
        } 
 
        /// 
        ///     Private helper for OwnedWindows property. 
        ///     The public version returns a copy of the WindowCollection.
        ///     For internal Window usage, we use OwnedWindowInternal
        ///     so that we can modify the underlying collection.
        ///  
        private WindowCollection OwnedWindowsInternal
        { 
            get 
            {
                if (_ownedWindows == null) 
                {
                    _ownedWindows = new WindowCollection();
                }
                return _ownedWindows; 
            }
        } 
 
        /// 
        ///     Application Instance 
        /// 
        private System.Windows.Application App
        {
            get {return System.Windows.Application.Current;} 
        }
 
        ///  
        ///     Tells whether the Application object exists or not
        ///  
        private bool IsInsideApp
        {
            get
            { 
                return (Application.Current != null);
            } 
        } 

        ///  
        ///     List of events on this Window
        /// 
        private EventHandlerList Events
        { 
            get
            { 
                if (_events == null) 
                {
                    _events = new EventHandlerList(); 
                }
                return _events;
            }
        } 
        #endregion Private Properties
 
 
        //----------------------------------------------
        // 
        // Private Fields
        //
        //----------------------------------------------
        #region Private Fields 

        private SourceWindowHelper  _swh;                               // object that will hold the window 
        private Window              _ownerWindow;                       // owner window 

        // keeps track of the owner hwnd 
        // we need this one b/c a owner/parent
        // can be set through the WindowInteropHandler
        // which is different than the owner Window object
        /// 
        /// Critical - handle of the parent window; get/set considered privileged operation
        /// 
        [SecurityCritical] 
        private IntPtr              _ownerHandle = IntPtr.Zero;   // no need to dispose this
        private WindowCollection    _ownedWindows; 
        private ArrayList           _threadWindowHandles;

        private bool                _updateHwndSize     = true;
        private bool                _updateHwndLocation = true; 
        private bool                _updateStartupLocation;
        private bool                _coercedFromWmMoveChanged;  // is used to special case Coerce[Top/Left] when called from WmMoveChanged 
        private bool                _isVisible; 
        private bool                _isVisibilitySet;           // use this to tell whether Visibility is set or not.
        private bool                _resetKeyboardCuesProperty; // true if we set ShowKeyboradCuesProperty in ShowDialog 
        private bool                _previousKeyboardCuesProperty;

        private static bool         _dialogCommandAdded;
        private bool                _postContentRenderedFromLoadedHandler; 

        // 
 

        private bool                _disposed; 

        private bool                _appShuttingDown;
        private bool                _ignoreCancel;
        private bool                _showingAsDialog; 
        private bool                _isClosing;
        private bool                _visibilitySetInternally; 
 
        private double              _trackMinWidthDeviceUnits = 0;
        private double              _trackMinHeightDeviceUnits = 0; 
        private double              _trackMaxWidthDeviceUnits = Double.PositiveInfinity;
        private double              _trackMaxHeightDeviceUnits = Double.PositiveInfinity;
        private double              _currentHwndWidthDevicePixels;
        private double              _currentHwndHeightDevicePixels; 

        /// 
        /// Critical - as this data is obtained via an elevation. 
        /// TreatAsSafe - as we've decided that Window position is not directly exploitable.
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        private double              _actualTop = Double.NaN;

        /// 
        /// Critical - as this data is obtained via an elevation.
        /// TreatAsSafe - as we've decided that Window position is not directly exploitable. 
        /// 
        [SecurityCritical, SecurityTreatAsSafe]
        private double              _actualLeft = Double.NaN; 

        private bool                _inUserSizeMove;
        private bool                _userResized;
        //Never expose this at any cost 
        /// 
        ///     Critical: This is a flag to indicate that this call is under RBW 
        ///                please do not expose it 
        /// 
        [SecurityCritical] 
        private bool                        _inTrustedSubWindow;

        private BitmapFrame                 _icon;
 
        private NativeMethods.IconHandle    _defaultLargeIconHandle;
        private NativeMethods.IconHandle    _defaultSmallIconHandle; 
        private NativeMethods.IconHandle    _currentLargeIconHandle; 
        private NativeMethods.IconHandle    _currentSmallIconHandle;
 
        private bool?                       _dialogResult = null;
        ///
        /// Critical - handle of the owner dialog; get/set considered privileged operation
        /// 
        [SecurityCritical]
        private IntPtr                      _dialogOwnerHandle = IntPtr.Zero; 
        /// 
        /// Critical - handle of the active window before the dialog is shown; get/set considered privileged operation
        /// 
        [SecurityCritical]
        private IntPtr                      _dialogPreviousActiveHandle;
        private DispatcherFrame             _dispatcherFrame;
 
        private WindowStartupLocation       _windowStartupLocation = WindowStartupLocation.Manual;
 
        // The previous WindowState value before WindowState changes 
        private WindowState                 _previousWindowState = WindowState.Normal;
        /// 
        /// Critical - handle of the owner dialog; get/set considered privileged operation
        ///
        [SecurityCritical]
        private HwndSource          _hiddenWindow; 
        private EventHandlerList    _events;
 
        // These should never be used directly, access only through property accessors 

        private SecurityCriticalDataForSet                 _styleDoNotUse; 
        private SecurityCriticalDataForSet                 _styleExDoNotUse;
        private HwndStyleManager    _manager;

        // reference to Resize Grip control; this is used to find out whether 
        // the mouse of over the resizegrip control
        private Control                 _resizeGripControl; 
 
        // static objects for Events
        private static readonly object EVENT_SOURCEINITIALIZED = new object(); 
        private static readonly object EVENT_CLOSING = new object();
        private static readonly object EVENT_CLOSED = new object();
        private static readonly object EVENT_ACTIVATED = new object();
        private static readonly object EVENT_DEACTIVATED = new object(); 
        private static readonly object EVENT_STATECHANGED = new object();
        private static readonly object EVENT_LOCATIONCHANGED = new object(); 
        private static readonly object EVENT_CONTENTRENDERED = new object(); 

        internal static readonly DependencyProperty IWindowServiceProperty 
            = DependencyProperty.RegisterAttached("IWindowService", typeof(IWindowService), typeof(Window),
                                          new FrameworkPropertyMetadata((IWindowService)null,
                                          FrameworkPropertyMetadataOptions.Inherits | FrameworkPropertyMetadataOptions.OverridesInheritanceBehavior));
 
        DispatcherOperation         _contentRenderedCallback;
 
        #endregion Private Fields 

        #region Private Class 

        ///
        ///      This class - is a wrapper around the HwndSource member - stored by the Window
        ///      All properties/methods on this class are marked as crtical, as by definition this classes purpose is the storage of critical data. 
        ///      Some of the individual members are marked - "TreatAsSafe".
        /// 
        ///      If you find you need a property on HwndSource to be accessed by the outer Window class 
        ///      Make sure you understand what you're doing from a security perspective.
        ///      Consult with AvSee or HamidM if you have any questions. 
        ///
        ///
        internal class SourceWindowHelper
        { 
                ///
                ///     Critical - as this accesses critical data ( _sourceWindow ) 
                /// 
                [SecurityCritical]
                internal SourceWindowHelper( HwndSource sourceWindow ) 
                {
                    Debug.Assert( sourceWindow != null );
                    _sourceWindow = sourceWindow;
                } 

                /// 
                ///     Critical - as this accesses critical data. 
                ///     TreatAsSafe - as this function just tests to see whether _sourceWindow has been created.
                ///                          Ok to expose publically. Equivalent to is Window visible. 
                ///
                internal bool IsSourceWindowNull
                {
                    [ SecurityCritical, SecurityTreatAsSafe ] 
                    get
                    { 
                        return ( _sourceWindow == null ); 
                    }
                } 

                ///
                ///     Critical - as this accesses critical data.
                ///     TreatAsSafe - as this function just tests to see whether CompositionTarget is valid or not. 
                ///                          Ok to expose publically.
                /// 
                internal bool IsCompositionTargetInvalid 
                {
                    [ SecurityCritical, SecurityTreatAsSafe ] 
                    get
                    {
                        return (CompositionTarget == null);
                    } 
                }
 
                /// 
                ///     Critical as this method hands out critical data.
                /// 
                internal IntPtr CriticalHandle
                {
                    [ SecurityCritical]
                    get 
                    {
                        if (_sourceWindow != null) 
                        { 
                            return _sourceWindow.CriticalHandle;
                        } 
                        else
                        {
                            return IntPtr.Zero;
                        } 
                    }
                } 
 
                ///
                /// Get the work area bounds for this window - taking multi-mon into account. 
                ///
                /// 
                ///     Critical: This code accesses CriticalHandle
                ///     TreatAsSafe: This information is safe to expose. It does not expose the CriticalHandle 
                /// 
                internal NativeMethods.RECT WorkAreaBoundsForNearestMonitor 
                { 
                    [SecurityCritical, SecurityTreatAsSafe]
                    get 
                    {
                        IntPtr monitor;
                        NativeMethods.MONITORINFOEX monitorInfo = new NativeMethods.MONITORINFOEX();
                        monitorInfo.cbSize = Marshal.SizeOf(typeof(NativeMethods.MONITORINFOEX)); 

                        monitor = SafeNativeMethods.MonitorFromWindow( new HandleRef( this, CriticalHandle), NativeMethods.MONITOR_DEFAULTTONEAREST  ); 
                        if ( monitor != IntPtr.Zero ) 
                        {
                            SafeNativeMethods.GetMonitorInfo( new HandleRef ( this, monitor ) , monitorInfo); 
                        }

                        return monitorInfo.rcWork;
 
                    }
                } 
 
                ///
                ///     Critical as this method accesses critical data. 
                ///     TreatAsSafe - window bounds by themselves is considered safe.
                ///
                internal NativeMethods.RECT WindowBounds
                { 
                   [SecurityCritical, SecurityTreatAsSafe ]
                    get 
                    { 
                        NativeMethods.RECT rc = new NativeMethods.RECT(0,0,0,0);
                        SafeNativeMethods.GetWindowRect(new HandleRef(this, CriticalHandle), ref rc); 

                        return rc;
                    }
                } 

 
                /// 
                ///     Critical as this method accesses critical data, _sourceWindow.CriticalHandle.
                /// 
                [SecurityCritical]
                private NativeMethods.POINT GetWindowScreenLocation(FlowDirection flowDirection)
                {
                    Debug.Assert(IsSourceWindowNull != true, "IsSourceWindowNull cannot be true here"); 
                    NativeMethods.POINT pt = new NativeMethods.POINT(0, 0);
                    if (flowDirection == FlowDirection.RightToLeft) 
                    { 
                        NativeMethods.RECT rc = new NativeMethods.RECT(0, 0, 0, 0);
 
                        // with RTL window, GetClientRect returns reversed coordinates
                        SafeNativeMethods.GetClientRect(new HandleRef(this, CriticalHandle), ref rc);

                        // note that we use rc.right here for the RTL case and client to screen that point 
                        pt = new NativeMethods.POINT(rc.right, rc.top);
                    } 
                    UnsafeNativeMethods.ClientToScreen(new HandleRef(this, _sourceWindow.CriticalHandle), pt); 

                    return pt; 
                }

                ///
                ///     Critical as this method accesses critical data. 
                ///     TreatAsSafe - as setting the auto-size behavior of the window is considered safe.
                /// 
                internal SizeToContent HwndSourceSizeToContent 
                {
                    [SecurityCritical, SecurityTreatAsSafe] 
                    get
                    {
                        return _sourceWindow.SizeToContent;
                    } 

                    [SecurityCritical, SecurityTreatAsSafe] 
                    set 
                    {
                        _sourceWindow.SizeToContent = value; 
                    }
                }

                /// 
                ///      Critical as this method accesses critical data.
                ///      NOT TREAT AS SAFE ! 
                /// 
                internal Visual RootVisual
                { 
                    [SecurityCritical]
                    set
                    {
                        _sourceWindow.RootVisual = value; 
                    }
                } 
 
                ///
                ///     Critical - as this method accesses critical data, _sourceWindow.CriticalHandle, 
                ///              - and calls UnsafeNativeMethod GetActiveWindow()
                ///     TreatAsSafe - the information we're returning ( this window is active) is deemed safe.
                ///
                internal bool IsActiveWindow 
                {
                    [ SecurityCritical, SecurityTreatAsSafe] 
                    get 
                    {
                        return (_sourceWindow.CriticalHandle == UnsafeNativeMethods.GetActiveWindow()); 
                    }
                }

                /// 
                ///         Critical as this accesses and hands out critical data.
                ///      * This is currently exposed for usage in the DRTs only. * 
                /// 
                internal HwndSource HwndSourceWindow
                { 
                    [SecurityCritical]
                    get
                    {
                        return _sourceWindow; 
                    }
                } 
 
                ///
                ///         Critical as this accesses and hands out critical data. 
                ///
                internal HwndTarget CompositionTarget
                {
                    [SecurityCritical] 
                    get
                    { 
                        if (_sourceWindow != null) 
                        {
                            HwndTarget compositionTarget = _sourceWindow.CompositionTarget; 
                            if (compositionTarget != null && compositionTarget.IsDisposed == false)
                            {
                                return compositionTarget;
                            } 
                        }
                        return null; 
                    } 
                }
 
                ///
                /// Return the relative window width and height.
                ///
                internal Size WindowSize 
                {
                    get 
                    { 
                        // Get the size of the avalon window and pass it to
                        // the base implementation. 

                        NativeMethods.RECT rc = WindowBounds;

                        return new Size(rc.right - rc.left, rc.bottom - rc.top); 
                    }
                } 
 
                ///
                /// Critical as this method calls a method that elevates - GetWindowLong 
                /// TreatAsSafe - this is information about the current window.
                ///                     this is safe as :
                ///                             it's innocous information.
                ///                             if you had permission to create the current window - you should be able to find out what you created it as. 
                ///                             for the browser case - you're not allowed to create the window. The actual styles you'd get would be fixed per OS release, you could guess them anyway.
                /// 
                internal int StyleExFromHwnd 
                {
                    [SecurityCritical, SecurityTreatAsSafe ] 
                    get
                    {
                        // Should never be called when Handle is non-null
                        Debug.Assert( IsSourceWindowNull == false , "Should only be invoked when we know Handle is non-null" ); 
                        return UnsafeNativeMethods.GetWindowLong(new HandleRef(this,CriticalHandle), NativeMethods.GWL_EXSTYLE);
                    } 
                } 

                /// 
                /// Critical as this method calls a method that elevates - GetWindowLong
                /// TreatAsSafe -this is information about the current window.
                ///                     this is safe as :
                ///                             it's innocous information. 
                ///                             if you had permission to create the current window - you should be able to find out what you created it as.
                ///                             for the browser case - you're not allowed to create the window. The actual styles you'd get would be fixed per OS release, you could guess them anyway. 
                /// 
                internal int StyleFromHwnd
                { 
                    [SecurityCritical, SecurityTreatAsSafe ]
                    get
                    {
                        // Should never be called when Handle is non-null 
                        Debug.Assert( IsSourceWindowNull == false , "Should only be invoked when we know Handle is non-null" );
                        return UnsafeNativeMethods.GetWindowLong(new HandleRef(this,CriticalHandle), NativeMethods.GWL_STYLE); 
                    } 
                }
 

                ///
                ///     Transform global coords of window location
                ///     to coords relative to top/left of the window. 
                ///
                /// 
                ///      Critical as this function accesses critical data (GetWindowScreenLocation). 
                ///      TreatAsSafe - as exposing the coords relative to the Window is considered safe.
                /// 
                [SecurityCritical, SecurityTreatAsSafe ]
                internal NativeMethods.POINT GetPointRelativeToWindow( int x, int y, FlowDirection flowDirection )
                {
                    NativeMethods.POINT ptWindow = GetWindowScreenLocation(flowDirection); 

                    // At this point ptWindow contains the location of the client area's top/left wrt 
                    // the screen 

                    return new NativeMethods.POINT( x - ptWindow.x, y - ptWindow.y ); 
                }

                /// 
                ///     Gets the size from the hwnd 
                /// 
                /// 
                /// Critical as this method accesses critical data. 
                /// TreatAsSafe - as this method returns the Window's current size. Considered safe.
                /// 
                [SecurityCritical, SecurityTreatAsSafe]
                internal Size GetSizeFromHwndInMeasureUnits()
                {
                    Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull can't be true here"); 

                    Point pt = new Point(0,0); 
                    NativeMethods.RECT rect = new NativeMethods.RECT(0,0,0,0); 
                    SafeNativeMethods.GetWindowRect(new HandleRef(null, CriticalHandle), ref rect);
                    pt.X = rect.right - rect.left; 
                    pt.Y = rect.bottom - rect.top;
                    pt = _sourceWindow.CompositionTarget.TransformFromDevice.Transform(pt);
                    return new Size(pt.X,pt.Y);
                } 

 
                ///  
                ///     Gets the frame size of the hwnd.
                ///     Note that we use the current Hwnd's style information. 
                ///     If you're in the middle of changing the window's _style or _styleEx and call this function,
                ///     you may get inconsistent results.
                /// 
                /// 
                ///     Critical as this method accesses critical data and performs an elevation
                ///     TreatAsSafe - as this method returns the Window's current non client area size. Considered safe. 
                /// 
                [ SecurityCritical, SecurityTreatAsSafe]
                internal Size GetHwndNonClientAreaSizeInMeasureUnits() 
                {
                    Point pt;
                    int style = StyleFromHwnd;
                    int styleEx = StyleExFromHwnd; 
                    Debug.Assert( IsSourceWindowNull == false , "IsSourceWindowNull can't be true here");
 
                    // Find out the size of the window frame x. 
                    // use any reference size to calculate the frame size
                    NativeMethods.RECT referenceClientAreaRect = new NativeMethods.RECT(100,100,500,500); 
                    NativeMethods.RECT windowRect = new NativeMethods.RECT(referenceClientAreaRect.left,
                                                                           referenceClientAreaRect.top,
                                                                           referenceClientAreaRect.right,
                                                                           referenceClientAreaRect.bottom); 

                    SafeNativeMethods.AdjustWindowRectEx(ref windowRect, style, false, styleEx ); 
 
                    pt = new Point(
                        (windowRect.right - windowRect.left) - (referenceClientAreaRect.right - referenceClientAreaRect.left), 
                        (windowRect.bottom - windowRect.top) - (referenceClientAreaRect.bottom - referenceClientAreaRect.top));

                    pt = _sourceWindow.CompositionTarget.TransformFromDevice.Transform(pt);
                    return new Size(pt.X, pt.Y); 
                }
 
                /// 
                ///     Critical as this function accesses critical data.
                ///     TreatAsSafe - as this function eliminates the top visual of the window if there is one. Considered safe this is 
                ///                          equivalent to making the window have no content.
                ///
                [SecurityCritical, SecurityTreatAsSafe]
                internal void ClearRootVisual() 
                {
                    if ( _sourceWindow.RootVisual != null ) 
                    { 
                        _sourceWindow.RootVisual = null;
                    } 
                }

                ///
                ///     Critical as this function accesses critical data. 
                ///     THIS FUNCTION IS NOT TREAT AS SAFE !
                /// 
                [SecurityCritical] 
                internal void AddDisposedHandler( EventHandler theHandler )
                { 
                    if (_sourceWindow != null)
                    {
                        _sourceWindow.Disposed += theHandler;
                    } 
                }
 
                /// 
                ///     Critical as this function accesses critical data.
                ///     THIS FUNCTION IS NOT TREAT AS SAFE ! 
                ///
                [SecurityCritical]
                internal void RemoveDisposedHandler( EventHandler theHandler )
                { 
                    if (_sourceWindow != null)
                    { 
                        _sourceWindow.Disposed -= theHandler; 
                    }
                } 

                [SecurityCritical]
                private HwndSource _sourceWindow;
        } 

        internal class HwndStyleManager : IDisposable 
        { 
            static internal HwndStyleManager StartManaging(Window w, int Style, int StyleEx )
            { 
                if (w.Manager == null)
                {
                    return new HwndStyleManager(w, Style, StyleEx);
                } 
                else
                { 
                    w.Manager._refCount++; 
                    return w.Manager;
                } 
            }

            private HwndStyleManager(Window w, int Style, int StyleEx  )
            { 
                _window = w;
                _window.Manager = this; 
 
                if ( w.IsSourceWindowNull == false )
                { 
                    _window._Style    =  Style;
                    _window._StyleEx  = StyleEx;

                    // Dirty ==> _style and hwnd are out of [....]. Since we just got 
                    // the style from hwnd, it obviously is not Dirty.
                    Dirty = false; 
                } 
                _refCount = 1;
            } 

            void IDisposable.Dispose()
            {
                _refCount--; 

                // hamidm - 07/13/2005: WOSB 1178019 (A NullReferenceException occurs when animating 
                // the WindowStyle enum via a custom animation).  This bug contains details of 
                // why we were seeing the null ref.
                // 
                // Sometimes, the Flush call below results in sending certain window messages
                // and their handling leads to setting some property on the Window leading
                // to a call to HwndStyleManager.StartManaging.  Thus, we end up calling
                // dispose on that before we complete this run of the Dispose method.  This 
                // resulted in null ref in Flush.  To fix this bug, we do the following two things:
                // 
                // 1) Keep a local copy of HwndStyleManager in Flush to make it re-entrant 
                // 2) null out _window.Manager below only if _window.Manager is this instance
                //    of the Manager. 

                if (_refCount == 0)
                {
                    _window.Flush(); 

                    if (_window.Manager == this) 
                    { 
                        _window.Manager = null;
                    } 
                }
            }

            internal bool Dirty 
            {
                get { return _fDirty; } 
                set { _fDirty = value; } 
            }
 
            private Window          _window;
            private int             _refCount;
            private bool            _fDirty;
        } 
        #endregion PrivateClass
 
        #region Private Enums 
        private enum TransformType
        { 
            WorkAreaToScreenArea = 0,
            ScreenAreaToWorkArea = 1
        }
 
        private enum BoundsSpecified
        { 
            Height = 0, 
            Width = 1,
            Top = 2, 
            Left = 3
        }
        #endregion Private Enums
 
        #region DTypeThemeStyleKey
 
        // Returns the DependencyObjectType for the registered ThemeStyleKey's default 
        // value. Controls will override this method to return approriate types.
        internal override DependencyObjectType DTypeThemeStyleKey 
        {
            get { return _dType; }
        }
 
        private static DependencyObjectType _dType;
 
        #endregion DTypeThemeStyleKey 
    }
 


    #region Enums
 
    /// 
    /// WindowStyle 
    ///  
    public enum WindowStyle
    { 
        /// 
        /// no border at all  also implies no caption
        /// 
        None = 0,                                               // no border at all  also implies no caption 

        ///  
        /// SingleBorderWindow 
        /// 
        SingleBorderWindow = 1,                                    // WS_BORDER 

        /// 
        /// 3DBorderWindow
        ///  
        ThreeDBorderWindow = 2,                                    // WS_BORDER | WS_EX_CLIENTEDGE
 
        ///  
        /// FixedToolWindow
        ///  
        ToolWindow = 3,                                           // WS_BORDER | WS_EX_TOOLWINDOW

        // NOTE: if you add or remove any values in this enum, be sure to update Window.IsValidWindowStyle()
    } 

 
    ///  
    /// WindowState
    ///  
    public enum WindowState
    {
        /// 
        /// Default size 
        /// 
        Normal = 0, 
 
        /// 
        /// Minimized 
        /// 
        Minimized = 1,   // WS_MINIMIZE

        ///  
        /// Maximized
        ///  
        Maximized = 2   // WS_MAXIMIZE 

        // NOTE: if you add or remove any values in this enum, be sure to update Window.IsValidWindowState() 

#if THEATRE_FULLSCREEN
        // The following Two are not Implement yet
        ///  
        /// Theatre
        ///  
        Theatre = 3, 

        ///  
        /// FullScreen
        /// 
        FullScreen = 4
#endif //THEATRE_FULLSCREEN 
    }
 
    ///  
    ///
    ///  
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)]
    public enum WindowStartupLocation
    {
        ///  
        /// Uses the values specified by Left and Top properties to position the Window
        ///  
        Manual = 0, 

        ///  
        /// Centers the Window on the screen.  If there are more than one monitors, then
        /// the Window is centered on the monitor that has the mouse on it
        /// 
        CenterScreen = 1, 

        ///  
        /// Centers the Window on its owner.  If there is no owner window defined or if 
        /// it is not possible to center it on the owner, then defaults to Manual
        ///  
        CenterOwner = 2,

        // NOTE: if you add or remove any values in this enum, be sure to update Window.IsValidWindowStartupLocation()
    } 

    ///  
    ///     ResizeMode 
    /// 
    [Localizability(LocalizationCategory.None, Readability = Readability.Unreadable)] 
    public enum ResizeMode
    {
        /// 
        ///     User cannot resize the Window. Maximize and Minimize boxes 
        ///     do not show in the caption bar.
        ///  
        NoResize = 0, 

        ///  
        ///     User can only minimize the Window.  Minimize box is shown and enabled
        ///     in the caption bar while the Maximize box is disabled.
        /// 
        CanMinimize = 1, 

        ///  
        ///     User can fully resize the Window including minimize and maximize. 
        ///     Both Maximize and Minimize boxes are shown and enabled in the caption
        ///     bar. 
        /// 
        CanResize = 2,

        ///  
        ///     Same as CanResize and ResizeGrip will show
        ///  
        CanResizeWithGrip = 3 

        // NOTE: if you add or remove any values in this enum, be sure to update Window.IsValidResizeMode() 
    }
    #endregion Enums

    internal class SingleChildEnumerator : IEnumerator 
    {
        internal SingleChildEnumerator(object Child) 
        { 
            _child = Child;
            _count = Child == null ? 0 : 1; 
        }

        object IEnumerator.Current
        { 
            get { return (_index == 0) ? _child : null; }
        } 
 
        bool IEnumerator.MoveNext()
        { 
            _index++;
            return _index < _count;
        }
 
        void IEnumerator.Reset()
        { 
            _index = -1; 
        }
 
        private int _index = -1;
        private int _count = 0;
        private object _child;
    } 
}
 
 


// 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