|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
// Description: Client-side wrapper for Window Pattern
using System;
using System.Windows.Automation.Provider;
using MS.Internal.Automation;
using System.Runtime.InteropServices;
namespace System.Windows.Automation
{
// Disable warning for obsolete types. These are scheduled to be removed in M8.2 so
// only need the warning to come out for components outside of APT.
#pragma warning disable 0618
///<summary>wrapper class for Window pattern </summary>
#if (INTERNAL_COMPILE)
internal class WindowPattern: BasePattern
#else
public class WindowPattern: BasePattern
#endif
{
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
private WindowPattern(AutomationElement el, SafePatternHandle hPattern, bool cached)
: base(el, hPattern)
{
_hPattern = hPattern;
_cached = cached;
}
#endregion Constructors
//------------------------------------------------------
//
// Public Constants / Readonly Fields
//
//------------------------------------------------------
#region Public Constants and Readonly Fields
/// <summary>Returns the Window pattern identifier</summary>
public static readonly AutomationPattern Pattern = WindowPatternIdentifiers.Pattern;
/// <summary>Property ID: CanMaximize - </summary>
public static readonly AutomationProperty CanMaximizeProperty = WindowPatternIdentifiers.CanMaximizeProperty;
/// <summary>Property ID: CanMinimize - </summary>
public static readonly AutomationProperty CanMinimizeProperty = WindowPatternIdentifiers.CanMinimizeProperty;
/// <summary>Property ID: IsModal - Is this is a modal window</summary>
public static readonly AutomationProperty IsModalProperty = WindowPatternIdentifiers.IsModalProperty;
/// <summary>Property ID: WindowVisualState - Is the Window Maximized, Minimized, or Normal (aka restored)</summary>
public static readonly AutomationProperty WindowVisualStateProperty = WindowPatternIdentifiers.WindowVisualStateProperty;
/// <summary>Property ID: WindowInteractionState - Is the Window Closing, ReadyForUserInteraction, BlockedByModalWindow or NotResponding.</summary>
public static readonly AutomationProperty WindowInteractionStateProperty = WindowPatternIdentifiers.WindowInteractionStateProperty;
/// <summary>Property ID: - This window is always on top</summary>
public static readonly AutomationProperty IsTopmostProperty = WindowPatternIdentifiers.IsTopmostProperty;
/// <summary>Event ID: WindowOpened - Immediately after opening the window - ApplicationWindows or Window Status is not guarantee to be: ReadyForUserInteraction</summary>
public static readonly AutomationEvent WindowOpenedEvent = WindowPatternIdentifiers.WindowOpenedEvent;
/// <summary>Event ID: WindowClosed - Immediately after closing the window</summary>
public static readonly AutomationEvent WindowClosedEvent = WindowPatternIdentifiers.WindowClosedEvent;
#endregion Public Constants and Readonly Fields
//------------------------------------------------------
//
// Public Methods
//
//------------------------------------------------------
#region Public Methods
/// <summary>
/// Changes the State of the window based on the passed enum.
/// </summary>
/// <param name="state">The requested state of the window.</param>
public void SetWindowVisualState( WindowVisualState state )
{
UiaCoreApi.WindowPattern_SetWindowVisualState(_hPattern, state);
}
/// <summary>
/// Non-blocking call to close this non-application window.
/// When called on a split pane, it will close the pane (thereby removing a
/// split), it may or may not also close all other panes related to the
/// document/content/etc. This behavior is application dependent.
/// </summary>
public void Close()
{
UiaCoreApi.WindowPattern_Close(_hPattern);
}
/// <summary>
/// Causes the calling code to block, waiting the specified number of milliseconds, for the
/// associated window to enter an idle state.
/// </summary>
/// <remarks>
/// The implementation is dependent on the underlying application framework therefore this
/// call may return sometime after the window is ready for user input. The calling code
/// should not rely on this call to understand exactly when the window has become idle.
///
/// For now this method works reliably for both WinFX and Win32 Windows that are starting
/// up. However, if called at other times on WinFX Windows (e.g. during a long layout)
/// WaitForInputIdle may return true before the Window is actually idle. Additional work
/// needs to be done to detect when WinFX Windows are idle.
/// </remarks>
/// <param name="milliseconds">The amount of time, in milliseconds, to wait for the
/// associated process to become idle. The maximum is the largest possible value of a
/// 32-bit integer, which represents infinity to the operating system
/// </param>
/// <returns>
/// returns true if the window has reached the idle state and false if the timeout occurred.
/// </returns>
public bool WaitForInputIdle( int milliseconds )
{
return UiaCoreApi.WindowPattern_WaitForInputIdle(_hPattern, milliseconds);
}
#endregion Public Methods
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
#region Public Properties
/// <summary>
/// This member allows access to previously requested
/// cached properties for this element. The returned object
/// has accessors for each property defined for this pattern.
/// </summary>
/// <remarks>
/// Cached property values must have been previously requested
/// using a CacheRequest. If you try to access a cached
/// property that was not previously requested, an InvalidOperation
/// Exception will be thrown.
///
/// To get the value of a property at the current point in time,
/// access the property via the Current accessor instead of
/// Cached.
/// </remarks>
public WindowPatternInformation Cached
{
get
{
Misc.ValidateCached(_cached);
return new WindowPatternInformation(_el, true);
}
}
/// <summary>
/// This member allows access to current property values
/// for this element. The returned object has accessors for
/// each property defined for this pattern.
/// </summary>
/// <remarks>
/// This pattern must be from an AutomationElement with a
/// Full reference in order to get current values. If the
/// AutomationElement was obtained using AutomationElementMode.None,
/// then it contains only cached data, and attempting to get
/// the current value of any property will throw an InvalidOperationException.
///
/// To get the cached value of a property that was previously
/// specified using a CacheRequest, access the property via the
/// Cached accessor instead of Current.
/// </remarks>
public WindowPatternInformation Current
{
get
{
Misc.ValidateCurrent(_hPattern);
return new WindowPatternInformation(_el, false);
}
}
#endregion Public Properties
//------------------------------------------------------
//
// Internal Methods
//
//------------------------------------------------------
#region Internal Methods
internal static object Wrap(AutomationElement el, SafePatternHandle hPattern, bool cached)
{
return new WindowPattern(el, hPattern, cached);
}
#endregion Internal Methods
//------------------------------------------------------
//
// Private Fields
//
//------------------------------------------------------
#region Private Fields
private SafePatternHandle _hPattern;
private bool _cached;
#endregion Private Fields
//------------------------------------------------------
//
// Nested Classes
//
//------------------------------------------------------
#region Nested Classes
/// <summary>
/// This class provides access to either Cached or Current
/// properties on a pattern via the pattern's .Cached or
/// .Current accessors.
/// </summary>
public struct WindowPatternInformation
{
//------------------------------------------------------
//
// Constructors
//
//------------------------------------------------------
#region Constructors
internal WindowPatternInformation(AutomationElement el, bool useCache)
{
_el = el;
_useCache = useCache;
}
#endregion Constructors
//------------------------------------------------------
//
// Public Properties
//
//------------------------------------------------------
#region Public Properties
/// <summary>Is this window Maximizable</summary>
public bool CanMaximize
{
get
{
return (bool)_el.GetPatternPropertyValue(CanMaximizeProperty, _useCache);
}
}
/// <summary>Is this window Minimizable</summary>
public bool CanMinimize
{
get
{
return (bool)_el.GetPatternPropertyValue(CanMinimizeProperty, _useCache);
}
}
/// <summary>Is this is a modal window.</summary>
public bool IsModal
{
get
{
return (bool)_el.GetPatternPropertyValue(IsModalProperty, _useCache);
}
}
/// <summary>Is the Window Maximized, Minimized, or Normal (aka restored)</summary>
public WindowVisualState WindowVisualState
{
get
{
return (WindowVisualState)_el.GetPatternPropertyValue(WindowVisualStateProperty, _useCache);
}
}
/// <summary>Is the Window Closing, ReadyForUserInteraction, BlockedByModalWindow or NotResponding.</summary>
public WindowInteractionState WindowInteractionState
{
get
{
return (WindowInteractionState)_el.GetPatternPropertyValue(WindowInteractionStateProperty, _useCache);
}
}
/// <summary>Is this window is always on top</summary>
public bool IsTopmost
{
get
{
return (bool)_el.GetPatternPropertyValue(IsTopmostProperty, _useCache);
}
}
#endregion Public Properties
//------------------------------------------------------
//
// Private Fields
//
//------------------------------------------------------
#region Private Fields
private AutomationElement _el; // AutomationElement that contains the cache or live reference
private bool _useCache; // true to use cache, false to use live reference to get current values
#endregion Private Fields
}
#endregion Nested Classes
}
}
|