internal Window(IntPtr hWnd, string className, string displayName, string processName, int workspacesCount, bool is64BitProcess,
NativeMethods.WS originalStyle, NativeMethods.WS_EX originalExStyle, ProgramRule.Rule rule, ProgramRule programRule, IntPtr menu) :
base(hWnd)
{
IsFloating = rule.isFloating;
Titlebar = rule.titlebar;
InAltTabAndTaskbar = rule.inAltTabAndTaskbar;
WindowBorders = rule.windowBorders;
this.WorkspacesCount = workspacesCount;
this.DisplayName = displayName;
this.className = className;
this.processName = processName;
this.is64BitProcess = is64BitProcess;
redrawOnShow = rule.redrawOnShow;
ShowMenu = programRule.showMenu;
updateIcon = programRule.updateIcon;
onHiddenWindowShownAction = programRule.onHiddenWindowShownAction;
this.menu = menu;
this.hideFromAltTabAndTaskbarWhenOnInactiveWorkspace = rule.hideFromAltTabAndTaskbarWhenOnInactiveWorkspace;
this.originalStyle = originalStyle;
this.originalExStyle = originalExStyle;
windowPlacement = NativeMethods.WINDOWPLACEMENT.Default;
SavePosition();
originalWindowPlacement = windowPlacement;
this.customOwnedWindowMatchingFunction = programRule.customOwnedWindowMatchingFunction;
this.ownedWindows = new LinkedList <IntPtr>();
this.ownedWindows.AddFirst(hWnd);
}
internal Window(Window window) : base(window)
{
this.IsFloating = window.IsFloating;
this.Titlebar = window.Titlebar;
this.InAltTabAndTaskbar = window.InAltTabAndTaskbar;
this.WindowBorders = window.WindowBorders;
this.WorkspacesCount = window.WorkspacesCount;
this.DisplayName = window.DisplayName;
className = window.className;
processName = window.processName;
is64BitProcess = window.is64BitProcess;
redrawOnShow = window.redrawOnShow;
ShowMenu = window.ShowMenu;
updateIcon = window.updateIcon;
onHiddenWindowShownAction = window.onHiddenWindowShownAction;
menu = window.menu;
this.hideFromAltTabAndTaskbarWhenOnInactiveWorkspace = window.hideFromAltTabAndTaskbarWhenOnInactiveWorkspace;
this.originalStyle = window.originalStyle;
this.originalExStyle = window.originalExStyle;
windowPlacement = window.windowPlacement;
originalWindowPlacement = window.originalWindowPlacement;
this.customOwnedWindowMatchingFunction = window.customOwnedWindowMatchingFunction;
ownedWindows = window.ownedWindows;
}
private IntPtr OnNCCalcSize(IntPtr hwnd, IntPtr wParam, IntPtr lParam, ref bool handled)
{
NativeMethods.WINDOWPLACEMENT placement = NativeMethods.GetWindowPlacement(hwnd);
// Need to handle the maxmized case to remove the caption area or else when the window
// is maximized the default chrome will come back
if (placement.showCmd == NativeMethods.SW_SHOWMAXIMIZED)
{
NativeMethods.DefWindowProc(hwnd, NativeMethods.WM_NCCALCSIZE, wParam, lParam);
NativeMethods.RECT screenRect = (NativeMethods.RECT)Marshal.PtrToStructure(lParam, typeof(NativeMethods.RECT));
// Here is where we remove the caption height to hide the default window chrome
//
// SystemParameters.CaptionHeight is in logical units and needs to be converted to
// device units in order to work for all cases. As written, this only works for
// displays that are set at 100% scale factor.
screenRect.top -= (int)Math.Ceiling(SystemParameters.CaptionHeight + 1);
// TODO: Should handle when the task bar is auto-hidden, but that's left as an
// exercise to the reader.
Marshal.StructureToPtr(screenRect, lParam, fDeleteOld: true);
}
// In the non-maximized case, keep the default size, which will fill the window's
// entire rect with client area, allowing us to draw custom chrome. In both cases,
// don't call DefWindowProc, which would overwrite these values.
handled = true;
return(IntPtr.Zero);
}
internal Window(IntPtr hWnd, string className, string displayName, string processName, int workspacesCount, bool is64BitProcess,
NativeMethods.WS originalStyle, NativeMethods.WS_EX originalExStyle, ProgramRule.Rule rule, ProgramRule programRule, IntPtr menu)
: base(hWnd)
{
IsFloating = rule.isFloating;
Titlebar = rule.titlebar;
InAltTabAndTaskbar = rule.inAltTabAndTaskbar;
WindowBorders = rule.windowBorders;
this.WorkspacesCount = workspacesCount;
this.DisplayName = displayName;
this.className = className;
this.processName = processName;
this.is64BitProcess = is64BitProcess;
redrawOnShow = rule.redrawOnShow;
ShowMenu = programRule.showMenu;
updateIcon = programRule.updateIcon;
onHiddenWindowShownAction = programRule.onHiddenWindowShownAction;
this.menu = menu;
this.hideFromAltTabAndTaskbarWhenOnInactiveWorkspace = rule.hideFromAltTabAndTaskbarWhenOnInactiveWorkspace;
this.originalStyle = originalStyle;
this.originalExStyle = originalExStyle;
windowPlacement = NativeMethods.WINDOWPLACEMENT.Default;
SavePosition();
originalWindowPlacement = windowPlacement;
this.customOwnedWindowMatchingFunction = programRule.customOwnedWindowMatchingFunction;
this.ownedWindows = new LinkedList<IntPtr>();
this.ownedWindows.AddFirst(hWnd);
}
internal Window(Window window)
: base(window)
{
this.IsFloating = window.IsFloating;
this.Titlebar = window.Titlebar;
this.InAltTabAndTaskbar = window.InAltTabAndTaskbar;
this.WindowBorders = window.WindowBorders;
this.WorkspacesCount = window.WorkspacesCount;
this.DisplayName = window.DisplayName;
className = window.className;
processName = window.processName;
is64BitProcess = window.is64BitProcess;
redrawOnShow = window.redrawOnShow;
ShowMenu = window.ShowMenu;
updateIcon = window.updateIcon;
onHiddenWindowShownAction = window.onHiddenWindowShownAction;
menu = window.menu;
this.hideFromAltTabAndTaskbarWhenOnInactiveWorkspace = window.hideFromAltTabAndTaskbarWhenOnInactiveWorkspace;
this.originalStyle = window.originalStyle;
this.originalExStyle = window.originalExStyle;
windowPlacement = window.windowPlacement;
originalWindowPlacement = window.originalWindowPlacement;
this.customOwnedWindowMatchingFunction = window.customOwnedWindowMatchingFunction;
ownedWindows = window.ownedWindows;
}
private static void SetWindowPlacement(IntPtr hWnd, int cmdShow)
{
NativeMethods.WINDOWPLACEMENT windowPlacement = new NativeMethods.WINDOWPLACEMENT();
NativeMethods.GetWindowPlacement(hWnd, out windowPlacement);
windowPlacement.showCmd = cmdShow;
NativeMethods.SetWindowPlacement(hWnd, windowPlacement);
}
protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
{
ISite site = ParentInternal?.Site;
if (IsHandleCreated && (site == null || !site.DesignMode))
{
Rectangle oldBounds = Bounds;
base.SetBoundsCore(x, y, width, height, specified);
Rectangle newBounds = Bounds;
int yDelta = oldBounds.Height - newBounds.Height;
if (yDelta != 0)
{
// NOTE: This logic is to keep minimized MDI children anchored to
// the bottom left of the client area, normally they are anchored
// to the top right which just looks wierd!
//
NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT
{
length = Marshal.SizeOf <NativeMethods.WINDOWPLACEMENT>()
};
for (int i = 0; i < Controls.Count; i++)
{
Control ctl = Controls[i];
if (ctl != null && ctl is Form)
{
Form child = (Form)ctl;
// Only adjust the window position for visible MDI Child windows to prevent
// them from being re-displayed.
if (child.CanRecreateHandle() && child.WindowState == FormWindowState.Minimized)
{
UnsafeNativeMethods.GetWindowPlacement(new HandleRef(child, child.Handle), ref wp);
wp.ptMinPosition.Y -= yDelta;
if (wp.ptMinPosition.Y == -1)
{
if (yDelta < 0)
{
wp.ptMinPosition.Y = 0;
}
else
{
wp.ptMinPosition.Y = -2;
}
}
wp.flags = NativeMethods.WPF_SETMINPOSITION;
UnsafeNativeMethods.SetWindowPlacement(new HandleRef(child, child.Handle), ref wp);
wp.flags = 0;
}
}
}
}
}
else
{
base.SetBoundsCore(x, y, width, height, specified);
}
}
public static SW GetWindowState(IntPtr handle)
{
NativeMethods.WINDOWPLACEMENT placement = new NativeMethods.WINDOWPLACEMENT();
placement.Length = Marshal.SizeOf(placement);
NativeMethods.GetWindowPlacement(handle, ref placement);
SW state = (SW)placement.ShowCmd;
return(state);
}
/// <include file='doc\MDIClient.uex' path='docs/doc[@for="MdiClient.SetBoundsCore"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected override void SetBoundsCore(int x, int y, int width, int height, BoundsSpecified specified)
{
ISite site = (ParentInternal == null) ? null : ParentInternal.Site;
if (IsHandleCreated && (site == null || !site.DesignMode))
{
Rectangle oldBounds = Bounds;
base.SetBoundsCore(x, y, width, height, specified);
Rectangle newBounds = Bounds;
int yDelta = oldBounds.Height - newBounds.Height;
// NOTE: This logic is to keep minimized MDI children anchored to
// the bottom left of the client area, normally they are anchored
// to the top right which just looks wierd!
//
NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT();
wp.length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT));
for (int i = 0; i < Controls.Count; i++)
{
Control ctl = Controls[i];
if (ctl != null && ctl is Form)
{
Form child = (Form)ctl;
if (child.WindowState == FormWindowState.Minimized)
{
UnsafeNativeMethods.GetWindowPlacement(new HandleRef(child, child.Handle), ref wp);
wp.ptMinPosition_y -= yDelta;
if (wp.ptMinPosition_y == -1)
{
if (yDelta < 0)
{
wp.ptMinPosition_y = 0;
}
else
{
wp.ptMinPosition_y = -2;
}
}
wp.flags = NativeMethods.WPF_SETMINPOSITION;
UnsafeNativeMethods.SetWindowPlacement(new HandleRef(child, child.Handle), ref wp);
wp.flags = 0;
}
}
}
}
else
{
base.SetBoundsCore(x, y, width, height, specified);
}
}
private static void SaveWINDOWPLACEMENT(NativeMethods.WINDOWPLACEMENT value, IObjectData data, bool omitDefault)
{
// argument checks
Debug.Assert(data != null);
// save WINDOWPLACEMENT value
// there values are not omitted
data.SetInt32Value(SettingNames.Flags, value.Flags);
data.SetInt32Value(SettingNames.ShowCmd, value.ShowCmd);
data.SetObjectValue(SettingNames.MinPosition, value.MinPosition, SavePOINT);
data.SetObjectValue(SettingNames.MaxPosition, value.MaxPosition, SavePOINT);
data.SetObjectValue(SettingNames.NormalPosition, value.NormalPosition, SaveRECT);
return;
}
private static NativeMethods.WINDOWPLACEMENT CreateWINDOWPLACEMENT(IObjectData data)
{
// argument checks
Debug.Assert(data != null);
// create WINDOWPLACEMENT value
NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT();
wp.Flags = data.GetInt32Value(SettingNames.Flags, Defaults.Flags);
wp.ShowCmd = data.GetInt32Value(SettingNames.ShowCmd, Defaults.ShowCmd);
wp.MinPosition = data.GetObjectValue(SettingNames.MinPosition, Defaults.Point, CreatePOINT);
wp.MaxPosition = data.GetObjectValue(SettingNames.MaxPosition, Defaults.Point, CreatePOINT);
wp.NormalPosition = data.GetObjectValue(SettingNames.NormalPosition, Defaults.Rect, CreateRECT);
return(wp);
}
private bool SetWindowPlacement(NativeMethods.WINDOWPLACEMENT windowPlacement)
{
if (_form == null)
{
throw (new NullReferenceException("WindowPlacement.Form is not set."));
}
windowPlacement.length = (uint)Marshal.SizeOf(windowPlacement);
try
{
return(NativeMethods.SetWindowPlacement(_form.Handle, ref windowPlacement));
}
catch (Exception)
{
throw;
}
}
internal void RevertToInitialValues()
{
this.Titlebar = State.SHOWN;
this.InAltTabAndTaskbar = State.SHOWN;
this.WindowBorders = State.SHOWN;
Initialize();
if (!ShowMenu)
{
ToggleShowHideWindowMenu();
}
windowPlacement = originalWindowPlacement;
RestorePosition(false);
ShowAsync();
}
public static WindowState GetHwndState(IntPtr hWnd)
{
SecurityHelper.DemandUnmanagedCode();
SecurityHelper.DemandUIWindowPermission();
var placement = new NativeMethods.WINDOWPLACEMENT();
ThrowLastError(!SafeNativeMethods.GetWindowPlacement(hWnd, ref placement));
switch (placement.showCmd)
{
case NativeMethods.WindowState.SW_SHOWMINIMIZED: return(WindowState.Minimized);
case NativeMethods.WindowState.SW_SHOWMAXIMIZED: return(WindowState.Maximized);
}
return(WindowState.Normal);
}
bool OnParentWmWindowPosChanged(ref Message m, BaseWndProc baseProc)
{
if (this.ParentForm == null || this.ParentForm.IsHandleCreated == false)
{
return(false);
}
// recover the correct size of the parent window
// after the Form's WM_WINDOWPOSCHANGED handler messes it up.
// 1a. minimise FormWindowState.Normal, SW_SHOWMINIMIZED
// 1b. maximise FormWindowState.Maximized, SW_SHOWMAXIMIZED
// 2. restore (ignore) FormWindowState.Minimized, SW_SHOWMINIMIZED
// 3. reentrant (<<here) FormWindowState.Normal, SW_SHOWNORMAL
var parentForm = this.ParentForm;
var wp = new NativeMethods.WINDOWPLACEMENT();
wp.length = Marshal.SizeOf(typeof(NativeMethods.WINDOWPLACEMENT));
UnsafeNativeMethods.GetWindowPlacement(this.ParentForm.Handle, ref wp);
var saveSize = (wp.showCmd == NativeMethods.SW_SHOWMINIMIZED) ||
(wp.showCmd == NativeMethods.SW_SHOWMAXIMIZED);
if (saveSize)
{
this.restoredWindowSize = wp.rcNormalPosition.ToRectangle().Size;
this.restoredSizeSaved = true;
}
var stage2 = parentForm.WindowState == FormWindowState.Minimized && wp.showCmd == NativeMethods.SW_SHOWMINIMIZED;
var stage3 = parentForm.WindowState == FormWindowState.Normal && wp.showCmd == NativeMethods.SW_SHOWNORMAL;
baseProc(ref m);
if (this.restoredSizeSaved && stage3)
{
this.restoredSizeSaved = false;
//parentForm.Refresh();
parentForm.Size = this.restoredWindowSize;
}
else if (stage2)
{
}
return(true);
}
private NativeMethods.WINDOWPLACEMENT GetWindowPlacement()
{
if (_form == null)
{
throw (new NullReferenceException("WindowPlacement.Form is not set."));
}
NativeMethods.WINDOWPLACEMENT windowPlacement = new NativeMethods.WINDOWPLACEMENT();
windowPlacement.length = (uint)Marshal.SizeOf(windowPlacement);
try
{
NativeMethods.GetWindowPlacement(_form.Handle, ref windowPlacement);
return windowPlacement;
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Gets the window style.
/// </summary>
/// <returns>The style currently applied to the ie window.</returns>
public NativeMethods.WindowShowStyle GetWindowStyle()
{
NativeMethods.WINDOWPLACEMENT placement = new NativeMethods.WINDOWPLACEMENT();
placement.length = Marshal.SizeOf(placement);
NativeMethods.GetWindowPlacement(hWnd, ref placement);
return (NativeMethods.WindowShowStyle) placement.showCmd;
}
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;
}
// The showCmd flag retreived by GetWindowPlacement is SW_SHOWMAXIMIZED when the window is maximized.
// If the window is minimized, showCmd is SW_SHOWMINIMIZED. Otherwise, it is SW_SHOWNORMAL, regardless
// of the window's visibility.
// SetWindowPlacement with SW_SHOWMAXIMIZED and SW_SHOWMINIMIZED will cause a hidden window to show.
// To workaround this issue, we check whether the current window is hidden and set showCmd to SW_HIDE if it is.
if (!this._isVisible)
{
wp.showCmd = NativeMethods.SW_HIDE;
}
UnsafeNativeMethods.SetWindowPlacement(new HandleRef(this, CriticalHandle), ref wp);
}
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 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);
}
internal static extern int GetWindowPlacement(IntPtr hwnd, ref NativeMethods.WINDOWPLACEMENT lpwndpl);
internal void RevertToInitialValues()
{
this.Titlebar = State.SHOWN;
this.InAltTabAndTaskbar = State.SHOWN;
this.WindowBorders = State.SHOWN;
Initialize();
if (!ShowMenu)
{
ToggleShowHideWindowMenu();
}
windowPlacement = originalWindowPlacement;
RestorePosition(false);
ShowAsync();
}
public static SW GetWindowState(IntPtr handle)
{
NativeMethods.WINDOWPLACEMENT placement = new NativeMethods.WINDOWPLACEMENT();
placement.Length = Marshal.SizeOf(placement);
NativeMethods.GetWindowPlacement(handle, ref placement);
SW state = (SW)placement.ShowCmd;
return state;
}
/// <summary>
/// Returns whether a window is normal (1), minimized (2), or maximized (3).
/// </summary>
/// <param name="hWnd">The handle of the window.</param>
private NativeMethods.WindowShowStyle GetWindowShowStyle(IntPtr hWnd)
{
NativeMethods.WINDOWPLACEMENT placement = new NativeMethods.WINDOWPLACEMENT();
NativeMethods.GetWindowPlacement(hWnd, ref placement);
return(placement.showCmd);
}
/// <summary>
/// Attach to client's message loop, restore window if minimized, and bring window forward.
/// </summary>
public bool PrepareWindowForInput()
{
NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT();
uint thread = NativeMethods.GetCurrentThreadId();
if (NativeMethods.AttachThreadInput(thread, this.ThreadID, true))
{
if (NativeMethods.GetWindowPlacement(this.WindowHandle, ref wp))
{
if (wp.showCmd == NativeMethods.SW_SHOWMINIMIZED)
{
wp.showCmd = NativeMethods.SW_SHOWDEFAULT;
if (!NativeMethods.SetWindowPlacement(this.WindowHandle, ref wp))
return false;
}
return NativeMethods.SetForegroundWindow(this.WindowHandle);
}
}
return false;
}
public static bool IsWindowMaximized(IntPtr handle)
{
NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT();
NativeMethods.GetWindowPlacement(handle, ref wp);
return wp.showCmd == (int)NativeMethods.SHOWWINDOW.SW_MAXIMIZE;
}
public static extern bool GetWindowPlacement(IntPtr hwnd, ref NativeMethods.WINDOWPLACEMENT lpwndpl);
/// <summary>
/// Returns whether a window is normal (1), minimized (2), or maximized (3).
/// </summary>
/// <param name="hWnd">The handle of the window.</param>
public int GetWindowPlacement(IntPtr hWnd)
{
NativeMethods.WINDOWPLACEMENT placement = new NativeMethods.WINDOWPLACEMENT();
NativeMethods.GetWindowPlacement(hWnd, ref placement);
return(placement.showCmd);
}
/// <summary>
/// Send mouse click to relative position in the client window.
/// </summary>
/// <param name="client">Target client.</param>
/// <param name="button">System.Windows.Forms.MouseButtons to click.</param>
/// <param name="x">X position of point to click relative to client window's X position.</param>
/// <param name="y">Y position of point to click relative to client window's Y position.</param>
/// <param name="doubleClick">True for double click, false for single click.</param>
/// <returns>True on success.</returns>
public static bool SendMouseClick(int client, MouseButtons button, int x, int y, bool doubleClick)
{
ClientInfo ci;
if (ClientInfoCollection.GetClient(client, out ci))
{
NativeMethods.INPUT[] inputs = new NativeMethods.INPUT[2];
NativeMethods.MOUSEINPUT mi = new NativeMethods.MOUSEINPUT();
inputs[0].type = NativeMethods.INPUT_MOUSE;
inputs[1].type = NativeMethods.INPUT_MOUSE;
mi.dx = 0;
mi.dy = 0;
switch (button)
{
case MouseButtons.None:
return(false);
case MouseButtons.Left:
mi.dwFlags = NativeMethods.MOUSEEVENTF_LEFTDOWN;
inputs[0].mkhi.mi = mi;
mi.dwFlags = NativeMethods.MOUSEEVENTF_LEFTUP;
inputs[1].mkhi.mi = mi;
break;
case MouseButtons.Right:
mi.dwFlags = NativeMethods.MOUSEEVENTF_RIGHTDOWN;
inputs[0].mkhi.mi = mi;
mi.dwFlags = NativeMethods.MOUSEEVENTF_RIGHTUP;
inputs[1].mkhi.mi = mi;
break;
case MouseButtons.Middle:
mi.dwFlags = NativeMethods.MOUSEEVENTF_MIDDLEDOWN;
inputs[0].mkhi.mi = mi;
mi.dwFlags = NativeMethods.MOUSEEVENTF_MIDDLEUP;
inputs[1].mkhi.mi = mi;
break;
case MouseButtons.XButton1:
mi.mouseData = NativeMethods.XBUTTON1;
mi.dwFlags = NativeMethods.MOUSEEVENTF_XDOWN;
inputs[0].mkhi.mi = mi;
mi.dwFlags = NativeMethods.MOUSEEVENTF_XUP;
inputs[1].mkhi.mi = mi;
break;
case MouseButtons.XButton2:
mi.mouseData = NativeMethods.XBUTTON2;
mi.dwFlags = NativeMethods.MOUSEEVENTF_XDOWN;
inputs[0].mkhi.mi = mi;
mi.dwFlags = NativeMethods.MOUSEEVENTF_XUP;
inputs[1].mkhi.mi = mi;
break;
}
if (!ci.PrepareWindowForInput())
{
ci.DetachFromWindow();
return(false);
}
NativeMethods.WINDOWPLACEMENT wp = new NativeMethods.WINDOWPLACEMENT();
if (NativeMethods.GetWindowPlacement(ci.WindowHandle, ref wp))
{
/*int screenX = wp.rcNormalPosition.X + x;
* int screenY = wp.rcNormalPosition.Y + y;
* int absX = (screenX * 65536 / Screen.PrimaryScreen.Bounds.Width);
* int absY = (screenY * 65536 / Screen.PrimaryScreen.Bounds.Height);
* inputs[0].mkhi.mi.dx = absX;
* inputs[1].mkhi.mi.dx = absX;
* inputs[0].mkhi.mi.dy = absY;
* inputs[1].mkhi.mi.dy = absY;*/
// using this method because absolute position is always off by a pixel or 2
if (!NativeMethods.SetCursorPos(x + wp.rcNormalPosition.X, y + wp.rcNormalPosition.Y))
{
return(false);
}
}
else
{
return(false);
}
uint success = NativeMethods.SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(inputs[0]));
if (doubleClick && success == inputs.Length)
{
success = NativeMethods.SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(inputs[0]));
}
ci.DetachFromWindow();
return(success == inputs.Length);
}
return(false);
}
