1084 lines
39 KiB
C#
1084 lines
39 KiB
C#
using System;
|
|
using System.Text;
|
|
using System.Drawing;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace DevComponents.DotNetBar
|
|
{
|
|
internal class WinApi
|
|
{
|
|
#region Windows Messages
|
|
public enum WindowsMessages
|
|
{
|
|
WM_DESTROY = 0x0002,
|
|
WM_NCPAINT = 0x0085,
|
|
WM_NCCALCSIZE = 0x0083,
|
|
WM_NCACTIVATE = 0x0086,
|
|
WM_SETTEXT = 0x000C,
|
|
WM_INITMENUPOPUP = 0x0117,
|
|
WM_WINDOWPOSCHANGED = 0x0047,
|
|
WM_NCHITTEST = 0x0084,
|
|
WM_ERASEBKGND = 0x0014,
|
|
WM_NCMOUSEMOVE = 0xA0,
|
|
WM_NCLBUTTONDOWN = 0xA1,
|
|
WM_NCMOUSELEAVE = 0x2A2,
|
|
WM_NCLBUTTONUP = 0xA2,
|
|
WM_NCMOUSEHOVER = 0x2A0,
|
|
WM_SETCURSOR = 0x20,
|
|
WM_SETICON = 0x0080,
|
|
WM_HSCROLL = 0x0114,
|
|
WM_VSCROLL = 0x115,
|
|
WM_MOUSEWHEEL = 0x020A,
|
|
WM_STYLECHANGING = 0x007C,
|
|
WM_STYLECHANGED = 0x7D,
|
|
WM_NCLBUTTONDBLCLK = 0xA3,
|
|
WM_MOUSEACTIVATE = 0x21,
|
|
WM_MOUSEMOVE = 0x0200,
|
|
WM_MDISETMENU = 0x230,
|
|
WM_MDIREFRESHMENU = 0x234,
|
|
WM_KEYDOWN = 0x0100,
|
|
WM_SIZE = 0x5,
|
|
WM_DWMCOMPOSITIONCHANGED = 0x031E,
|
|
WM_DRAWITEM = 0x002B,
|
|
SBM_SETPOS = 0x00E0,
|
|
SBM_SETSCROLLINFO = 0x00E9,
|
|
EM_GETMODIFY = 0x00B8,
|
|
EM_SETMODIFY = 0x00B9,
|
|
WM_LBUTTONUP = 0x0202,
|
|
WM_LBUTTONDOWN = 0x0201,
|
|
WM_LBUTTONDBLCLK = 0x0203,
|
|
WM_SYSTIMER = 0x0118,
|
|
WM_SETFOCUS = 0x0007,
|
|
WM_KILLFOCUS = 0x0008,
|
|
WM_PAINT = 0x000F,
|
|
WM_COMMAND = 0x0111,
|
|
WM_CTLCOLORBTN = 0x0135,
|
|
WM_CTLCOLORSCROLLBAR = 0x0137,
|
|
WM_MDIACTIVATE = 0x222,
|
|
WM_CAPTURECHANGED = 0x0215,
|
|
CB_GETDROPPEDSTATE = 0x0157,
|
|
WVR_VALIDRECTS = 0x400,
|
|
WM_GETMINMAXINFO = 0x0024,
|
|
WM_APPCOMMAND = 0x0319,
|
|
WM_USER = 0x0400,
|
|
WM_REFLECT = WM_USER + 0x1C00,
|
|
WM_REFLECTCOMMAND = WM_REFLECT + WM_COMMAND,
|
|
WM_DPICHANGED = 0x02E0,
|
|
WM_SETREDRAW=0x000B,
|
|
WM_MOVE=0x3
|
|
}
|
|
|
|
public enum ComboNotificationCodes : int
|
|
{
|
|
CBN_DROPDOWN = 7,
|
|
CBN_CLOSEUP = 8
|
|
}
|
|
|
|
public enum MouseKeyState : int
|
|
{
|
|
MK_LBUTTON = 0x0001,
|
|
MK_RBUTTON = 0x0002,
|
|
MK_SHIFT = 0x0004,
|
|
MK_CONTROL = 0x0008,
|
|
MK_MBUTTON = 0x0010,
|
|
MK_XBUTTON1 = 0x0020,
|
|
MK_XBUTTON2 = 0x0040
|
|
|
|
}
|
|
|
|
/// <summary>Options available when a form is tested for mose positions.</summary>
|
|
public enum WindowHitTestRegions
|
|
{
|
|
/// <summary>HTERROR: On the screen background or on a dividing line between windows
|
|
/// (same as HTNOWHERE, except that the DefWindowProc function produces a system
|
|
/// beep to indicate an error).</summary>
|
|
Error = -2,
|
|
/// <summary>HTTRANSPARENT: In a window currently covered by another window in the
|
|
/// same thread (the message will be sent to underlying windows in the same thread
|
|
/// until one of them returns a code that is not HTTRANSPARENT).</summary>
|
|
TransparentOrCovered = -1,
|
|
/// <summary>HTNOWHERE: On the screen background or on a dividing line between
|
|
/// windows.</summary>
|
|
NoWhere = 0,
|
|
/// <summary>HTCLIENT: In a client area.</summary>
|
|
ClientArea = 1,
|
|
/// <summary>HTCAPTION: In a title bar.</summary>
|
|
TitleBar = 2,
|
|
/// <summary>HTSYSMENU: In a window menu or in a Close button in a child window.</summary>
|
|
SystemMenu = 3,
|
|
/// <summary>HTGROWBOX: In a size box (same as HTSIZE).</summary>
|
|
GrowBox = 4,
|
|
/// <summary>HTMENU: In a menu.</summary>
|
|
Menu = 5,
|
|
/// <summary>HTHSCROLL: In a horizontal scroll bar.</summary>
|
|
HorizontalScrollBar = 6,
|
|
/// <summary>HTVSCROLL: In the vertical scroll bar.</summary>
|
|
VerticalScrollBar = 7,
|
|
/// <summary>HTMINBUTTON: In a Minimize button. </summary>
|
|
MinimizeButton = 8,
|
|
/// <summary>HTMAXBUTTON: In a Maximize button.</summary>
|
|
MaximizeButton = 9,
|
|
/// <summary>HTLEFT: In the left border of a resizable window (the user can click
|
|
/// the mouse to resize the window horizontally).</summary>
|
|
LeftSizeableBorder = 10,
|
|
/// <summary>HTRIGHT: In the right border of a resizable window (the user can click
|
|
/// the mouse to resize the window horizontally).</summary>
|
|
RightSizeableBorder = 11,
|
|
/// <summary>HTTOP: In the upper-horizontal border of a window.</summary>
|
|
TopSizeableBorder = 12,
|
|
/// <summary>HTTOPLEFT: In the upper-left corner of a window border.</summary>
|
|
TopLeftSizeableCorner = 13,
|
|
/// <summary>HTTOPRIGHT: In the upper-right corner of a window border.</summary>
|
|
TopRightSizeableCorner = 14,
|
|
/// <summary>HTBOTTOM: In the lower-horizontal border of a resizable window (the
|
|
/// user can click the mouse to resize the window vertically).</summary>
|
|
BottomSizeableBorder = 15,
|
|
/// <summary>HTBOTTOMLEFT: In the lower-left corner of a border of a resizable
|
|
/// window (the user can click the mouse to resize the window diagonally).</summary>
|
|
BottomLeftSizeableCorner = 16,
|
|
/// <summary>HTBOTTOMRIGHT: In the lower-right corner of a border of a resizable
|
|
/// window (the user can click the mouse to resize the window diagonally).</summary>
|
|
BottomRightSizeableCorner = 17,
|
|
/// <summary>HTBORDER: In the border of a window that does not have a sizing
|
|
/// border.</summary>
|
|
NonSizableBorder = 18,
|
|
/// <summary>HTOBJECT: Unknown...No Documentation Found</summary>
|
|
Object = 19,
|
|
/// <summary>HTCLOSE: In a Close button.</summary>
|
|
CloseButton = 20,
|
|
/// <summary>HTHELP: In a Help button.</summary>
|
|
HelpButton = 21,
|
|
/// <summary>HTSIZE: In a size box (same as HTGROWBOX). (Same as GrowBox).</summary>
|
|
SizeBox = GrowBox,
|
|
/// <summary>HTREDUCE: In a Minimize button. (Same as MinimizeButton).</summary>
|
|
ReduceButton = MaximizeButton,
|
|
/// <summary>HTZOOM: In a Maximize button. (Same as MaximizeButton).</summary>
|
|
ZoomButton = MaximizeButton,
|
|
}
|
|
|
|
public enum GWL
|
|
{
|
|
GWL_WNDPROC = (-4),
|
|
GWL_HINSTANCE = (-6),
|
|
GWL_HWNDPARENT = (-8),
|
|
GWL_STYLE = (-16),
|
|
GWL_EXSTYLE = (-20),
|
|
GWL_USERDATA = (-21),
|
|
GWL_ID = (-12)
|
|
}
|
|
|
|
public enum RedrawWindowFlags : uint
|
|
{
|
|
RDW_INVALIDATE = 0x0001,
|
|
RDW_INTERNALPAINT = 0x0002,
|
|
RDW_ERASE = 0x0004,
|
|
RDW_VALIDATE = 0x0008,
|
|
RDW_NOINTERNALPAINT = 0x0010,
|
|
RDW_NOERASE = 0x0020,
|
|
RDW_NOCHILDREN = 0x0040,
|
|
RDW_ALLCHILDREN = 0x0080,
|
|
RDW_UPDATENOW = 0x0100,
|
|
RDW_ERASENOW = 0x0200,
|
|
RDW_FRAME = 0x0400,
|
|
RDW_NOFRAME = 0x0800
|
|
}
|
|
[Flags()]
|
|
public enum WindowStyles
|
|
{
|
|
WS_VISIBLE = 0x10000000,
|
|
WS_CAPTION = 0x00C00000,
|
|
WS_BORDER = 0x800000,
|
|
WS_DLGFRAME = 0x400000,
|
|
WS_THICKFRAME = 0x00040000,
|
|
WS_HSCROLL = 0x100000,
|
|
WS_VSCROLL = 0x200000
|
|
}
|
|
#endregion
|
|
|
|
#region Windows API
|
|
[DllImport("user32", EntryPoint = "SetWindowLongPtr")]
|
|
public static extern IntPtr SubclassWindow64(IntPtr hWnd, GWL nIndex, WindowProcDelegate dwNewLong);
|
|
[DllImport("user32", EntryPoint = "SetWindowLong")]
|
|
public static extern IntPtr SubclassWindow(IntPtr hWnd, GWL nIndex, WindowProcDelegate dwNewLong);
|
|
[DllImport("user32", EntryPoint = "SetWindowLongPtr")]
|
|
public static extern IntPtr SubclassWindow64(IntPtr hWnd, GWL nIndex, IntPtr dwNewLong);
|
|
[DllImport("user32", EntryPoint = "SetWindowLong")]
|
|
public static extern IntPtr SubclassWindow(IntPtr hWnd, GWL nIndex, IntPtr dwNewLong);
|
|
[DllImport("user32.dll", CharSet = CharSet.Auto)]
|
|
public static extern uint CallWindowProc(IntPtr prevWndFunc, IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam);
|
|
public delegate uint WindowProcDelegate(IntPtr hWnd, int msg, IntPtr wparam, IntPtr lparam);
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern bool EnableMenuItem(IntPtr hMenu, uint uIDEnableItem, uint uEnable);
|
|
|
|
public static char ToAscii(uint virtualKey)
|
|
{
|
|
StringBuilder outputBuilder = new StringBuilder(2);
|
|
byte[] keyState = new byte[256];
|
|
NativeFunctions.GetKeyboardState(keyState);
|
|
int result = ToAscii(virtualKey, 0, keyState,
|
|
outputBuilder, 0);
|
|
if (result == 1)
|
|
return outputBuilder[0];
|
|
else
|
|
return '\0';
|
|
}
|
|
[DllImport("user32.dll")]
|
|
private static extern int ToAscii(uint uVirtKey, uint uScanCode, byte[] lpKeyState, [Out] StringBuilder lpChar, uint uFlags);
|
|
[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
|
|
public static extern short GetKeyState(int keyCode);
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern bool IsZoomed(IntPtr hWnd);
|
|
//[DllImport("user32.dll")]
|
|
//public static extern bool GetClientRect(IntPtr hWnd, out RECT lpRect);
|
|
|
|
[System.Runtime.InteropServices.DllImport("User32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
|
|
public static extern IntPtr BeginPaint(IntPtr hWnd, ref PAINTSTRUCT ps);
|
|
|
|
[System.Runtime.InteropServices.DllImport("User32.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto)]
|
|
public static extern bool EndPaint(IntPtr hWnd, ref PAINTSTRUCT ps);
|
|
|
|
[DllImport("gdi32.dll")]
|
|
public static extern int ExcludeClipRect(IntPtr hdc, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
|
|
|
|
[DllImport("user32")]
|
|
public static extern int SendMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
|
|
[DllImport("user32")]
|
|
public static extern int SendMessage(IntPtr hWnd, int Msg, int wParam, int lParam);
|
|
|
|
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
|
|
public static extern bool GetTextMetrics(HandleRef hdc, TEXTMETRIC tm);
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern bool SetMenu(IntPtr hWnd, IntPtr hMenu);
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern IntPtr GetMenu(IntPtr hWnd);
|
|
|
|
[DllImport("user32")]
|
|
public static extern bool RedrawWindow(IntPtr hWnd, [In] ref RECT lprcUpdate, IntPtr hrgnUpdate, RedrawWindowFlags flags);
|
|
[DllImport("user32")]
|
|
public static extern bool RedrawWindow(IntPtr hWnd, IntPtr lprcUpdate, IntPtr hrgnUpdate, RedrawWindowFlags flags);
|
|
|
|
[DllImport("user32")]
|
|
public static extern bool GetWindowRect(IntPtr hWnd, ref RECT r);
|
|
|
|
[DllImport("user32.dll", SetLastError = true, EntryPoint = "GetScrollBarInfo")]
|
|
public static extern int GetScrollBarInfo(IntPtr hWnd, uint idObject, ref SCROLLBARINFO psbi);
|
|
|
|
public enum SBOrientation : int
|
|
{
|
|
SB_HORZ = 0x0,
|
|
SB_VERT = 0x1,
|
|
SB_CTL = 0x2,
|
|
SB_BOTH = 0x3
|
|
}
|
|
[Flags()]
|
|
internal enum ScrollInfoMask:int
|
|
{
|
|
SIF_RANGE = 0x0001,
|
|
SIF_PAGE = 0x0002,
|
|
SIF_POS = 0x0004,
|
|
SIF_DISABLENOSCROLL = 0x0008,
|
|
SIF_TRACKPOS = 0x0010,
|
|
SIF_ALL = (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)
|
|
}
|
|
public enum ScrollBarCommands
|
|
{
|
|
SB_LINEUP = 0,
|
|
SB_LINELEFT = 0,
|
|
SB_LINEDOWN = 1,
|
|
SB_LINERIGHT = 1,
|
|
SB_PAGEUP = 2,
|
|
SB_PAGELEFT = 2,
|
|
SB_PAGEDOWN = 3,
|
|
SB_PAGERIGHT = 3,
|
|
SB_THUMBPOSITION = 4,
|
|
SB_THUMBTRACK = 5,
|
|
SB_TOP = 6,
|
|
SB_LEFT = 6,
|
|
SB_BOTTOM = 7,
|
|
SB_RIGHT = 7,
|
|
SB_ENDSCROLL = 8
|
|
}
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool GetScrollInfo(IntPtr hwnd, SBOrientation fnBar, ref SCROLLINFO lpsi);
|
|
|
|
[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
|
|
public static extern int SetScrollInfo(IntPtr hWnd, SBOrientation fnBar, ref SCROLLINFO si, bool redraw);
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern IntPtr GetWindowDC(IntPtr hWnd);
|
|
[DllImport("user32.dll")]
|
|
public static extern int ReleaseDC(IntPtr hWnd, IntPtr hDC);
|
|
|
|
[DllImport("user32.dll")]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
public static extern bool SetForegroundWindow(IntPtr hWnd);
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern bool AdjustWindowRectEx(ref RECT lpRect, int dwStyle,
|
|
bool bMenu, int dwExStyle);
|
|
|
|
// This static method is required because legacy OSes do not support
|
|
// GetWindowLongPtr
|
|
public static IntPtr GetWindowLongPtr(IntPtr hWnd, int nIndex)
|
|
{
|
|
if (IntPtr.Size == 8)
|
|
return GetWindowLongPtr64(hWnd, nIndex);
|
|
else
|
|
return new IntPtr(GetWindowLong32(hWnd, nIndex));
|
|
}
|
|
|
|
[DllImport("user32.dll", EntryPoint = "GetWindowLong")]
|
|
public static extern int GetWindowLong32(IntPtr hWnd, int nIndex);
|
|
|
|
[DllImport("user32.dll", EntryPoint = "GetWindowLongPtr")]
|
|
public static extern IntPtr GetWindowLongPtr64(IntPtr hWnd, int nIndex);
|
|
|
|
[DllImport("user32.dll")]
|
|
public static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);
|
|
|
|
public static IntPtr SetWindowLongPtr(IntPtr hwnd, int nIndex, IntPtr dwNewLong)
|
|
{
|
|
if (IntPtr.Size == 8)
|
|
{
|
|
return SetWindowLongPtr64(hwnd, nIndex, dwNewLong);
|
|
}
|
|
return new IntPtr(SetWindowLongPtr32(hwnd, nIndex, dwNewLong.ToInt32()));
|
|
}
|
|
[DllImport("user32.dll", EntryPoint = "SetWindowLong", SetLastError = true)]
|
|
private static extern int SetWindowLongPtr32(IntPtr hWnd, int nIndex, int dwNewLong);
|
|
[DllImport("user32.dll", EntryPoint = "SetWindowLongPtr", SetLastError = true)]
|
|
private static extern IntPtr SetWindowLongPtr64(IntPtr hWnd, int nIndex, IntPtr dwNewLong);
|
|
|
|
[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
|
|
public static extern int MapWindowPoints(IntPtr hwndFrom, IntPtr hwndTo, ref POINT lpPoints, [MarshalAs(UnmanagedType.U4)] int cPoints);
|
|
|
|
[DllImport("user32")]
|
|
public static extern bool PostMessage(int hWnd, int Msg, int wParam, int lParam);
|
|
[DllImport("user32")]
|
|
public static extern bool PostMessage(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
|
|
|
|
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
|
|
public static extern bool DeleteDC(IntPtr hDC);
|
|
|
|
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
|
|
public static extern IntPtr SelectObject(IntPtr hDC, IntPtr hObject);
|
|
|
|
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
|
|
public static extern IntPtr CreateCompatibleDC(IntPtr hDC);
|
|
|
|
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
|
|
public static extern IntPtr CreateDIBSection(IntPtr hdc, BITMAPINFO pbmi, uint iUsage, int ppvBits, IntPtr hSection, uint dwOffset);
|
|
|
|
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
|
|
public static extern bool BitBlt(IntPtr hdc, int nXDest, int nYDest, int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc, uint dwRop);
|
|
|
|
[DllImport("gdi32")]
|
|
public static extern bool DeleteObject(IntPtr hObject);
|
|
[DllImport("gdi32")]
|
|
public static extern bool DeleteObject(int hObject);
|
|
|
|
public delegate void TimerDelegate(IntPtr hWnd, IntPtr uMsg, IntPtr idEvent, int dwTime);
|
|
[DllImport("user32.dll")]
|
|
public static extern UIntPtr SetTimer(IntPtr hWnd, UIntPtr nIDEvent, uint uElapse, TimerDelegate lpTimerFunc);
|
|
[DllImport("user32.dll")]
|
|
public static extern bool KillTimer(IntPtr hWnd, UIntPtr uIDEvent);
|
|
|
|
//[DllImport("gdi32.dll")]
|
|
//public static extern int CombineRgn(IntPtr hrgnDest, IntPtr hrgnSrc1, IntPtr hrgnSrc2, CombineRgnStyles fnCombineMode);
|
|
//public enum CombineRgnStyles : int
|
|
//{
|
|
// RGN_AND = 1,
|
|
// RGN_OR = 2,
|
|
// RGN_XOR = 3,
|
|
// RGN_DIFF = 4,
|
|
// RGN_COPY = 5,
|
|
// RGN_MIN = RGN_AND,
|
|
// RGN_MAX = RGN_COPY
|
|
//}
|
|
//[DllImport("gdi32.dll")]
|
|
//public static extern IntPtr CreateRectRgn(int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
|
|
|
|
internal static bool ModifyHwndStyle(IntPtr hwnd, int removeStyle, int addStyle)
|
|
{
|
|
int curWindowStyle = GetWindowLongPtr(hwnd, (int)GWL.GWL_STYLE).ToInt32();
|
|
int newStyle = (curWindowStyle & ~removeStyle) | addStyle;
|
|
if (curWindowStyle == newStyle)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
SetWindowLong(hwnd, (int)GWL.GWL_STYLE, newStyle);
|
|
return true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Structures
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
public class STYLESTRUCT
|
|
{
|
|
public uint styleOld;
|
|
public uint styleNew;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
|
|
public class TEXTMETRIC
|
|
{
|
|
public int tmHeight;
|
|
public int tmAscent;
|
|
public int tmDescent;
|
|
public int tmInternalLeading;
|
|
public int tmExternalLeading;
|
|
public int tmAveCharWidth;
|
|
public int tmMaxCharWidth;
|
|
public int tmWeight;
|
|
public int tmOverhang;
|
|
public int tmDigitizedAspectX;
|
|
public int tmDigitizedAspectY;
|
|
public char tmFirstChar;
|
|
public char tmLastChar;
|
|
public char tmDefaultChar;
|
|
public char tmBreakChar;
|
|
public byte tmItalic;
|
|
public byte tmUnderlined;
|
|
public byte tmStruckOut;
|
|
public byte tmPitchAndFamily;
|
|
public byte tmCharSet;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct SCROLLBARINFO
|
|
{
|
|
public int cbSize;
|
|
public RECT rcScrollBar;
|
|
public int dxyLineButton;
|
|
public int xyThumbTop;
|
|
public int xyThumbBottom;
|
|
public int reserved;
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
|
|
public int[] rgstate;
|
|
}
|
|
|
|
public enum eScrollBarDirection
|
|
{
|
|
SB_HORZ = 0,
|
|
SB_VERT = 1
|
|
}
|
|
|
|
public enum eScrollInfoMask
|
|
{
|
|
SIF_RANGE = 0x1,
|
|
SIF_PAGE = 0x2,
|
|
SIF_POS = 0x4,
|
|
SIF_DISABLENOSCROLL = 0x8,
|
|
SIF_TRACKPOS = 0x10,
|
|
SIF_ALL = SIF_RANGE + SIF_PAGE + SIF_POS + SIF_TRACKPOS
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct SCROLLINFO
|
|
{
|
|
public int cbSize;
|
|
public ScrollInfoMask fMask;
|
|
public int nMin;
|
|
public int nMax;
|
|
public int nPage;
|
|
public int nPos;
|
|
public int nTrackPos;
|
|
public override string ToString()
|
|
{
|
|
return string.Format("nMin={0}, nMax={1}, nPage={2}, nPos={3}, nTrackPos={4}",
|
|
nMin, nMax, nPage, nPos, nTrackPos);
|
|
}
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct POINT
|
|
{
|
|
public int x;
|
|
public int y;
|
|
|
|
public POINT(System.Drawing.Point p)
|
|
{
|
|
this.x = p.X;
|
|
this.y = p.Y;
|
|
}
|
|
public POINT(int x, int y)
|
|
{
|
|
this.x = x;
|
|
this.y = y;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return string.Format("{0},{1}", x, y);
|
|
}
|
|
}
|
|
public enum ShowWindowCommands : int
|
|
{
|
|
/// <summary>
|
|
/// Hides the window and activates another window.
|
|
/// </summary>
|
|
Hide = 0,
|
|
/// <summary>
|
|
/// Activates and displays a window. If the window is minimized or
|
|
/// maximized, the system restores it to its original size and position.
|
|
/// An application should specify this flag when displaying the window
|
|
/// for the first time.
|
|
/// </summary>
|
|
Normal = 1,
|
|
/// <summary>
|
|
/// Activates the window and displays it as a minimized window.
|
|
/// </summary>
|
|
ShowMinimized = 2,
|
|
/// <summary>
|
|
/// Maximizes the specified window.
|
|
/// </summary>
|
|
Maximize = 3, // is this the right value?
|
|
/// <summary>
|
|
/// Activates the window and displays it as a maximized window.
|
|
/// </summary>
|
|
ShowMaximized = 3,
|
|
/// <summary>
|
|
/// Displays a window in its most recent size and position. This value
|
|
/// is similar to <see cref="Win32.ShowWindowCommand.Normal"/>, except
|
|
/// the window is not actived.
|
|
/// </summary>
|
|
ShowNoActivate = 4,
|
|
/// <summary>
|
|
/// Activates the window and displays it in its current size and position.
|
|
/// </summary>
|
|
Show = 5,
|
|
/// <summary>
|
|
/// Minimizes the specified window and activates the next top-level
|
|
/// window in the Z order.
|
|
/// </summary>
|
|
Minimize = 6,
|
|
/// <summary>
|
|
/// Displays the window as a minimized window. This value is similar to
|
|
/// <see cref="Win32.ShowWindowCommand.ShowMinimized"/>, except the
|
|
/// window is not activated.
|
|
/// </summary>
|
|
ShowMinNoActive = 7,
|
|
/// <summary>
|
|
/// Displays the window in its current size and position. This value is
|
|
/// similar to <see cref="Win32.ShowWindowCommand.Show"/>, except the
|
|
/// window is not activated.
|
|
/// </summary>
|
|
ShowNA = 8,
|
|
/// <summary>
|
|
/// Activates and displays the window. If the window is minimized or
|
|
/// maximized, the system restores it to its original size and position.
|
|
/// An application should specify this flag when restoring a minimized window.
|
|
/// </summary>
|
|
Restore = 9,
|
|
/// <summary>
|
|
/// Sets the show state based on the SW_* value specified in the
|
|
/// STARTUPINFO structure passed to the CreateProcess function by the
|
|
/// program that started the application.
|
|
/// </summary>
|
|
ShowDefault = 10,
|
|
/// <summary>
|
|
/// <b>Windows 2000/XP:</b> Minimizes a window, even if the thread
|
|
/// that owns the window is not responding. This flag should only be
|
|
/// used when minimizing windows from a different thread.
|
|
/// </summary>
|
|
ForceMinimize = 11
|
|
}
|
|
|
|
public struct WINDOWPLACEMENT
|
|
{
|
|
public int length;
|
|
public int flags;
|
|
public int showCmd;
|
|
public POINT ptMinPosition;
|
|
public POINT ptMaxPosition;
|
|
public RECT rcNormalPosition;
|
|
}
|
|
/// <summary>
|
|
/// Retrieves the show state and the restored, minimized, and maximized positions of the specified window.
|
|
/// </summary>
|
|
/// <param name="hWnd">
|
|
/// A handle to the window.
|
|
/// </param>
|
|
/// <param name="lpwndpl">
|
|
/// A pointer to the WINDOWPLACEMENT structure that receives the show state and position information.
|
|
/// <para>
|
|
/// Before calling GetWindowPlacement, set the length member to sizeof(WINDOWPLACEMENT). GetWindowPlacement fails if lpwndpl-> length is not set correctly.
|
|
/// </para>
|
|
/// </param>
|
|
/// <returns>
|
|
/// If the function succeeds, the return value is nonzero.
|
|
/// <para>
|
|
/// If the function fails, the return value is zero. To get extended error information, call GetLastError.
|
|
/// </para>
|
|
/// </returns>
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
[return: MarshalAs(UnmanagedType.Bool)]
|
|
internal static extern bool GetWindowPlacement(IntPtr hWnd, out WINDOWPLACEMENT lpwndpl);
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct NCCALCSIZE_PARAMS
|
|
{
|
|
public RECT rgrc0, rgrc1, rgrc2;
|
|
public IntPtr lppos;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct WINDOWPOS
|
|
{
|
|
public IntPtr hwnd;
|
|
public IntPtr hwndInsertAfter;
|
|
public int x, y;
|
|
public int cx, cy;
|
|
public int flags;
|
|
public override string ToString()
|
|
{
|
|
return string.Format("x={0}, y={1}, right={2}, bottom={3}", x, y, cx, cy);
|
|
}
|
|
}
|
|
|
|
[Serializable, StructLayout(LayoutKind.Sequential)]
|
|
public struct RECT
|
|
{
|
|
public int Left;
|
|
public int Top;
|
|
public int Right;
|
|
public int Bottom;
|
|
|
|
public RECT(int left_, int top_, int right_, int bottom_)
|
|
{
|
|
Left = left_;
|
|
Top = top_;
|
|
Right = right_;
|
|
Bottom = bottom_;
|
|
}
|
|
|
|
public RECT(Rectangle r)
|
|
{
|
|
Left = r.Left;
|
|
Top = r.Top;
|
|
Right = r.Right;
|
|
Bottom = r.Bottom;
|
|
}
|
|
|
|
public int Height { get { return Bottom - Top; } }
|
|
public int Width { get { return Right - Left; } }
|
|
public Size Size { get { return new Size(Width, Height); } }
|
|
|
|
public Point Location { get { return new Point(Left, Top); } }
|
|
|
|
// Handy method for converting to a System.Drawing.Rectangle
|
|
public Rectangle ToRectangle()
|
|
{ return Rectangle.FromLTRB(Left, Top, Right, Bottom); }
|
|
|
|
public static RECT FromRectangle(Rectangle rectangle)
|
|
{
|
|
return new RECT(rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom);
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return Left ^ ((Top << 13) | (Top >> 0x13))
|
|
^ ((Width << 0x1a) | (Width >> 6))
|
|
^ ((Height << 7) | (Height >> 0x19));
|
|
}
|
|
|
|
public static RECT FromXYWH(int x, int y, int width, int height)
|
|
{
|
|
return new RECT(x, y, x + width, y + height);
|
|
}
|
|
|
|
#region Operator overloads
|
|
|
|
public static implicit operator Rectangle(RECT rect)
|
|
{
|
|
return Rectangle.FromLTRB(rect.Left, rect.Top, rect.Right, rect.Bottom);
|
|
}
|
|
|
|
public static implicit operator RECT(Rectangle rect)
|
|
{
|
|
return new RECT(rect.Left, rect.Top, rect.Right, rect.Bottom);
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return "Left=" + this.Left + ", Top=" + this.Top + ", Right=" + this.Right + ", Bottom=" + this.Bottom;
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
[System.Runtime.InteropServices.StructLayout(System.Runtime.InteropServices.LayoutKind.Sequential)]
|
|
public struct PAINTSTRUCT
|
|
{
|
|
public IntPtr hdc;
|
|
public int fErase;
|
|
public WinApi.RECT rcPaint;
|
|
public int fRestore;
|
|
public int fIncUpdate;
|
|
public int Reserved1;
|
|
public int Reserved2;
|
|
public int Reserved3;
|
|
public int Reserved4;
|
|
public int Reserved5;
|
|
public int Reserved6;
|
|
public int Reserved7;
|
|
public int Reserved8;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public class BITMAPINFO
|
|
{
|
|
public int biSize = 0;
|
|
public int biWidth = 0;
|
|
public int biHeight = 0;
|
|
public short biPlanes = 0;
|
|
public short biBitCount = 0;
|
|
public int biCompression = 0;
|
|
public int biSizeImage = 0;
|
|
public int biXPelsPerMeter = 0;
|
|
public int biYPelsPerMeter = 0;
|
|
public int biClrUsed = 0;
|
|
public int biClrImportant = 0;
|
|
public byte bmiColors_rgbBlue = 0;
|
|
public byte bmiColors_rgbGreen = 0;
|
|
public byte bmiColors_rgbRed = 0;
|
|
public byte bmiColors_rgbReserved = 0;
|
|
}
|
|
|
|
public enum eObjectId : uint
|
|
{
|
|
OBJID_CLIENT = 0xFFFFFFFC,
|
|
OBJID_VSCROLL = 0xFFFFFFFB,
|
|
OBJID_HSCROLL = 0xFFFFFFFA
|
|
}
|
|
|
|
public enum eStateFlags
|
|
{
|
|
STATE_SYSTEM_INVISIBLE = 0x00008000,
|
|
STATE_SYSTEM_OFFSCREEN = 0x00010000,
|
|
STATE_SYSTEM_PRESSED = 0x00000008,
|
|
STATE_SYSTEM_UNAVAILABLE = 0x00000001
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct MINMAXINFO
|
|
{
|
|
public Point reserved;
|
|
public Size maxSize;
|
|
public Point maxPosition;
|
|
public Size minTrackSize;
|
|
public Size maxTrackSize;
|
|
}
|
|
#endregion
|
|
|
|
#region Functions
|
|
[DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true, ExactSpelling = true)]
|
|
public static extern int ScrollWindowEx(HandleRef hWnd, int nXAmount, int nYAmount, ref RECT rectScrollRegion, ref RECT rectClip, IntPtr hrgnUpdate, ref RECT prcUpdate, int flags);
|
|
|
|
[DllImport("Gdi32.dll", EntryPoint = "CreateRoundRectRgn")]
|
|
public static extern IntPtr CreateRoundRectRgn
|
|
(
|
|
int nLeftRect, // x-coordinate of upper-left corner
|
|
int nTopRect, // y-coordinate of upper-left corner
|
|
int nRightRect, // x-coordinate of lower-right corner
|
|
int nBottomRect, // y-coordinate of lower-right corner
|
|
int nWidthEllipse, // height of ellipse
|
|
int nHeightEllipse // width of ellipse
|
|
);
|
|
|
|
public enum AppCommands
|
|
{
|
|
APPCOMMAND_BROWSER_BACKWARD = 1,
|
|
APPCOMMAND_BROWSER_FORWARD = 2
|
|
}
|
|
private static int FAPPCOMMAND_MASK = 0xF000;
|
|
public static short GetAppCommandLParam(IntPtr lParam)
|
|
{
|
|
return (short)((short)HIWORD(lParam) & ~FAPPCOMMAND_MASK);
|
|
}
|
|
public static int LOWORD(int n)
|
|
{
|
|
return (short)(n & 0xffff);
|
|
}
|
|
public static int HIWORD(int n)
|
|
{
|
|
return (int)((n >> 0x10) & 0xffff);
|
|
}
|
|
public static int LOWORD(IntPtr n)
|
|
{
|
|
return unchecked((short)(long)n);
|
|
//return LOWORD((int)((long)n));
|
|
}
|
|
public static int HIWORD(IntPtr n)
|
|
{
|
|
//return (IntPtr.Size == 8 ? unchecked((int)n.ToInt64()) : n.ToInt32()) >> 16;
|
|
return unchecked((short)((long)n >> 16));
|
|
}
|
|
|
|
public static IntPtr CreateLParam(int loWord, int hiWord)
|
|
{
|
|
byte[] bx = BitConverter.GetBytes(loWord);
|
|
byte[] by = BitConverter.GetBytes(hiWord);
|
|
byte[] blp = new byte[] { bx[0], bx[1], by[0], by[1] };
|
|
return new IntPtr(BitConverter.ToInt32(blp, 0));
|
|
}
|
|
|
|
public static int ToInt(IntPtr ptr)
|
|
{
|
|
int result = 0;
|
|
try { result = (int)((long)ptr); }
|
|
catch { }
|
|
return result;
|
|
}
|
|
#endregion
|
|
|
|
#region DWM
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct MARGINS
|
|
{
|
|
public int cxLeftWidth;
|
|
public int cxRightWidth;
|
|
public int cyTopHeight;
|
|
public int cyBottomHeight;
|
|
}
|
|
|
|
[DllImport("dwmapi.dll")]
|
|
public static extern int DwmSetWindowAttribute(
|
|
IntPtr hWnd,
|
|
int dwAttribute,
|
|
ref int attributeValue,
|
|
int sizeOfValueRetrived
|
|
);
|
|
[DllImport("dwmapi.dll")]
|
|
public static extern int DwmGetWindowAttribute(
|
|
IntPtr hwnd,
|
|
int dwAttribute,
|
|
ref int pvAttribute,
|
|
int sizeOfValueRetrived);
|
|
|
|
[DllImport("dwmapi.dll", PreserveSig = false)]
|
|
static extern bool DwmIsCompositionEnabled();
|
|
|
|
[DllImport("dwmapi.dll")]
|
|
public static extern int DwmDefWindowProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, out IntPtr plResult);
|
|
[DllImport("user32.dll", CharSet = CharSet.Unicode, EntryPoint = "DefWindowProcW")]
|
|
public static extern IntPtr DefWindowProc(IntPtr hWnd, WindowsMessages Msg, IntPtr wParam, IntPtr lParam);
|
|
[DllImport("user32.dll", CharSet = CharSet.Unicode, EntryPoint = "DefWindowProcW")]
|
|
public static extern IntPtr DefWindowProc(IntPtr hWnd, int Msg, IntPtr wParam, IntPtr lParam);
|
|
|
|
[DllImport("dwmapi.dll")]
|
|
public static extern int DwmExtendFrameIntoClientArea(IntPtr hWnd, ref MARGINS pMargins);
|
|
|
|
public static void ExtendGlass(IntPtr handle, int glassHeight)
|
|
{
|
|
MARGINS margins = new MARGINS();
|
|
margins.cxLeftWidth = 0;
|
|
margins.cxRightWidth = 0;
|
|
margins.cyTopHeight = glassHeight;
|
|
margins.cyBottomHeight = 0;
|
|
|
|
int result = DwmExtendFrameIntoClientArea(handle, ref margins);
|
|
|
|
}
|
|
|
|
public static bool IsGlassEnabled
|
|
{
|
|
get
|
|
{
|
|
if (System.Environment.OSVersion.Version.Major < 6)
|
|
return false;
|
|
return DwmIsCompositionEnabled() && (System.Windows.Forms.Application.VisualStyleState == System.Windows.Forms.VisualStyles.VisualStyleState.ClientAndNonClientAreasEnabled);
|
|
}
|
|
}
|
|
|
|
public enum DWMWINDOWATTRIBUTE : int
|
|
{
|
|
DWMWA_NCRENDERING_ENABLED = 1,
|
|
DWMWA_NCRENDERING_POLICY = 2,
|
|
DWMWA_TRANSITIONS_FORCEDISABLED = 3,
|
|
DWMWA_ALLOW_NCPAINT = 4,
|
|
DWMWA_LAST = 5
|
|
}
|
|
|
|
public enum DWMNCRENDERINGPOLICY : int
|
|
{
|
|
DWMNCRP_USEWINDOWSTYLE = 0,
|
|
DWMNCRP_DISABLED = 1,
|
|
DWMNCRP_ENABLED = 2,
|
|
DWMNCRP_LAST = 3
|
|
}
|
|
|
|
public enum WVR
|
|
{
|
|
ALIGNTOP = 0x0010,
|
|
ALIGNLEFT = 0x0020,
|
|
ALIGNBOTTOM = 0x0040,
|
|
ALIGNRIGHT = 0x0080,
|
|
HREDRAW = 0x0100,
|
|
VREDRAW = 0x0200,
|
|
VALIDRECTS = 0x0400,
|
|
REDRAW = HREDRAW | VREDRAW,
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
#region Taskbar
|
|
public enum TaskbarPosition
|
|
{
|
|
Unknown = -1,
|
|
Left,
|
|
Top,
|
|
Right,
|
|
Bottom,
|
|
}
|
|
|
|
internal sealed class Taskbar
|
|
{
|
|
private const string ClassName = "Shell_TrayWnd";
|
|
|
|
private Rectangle _Bounds = Rectangle.Empty;
|
|
public Rectangle Bounds
|
|
{
|
|
get { return _Bounds; }
|
|
private set { _Bounds=value;}
|
|
}
|
|
|
|
private TaskbarPosition _Position = TaskbarPosition.Unknown;
|
|
public TaskbarPosition Position
|
|
{
|
|
get { return _Position; }
|
|
private set { _Position = value; }
|
|
}
|
|
public Point Location
|
|
{
|
|
get
|
|
{
|
|
return this.Bounds.Location;
|
|
}
|
|
}
|
|
public Size Size
|
|
{
|
|
get
|
|
{
|
|
return this.Bounds.Size;
|
|
}
|
|
}
|
|
|
|
private bool _AlwaysOnTop = false;
|
|
//Always returns false under Windows 7
|
|
public bool AlwaysOnTop
|
|
{
|
|
get
|
|
{
|
|
return _AlwaysOnTop;
|
|
}
|
|
private set
|
|
{
|
|
_AlwaysOnTop = value;
|
|
}
|
|
}
|
|
private bool _AutoHide = false;
|
|
public bool AutoHide
|
|
{
|
|
get
|
|
{
|
|
return _AutoHide;
|
|
}
|
|
private set
|
|
{
|
|
_AutoHide = value;
|
|
}
|
|
}
|
|
|
|
public Taskbar()
|
|
{
|
|
IntPtr taskbarHandle = User32.FindWindow(Taskbar.ClassName, null);
|
|
|
|
APPBARDATA data = new APPBARDATA();
|
|
data.cbSize = (uint)Marshal.SizeOf(typeof(APPBARDATA));
|
|
data.hWnd = taskbarHandle;
|
|
IntPtr result = Shell32.SHAppBarMessage(ABM.GetTaskbarPos, ref data);
|
|
if (result == IntPtr.Zero)
|
|
throw new InvalidOperationException();
|
|
|
|
this.Position = (TaskbarPosition)data.uEdge;
|
|
this.Bounds = Rectangle.FromLTRB(data.rc.left, data.rc.top, data.rc.right, data.rc.bottom);
|
|
|
|
data.cbSize = (uint)Marshal.SizeOf(typeof(APPBARDATA));
|
|
result = Shell32.SHAppBarMessage(ABM.GetState, ref data);
|
|
int state = result.ToInt32();
|
|
this.AlwaysOnTop = (state & ABS.AlwaysOnTop) == ABS.AlwaysOnTop;
|
|
this.AutoHide = (state & ABS.Autohide) == ABS.Autohide;
|
|
}
|
|
}
|
|
|
|
public enum ABM : uint
|
|
{
|
|
New = 0x00000000,
|
|
Remove = 0x00000001,
|
|
QueryPos = 0x00000002,
|
|
SetPos = 0x00000003,
|
|
GetState = 0x00000004,
|
|
GetTaskbarPos = 0x00000005,
|
|
Activate = 0x00000006,
|
|
GetAutoHideBar = 0x00000007,
|
|
SetAutoHideBar = 0x00000008,
|
|
WindowPosChanged = 0x00000009,
|
|
SetState = 0x0000000A,
|
|
}
|
|
|
|
public enum ABE : uint
|
|
{
|
|
Left = 0,
|
|
Top = 1,
|
|
Right = 2,
|
|
Bottom = 3
|
|
}
|
|
|
|
public static class ABS
|
|
{
|
|
public const int Autohide = 0x0000001;
|
|
public const int AlwaysOnTop = 0x0000002;
|
|
}
|
|
|
|
public static class Shell32
|
|
{
|
|
[DllImport("shell32.dll", SetLastError = true)]
|
|
public static extern IntPtr SHAppBarMessage(ABM dwMessage, [In] ref APPBARDATA pData);
|
|
}
|
|
|
|
public static class User32
|
|
{
|
|
[DllImport("user32.dll", SetLastError = true)]
|
|
public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct APPBARDATA
|
|
{
|
|
public uint cbSize;
|
|
public IntPtr hWnd;
|
|
public uint uCallbackMessage;
|
|
public ABE uEdge;
|
|
public RECT rc;
|
|
public int lParam;
|
|
}
|
|
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
public struct RECT
|
|
{
|
|
public int left;
|
|
public int top;
|
|
public int right;
|
|
public int bottom;
|
|
}
|
|
#endregion
|
|
}
|