static CommunicationWindowManager()
{
string windowClassName = string.Empty;
for (int i = 0; true; i++)
{
windowClassName = WindowClassNameBase + i;
//ウィンドウプロックをGCの対象から外すためにstaticメンバにする
MyWindowProc = new NativeMethods.WndProc(WndProc);
//ウィンドウクラス登録
NativeMethods.WNDCLASSEX wc = new NativeMethods.WNDCLASSEX();
wc.cbSize = (uint)Marshal.SizeOf(wc);
wc.style = 0;
wc.lpfnWndProc = Marshal.GetFunctionPointerForDelegate(MyWindowProc);
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = NativeMethods.GetModuleHandle(null);
wc.hIcon = IntPtr.Zero;
wc.hCursor = IntPtr.Zero;
wc.hbrBackground = IntPtr.Zero;
wc.lpszMenuName = string.Empty;
wc.lpszClassName = windowClassName;
wc.hIconSm = IntPtr.Zero;
if (NativeMethods.RegisterClassEx(ref wc) != 0)
{
break;
}
}
WindowClassName = windowClassName;
}
// Helpers
// create a window to handle messages
static IntPtr CreateTestWindow()
{
// Create a simple Win32 window
var hwndStatic = NativeMethods.CreateWindowEx(0, "Static", String.Empty, NativeMethods.WS_POPUP,
0, 0, 0, 0, NativeMethods.HWND_MESSAGE, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
// subclass it with a custom WndProc
IntPtr prevWndProc = IntPtr.Zero;
NativeMethods.WndProc newWndProc = (hwnd, msg, wParam, lParam) =>
{
if (msg == NativeMethods.WM_TEST)
{
Console.WriteLine("WM_TEST processed: " + wParam);
}
return(NativeMethods.CallWindowProc(prevWndProc, hwnd, msg, wParam, lParam));
};
prevWndProc = NativeMethods.SetWindowLong(hwndStatic, NativeMethods.GWL_WNDPROC,
Marshal.GetFunctionPointerForDelegate(newWndProc));
if (prevWndProc == IntPtr.Zero)
{
throw new ApplicationException();
}
return(hwndStatic);
}
public static IntPtr SetWindowLong(HandleRef hWnd, int nIndex, NativeMethods.WndProc wndproc)
{
if (IntPtr.Size == 4)
{
return(SetWindowLongPtr32(hWnd, nIndex, wndproc));
}
return(SetWindowLongPtr64(hWnd, nIndex, wndproc));
}
/// <include file='doc\FileDialog.uex' path='docs/doc[@for="FileDialog.RunDialog"]/*' />
/// <devdoc>
/// Implements running of a file dialog.
/// </devdoc>
/// <internalonly/>
protected override bool RunDialog(IntPtr hWndOwner)
{
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
NativeMethods.OPENFILENAME_I ofn = new NativeMethods.OPENFILENAME_I();
try {
charBuffer = CharBuffer.CreateBuffer(FILEBUFSIZE);
if (fileNames != null)
{
charBuffer.PutString(fileNames[0]);
}
ofn.lStructSize = Marshal.SizeOf(typeof(NativeMethods.OPENFILENAME_I));
// SECREVIEW : Assert environment so that we can determine
// : the platform that we are running on. We only
// : use the information to change the style of
// : dialog, so it is safe.
//
IntSecurity.UnrestrictedEnvironment.Assert();
try {
// Degrade to the older style dialog if we're not on Win2K.
// We do this by setting the struct size to a different value
//
if (Environment.OSVersion.Platform != System.PlatformID.Win32NT ||
Environment.OSVersion.Version.Major < 5)
{
ofn.lStructSize = 0x4C;
}
}
finally {
CodeAccessPermission.RevertAssert();
}
ofn.hwndOwner = hWndOwner;
ofn.hInstance = Instance;
ofn.lpstrFilter = MakeFilterString(filter);
ofn.nFilterIndex = filterIndex;
ofn.lpstrFile = charBuffer.AllocCoTaskMem();
ofn.nMaxFile = FILEBUFSIZE;
ofn.lpstrInitialDir = initialDir;
ofn.lpstrTitle = title;
ofn.Flags = Options | (NativeMethods.OFN_EXPLORER | NativeMethods.OFN_ENABLEHOOK | NativeMethods.OFN_ENABLESIZING);
ofn.lpfnHook = hookProcPtr;
ofn.FlagsEx = NativeMethods.OFN_USESHELLITEM;
if (defaultExt != null && AddExtension)
{
ofn.lpstrDefExt = defaultExt;
}
return(RunFileDialog(ofn));
}
finally {
charBuffer = null;
if (ofn.lpstrFile != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(ofn.lpstrFile);
}
}
}
public override void Start()
{
//https://stackoverflow.com/questions/8980873/implementing-a-win32-message-loop-and-creating-a-window-object-with-p-invoke
_messageWindowProc = WndProc;
w = new WNDCLASSEX
{
cbSize = (uint)Marshal.SizeOf(typeof(WNDCLASSEX)),
lpszClassName = "OTB_Message_Watcher_Class",
lpfnWndProc = _messageWindowProc
};
NativeMethods.RegisterClassEx(ref w);
IntPtr hInstance = NativeMethods.GetModuleHandle(Process.GetCurrentProcess().MainModule.ModuleName);
//new IntPtr(-3) = MESSAGE ONLY
_messageWindowHandle = NativeMethods.CreateWindowEx(0, w.lpszClassName, w.lpszClassName, 0, 0, 0, 0, 0, new IntPtr(-3), IntPtr.Zero, hInstance /*Can I make this 0?*/, IntPtr.Zero);
NativeMethods.AddClipboardFormatListener(_messageWindowHandle);
_windowsMouseHookHandle = IntPtr.Zero;
_user32LibraryHandle = IntPtr.Zero;
_mouseHookProc = LowLevelMouseProc; // we must keep alive _hookProc, because GC is not aware about SetWindowsHookEx behaviour.
_windowsKeyboardHookHandle = IntPtr.Zero;
_keyboardHookProc = LowLevelKeyboardProc; // we must keep alive _hookProc, because GC is not aware about SetWindowsHookEx behaviour.
_user32LibraryHandle = NativeMethods.LoadLibrary("User32");
if (_user32LibraryHandle == IntPtr.Zero)
{
int errorCode = Marshal.GetLastWin32Error();
throw new Win32Exception(errorCode, $"Failed to load library 'User32.dll'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}.");
}
_windowsMouseHookHandle = NativeMethods.SetWindowsHookEx(WH_MOUSE_LL, _mouseHookProc, _user32LibraryHandle, 0);
if (_windowsMouseHookHandle == IntPtr.Zero)
{
int errorCode = Marshal.GetLastWin32Error();
throw new Win32Exception(errorCode, $"Failed to adjust mouse hooks for '{Process.GetCurrentProcess().ProcessName}'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}.");
}
_windowsKeyboardHookHandle = NativeMethods.SetWindowsHookEx(WH_KEYBOARD_LL, _keyboardHookProc, _user32LibraryHandle, 0);
if (_windowsKeyboardHookHandle == IntPtr.Zero)
{
int errorCode = Marshal.GetLastWin32Error();
throw new Win32Exception(errorCode, $"Failed to adjust keyboard hooks for '{Process.GetCurrentProcess().ProcessName}'. Error {errorCode}: {new Win32Exception(Marshal.GetLastWin32Error()).Message}.");
}
//init initial cursor position
if (NativeMethods.GetCursorPos(out Point p))
{
MouseState.Position = new MousePoint(p.X, p.Y);
}
}
private void HookWindowProc(IntPtr hwnd, NativeMethods.WndProc newWndProc, IntPtr oldWndProc)
{
_hwndAttached = hwnd;
_hwndHandleRef = new HandleRef(null, _hwndAttached);
_bond = Bond.Attached;
_attachedWndProc = newWndProc;
_oldWndProc = oldWndProc;
IntPtr oldWndProc2 = (IntPtr)UnsafeNativeMethods.CriticalSetWindowLong(_hwndHandleRef, NativeMethods.GWL_WNDPROC, _attachedWndProc);
// Track this window so that we can rip out the managed window proc
// when the CLR shuts down.
ManagedWndProcTracker.TrackHwndSubclass(this, _hwndAttached);
}
/// <include file='doc\CommonDialog.uex' path='docs/doc[@for="CommonDialog.ShowDialog1"]/*' />
/// <devdoc>
/// <para>
/// Runs a common dialog box, parented to the given IWin32Window.
/// </para>
/// </devdoc>
public DialogResult ShowDialog(IWin32Window owner)
{
IntSecurity.SafeSubWindows.Demand();
if (owner == null || owner.Handle == IntPtr.Zero)
{
return(ShowDialog());
}
if (!SystemInformation.UserInteractive)
{
throw new InvalidOperationException(SR.GetString(SR.CantShowModalOnNonInteractive));
}
if (helpMsg == 0)
{
helpMsg = SafeNativeMethods.RegisterWindowMessage("commdlg_help");
}
IntPtr hwndOwner = owner.Handle;
defOwnerWndProc = UnsafeNativeMethods.GetWindowLong(new HandleRef(owner, hwndOwner), NativeMethods.GWL_WNDPROC);
// define ownerproc out here so it won't be garbage collected before the finally
// clause runs
NativeMethods.WndProc ownerProc = new NativeMethods.WndProc(this.OwnerWndProc);
DialogResult result = DialogResult.Cancel;
try {
UnsafeNativeMethods.SetWindowLong(new HandleRef(owner, hwndOwner), NativeMethods.GWL_WNDPROC, ownerProc);
Application.BeginModalMessageLoop();
try {
result = RunDialog(hwndOwner) ? DialogResult.OK : DialogResult.Cancel;
GC.KeepAlive(ownerProc);
}
finally {
Application.EndModalMessageLoop();
}
}
finally {
if (UnsafeNativeMethods.IsWindow(new HandleRef(owner, hwndOwner)))
{
UnsafeNativeMethods.SetWindowLong(new HandleRef(owner, hwndOwner), NativeMethods.GWL_WNDPROC, new HandleRef(null, defOwnerWndProc));
}
}
return(result);
}
protected override bool RunDialog(IntPtr hwndOwner)
{
var hookProcPtr = new NativeMethods.WndProc(HookProc);
if (!UseEXDialog)
{
NativeMethods.PRINTDLG data = CreatePRINTDLG();
return(ShowPrintDialog(hwndOwner, hookProcPtr, data));
}
else
{
NativeMethods.PRINTDLGEX data = CreatePRINTDLGEX();
return(ShowPrintDialog(hwndOwner, data));
}
}
private void CreateWindow()
{
this.m_proc = new NativeMethods.WndProc(this.CustomProc);
var wndClass = new NativeMethods.WNDCLASS();
wndClass.lpszClassName = this.m_uniqueName;
wndClass.lpfnWndProc = Marshal.GetFunctionPointerForDelegate(this.m_proc);
var resRegister = NativeMethods.RegisterClass(ref wndClass);
var resError = Marshal.GetLastWin32Error();
if (resRegister == 0 && resError != NativeMethods.ERROR_CLASS_ALREADY_EXISTS)
throw new Exception();
this.m_customHwnd = NativeMethods.CreateWindowEx(0, this.m_uniqueName, null, 0, 0, 0, 0, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
}
/// <summary>Create a window class for the win32 window</summary>
/// <param name="className">Name of the window class.</param>
public WindowClass(string className)
{
defWindowProc = new NativeMethods.WndProc(NativeMethods.DefWindowProc);
var wndclass = default(WNDCLASS);
wndclass.cbClsExtra = 0;
wndclass.cbWndExtra = 0;
wndclass.hbrBackground = IntPtr.Zero;
wndclass.hCursor = IntPtr.Zero;
wndclass.hIcon = IntPtr.Zero;
wndclass.lpfnWndProc = defWindowProc;
wndclass.lpszClassName = className;
wndclass.lpszMenuName = null;
wndclass.style = 0u;
hWndClass = new IntPtr(NativeMethods.RegisterClass(ref wndclass));
} // ctor
private bool RunDialogOld(IntPtr hWndOwner)
{
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
NativeMethods.OPENFILENAME_I ofn = new NativeMethods.OPENFILENAME_I();
try {
charBuffer = CharBuffer.CreateBuffer(FILEBUFSIZE);
if (fileNames != null)
{
charBuffer.PutString(fileNames[0]);
}
ofn.lStructSize = Marshal.SizeOf(typeof(NativeMethods.OPENFILENAME_I));
// Degrade to the older style dialog if we're not on Win2K.
// We do this by setting the struct size to a different value
//
if (Environment.OSVersion.Platform != System.PlatformID.Win32NT ||
Environment.OSVersion.Version.Major < 5)
{
ofn.lStructSize = 0x4C;
}
ofn.hwndOwner = hWndOwner;
ofn.hInstance = Instance;
ofn.lpstrFilter = MakeFilterString(filter, this.DereferenceLinks);
ofn.nFilterIndex = filterIndex;
ofn.lpstrFile = charBuffer.AllocCoTaskMem();
ofn.nMaxFile = FILEBUFSIZE;
ofn.lpstrInitialDir = initialDir;
ofn.lpstrTitle = title;
ofn.Flags = Options | (NativeMethods.OFN_EXPLORER | NativeMethods.OFN_ENABLEHOOK | NativeMethods.OFN_ENABLESIZING);
ofn.lpfnHook = hookProcPtr;
ofn.FlagsEx = NativeMethods.OFN_USESHELLITEM;
if (defaultExt != null && AddExtension)
{
ofn.lpstrDefExt = defaultExt;
}
//Security checks happen here
return(RunFileDialog(ofn));
}
finally {
charBuffer = null;
if (ofn.lpstrFile != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(ofn.lpstrFile);
}
}
}
/// <summary>
/// 実行。
/// </summary>
/// <param name="targetThreadWindowHandle">処理を実行させるウィンドウ。</param>
/// <param name="action">処理。</param>
/// <returns>成否。</returns>
internal static bool Execute(IntPtr targetThreadWindowHandle, MethodInvoker action)
{
//現在のウィンドウプロックを取得
IntPtr currentProc = NativeMethods.GetWindowLongPtr(targetThreadWindowHandle, NativeMethods.GWL_WNDPROC);
//InvokeWindowを起動するためのプロックを設定
bool executed = false;
NativeMethods.WndProc proc = delegate(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam)
{
switch (msg)
{
case 0:
if (!executed)
{
action();
executed = true;
}
break;
default:
break;
}
return(NativeMethods.CallWindowProc(currentProc, hwnd, msg, wParam, lParam));
};
NativeMethods.SetWindowLongPtr(targetThreadWindowHandle, NativeMethods.GWL_WNDPROC, Marshal.GetFunctionPointerForDelegate(proc));
//実行完了待ち
while (!executed)
{
//指定のウィンドウが消えていたら終了
if (!NativeMethods.IsWindow(targetThreadWindowHandle))
{
return(false);
}
NativeMethods.SendMessage(targetThreadWindowHandle, 0, IntPtr.Zero, IntPtr.Zero);
Thread.Sleep(10);
}
GC.KeepAlive(proc);
GC.KeepAlive(action);
//元に戻す
NativeMethods.SetWindowLongPtr(targetThreadWindowHandle, NativeMethods.GWL_WNDPROC, currentProc);
return(true);
}
internal IntPtr CriticalAttach(IntPtr hwnd)
{
if (hwnd == IntPtr.Zero)
{
throw new ArgumentNullException("hwnd");
}
if (_bond != Bond.Unattached)
{
throw new InvalidOperationException();
}
NativeMethods.WndProc newWndProc = new NativeMethods.WndProc(SubclassWndProc);
IntPtr oldWndProc = UnsafeNativeMethods.GetWindowLongPtr(new HandleRef(this, hwnd), NativeMethods.GWL_WNDPROC);
HookWindowProc(hwnd, newWndProc, oldWndProc);
// Return the GC handle as a unique identifier of this
return((IntPtr)_gcHandle);
}
private void CreateWindow()
{
this.m_proc = new NativeMethods.WndProc(this.CustomProc);
var wndClass = new NativeMethods.WNDCLASS();
wndClass.lpszClassName = this.m_uniqueName;
wndClass.lpfnWndProc = Marshal.GetFunctionPointerForDelegate(this.m_proc);
var resRegister = NativeMethods.RegisterClass(ref wndClass);
var resError = Marshal.GetLastWin32Error();
if (resRegister == 0 && resError != NativeMethods.ERROR_CLASS_ALREADY_EXISTS)
{
throw new Exception();
}
this.m_customHwnd = NativeMethods.CreateWindowEx(0, this.m_uniqueName, null, 0, 0, 0, 0, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
if (handle == IntPtr.Zero)
{
handle = new WindowInteropHelper(this).Handle;
newWndProc = new NativeMethods.WndProc(WindowProc);
oldWndProc = NativeMethods.GetWindowLongPtr(handle, NativeMethods.GWLP_WNDPROC);
NativeMethods.SetWindowLongPtr(handle, NativeMethods.GWLP_WNDPROC,
Marshal.GetFunctionPointerForDelegate(newWndProc));
}
if (comboBox1.Items.Count == 0 && conf.Configurations.Count > 0)
{
for (int i = 0; i < conf.Configurations.Count; i++)
{
var h = conf.Configurations.ElementAt(i);
h.Value.PropertyChanged += Header_PropertyChanged;
comboBox1.Items.Add(h.Key);
var m = h.Value.Modules as Modules;
m.PropertyChanged += Modules_PropertyChanged;
}
comboBox1.SelectedIndex = 0;
}
else
{
UpdateStateToControls();
}
menuItem2_1.IsEnabled = false;
menuItem2_2.IsEnabled = false;
menuItem3_1.IsEnabled = false;
menuItem3_2.IsEnabled = false;
button2_1.IsEnabled = false;
button2_2.IsEnabled = false;
button3_1.IsEnabled = false;
button3_2.IsEnabled = false;
propertyGrid.PropertyValueChanged += Translator_PropertyValueChanged;
}
protected override bool RunDialog(IntPtr hwndOwner)
{
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(HookProc);
NativeMethods.CHOOSECOLOR cc = new NativeMethods.CHOOSECOLOR();
IntPtr custColorPtr = Marshal.AllocCoTaskMem(64);
try
{
Marshal.Copy(customColors, 0, custColorPtr, 16);
cc.hwndOwner = hwndOwner;
cc.hInstance = Instance;
cc.rgbResult = ColorTranslator.ToWin32(color);
cc.lpCustColors = custColorPtr;
int flags = Options | (NativeMethods.CC_RGBINIT | NativeMethods.CC_ENABLEHOOK);
// Our docs say AllowFullOpen takes precedence over FullOpen; ChooseColor implements the opposite
if (!AllowFullOpen)
{
flags &= ~NativeMethods.CC_FULLOPEN;
}
cc.Flags = flags;
cc.lpfnHook = hookProcPtr;
if (!SafeNativeMethods.ChooseColor(cc))
{
return(false);
}
if (cc.rgbResult != ColorTranslator.ToWin32(color))
{
color = ColorTranslator.FromOle(cc.rgbResult);
}
Marshal.Copy(custColorPtr, customColors, 0, 16);
return(true);
}
finally
{
Marshal.FreeCoTaskMem(custColorPtr);
}
}
/// <include file='doc\PrintDialog.uex' path='docs/doc[@for="PrintDialog.RunDialog"]/*' />
/// <devdoc>
/// </devdoc>
/// <internalonly/>
// Use PrintDlgEx and PRINTDLGEX on Win2k and newer OS'.
protected override bool RunDialog(IntPtr hwndOwner)
{
bool returnValue = false;
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
if (!UseEXDialog || (Environment.OSVersion.Platform != System.PlatformID.Win32NT ||
Environment.OSVersion.Version.Major < 5))
{
NativeMethods.PRINTDLG data = CreatePRINTDLG();
returnValue = ShowPrintDialog(hwndOwner, hookProcPtr, data);
}
else
{
NativeMethods.PRINTDLGEX data = CreatePRINTDLGEX();
returnValue = ShowPrintDialog(hwndOwner, data);
}
return(returnValue);
}
private bool RunLegacyDialog(IntPtr hwndOwner)
{
NativeMethods.WndProc lpfnHook = new NativeMethods.WndProc(this.HookProc);
NativeMethods.OPENFILENAME_I openfilename_I = new NativeMethods.OPENFILENAME_I();
bool result;
try
{
this._charBuffer = NativeMethods.CharBuffer.CreateBuffer(8192);
if (this._fileNames != null)
{
this._charBuffer.PutString(this._fileNames[0]);
}
openfilename_I.lStructSize = Marshal.SizeOf(typeof(NativeMethods.OPENFILENAME_I));
openfilename_I.hwndOwner = hwndOwner;
openfilename_I.hInstance = IntPtr.Zero;
openfilename_I.lpstrFilter = FileDialog.MakeFilterString(this._filter, this.DereferenceLinks);
openfilename_I.nFilterIndex = this._filterIndex;
openfilename_I.lpstrFile = this._charBuffer.AllocCoTaskMem();
openfilename_I.nMaxFile = this._charBuffer.Length;
openfilename_I.lpstrInitialDir = this._initialDirectory.Value;
openfilename_I.lpstrTitle = this._title.Value;
openfilename_I.Flags = (this.Options | 8912928);
openfilename_I.lpfnHook = lpfnHook;
openfilename_I.FlagsEx = 16777216;
if (this._defaultExtension != null && this.AddExtension)
{
openfilename_I.lpstrDefExt = this._defaultExtension;
}
result = this.RunFileDialog(openfilename_I);
}
finally
{
this._charBuffer = null;
if (openfilename_I.lpstrFile != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(openfilename_I.lpstrFile);
}
}
return(result);
}
protected ushort RegisterClass(string className)
{
WNDCLASS wNDCLAss = new WNDCLASS()
{
cbClsExtra = 0,
cbWndExtra = 0,
hbrBackground = IntPtr.Zero,
hCursor = IntPtr.Zero,
hIcon = IntPtr.Zero
};
HwndWrapper hwndWrapper = this;
NativeMethods.WndProc wndProc = new NativeMethods.WndProc(hwndWrapper.WndProc);
Delegate @delegate = wndProc;
this.wndProc = wndProc;
wNDCLAss.lpfnWndProc = @delegate;
wNDCLAss.lpszClassName = className;
wNDCLAss.lpszMenuName = null;
wNDCLAss.style = 0;
return(NativeMethods.RegisterClass(ref wNDCLAss));
}
private void DestroyResources()
{
if (_dt != null)
{
_dt.Stop();
_dt = null;
}
if (_hwnd != IntPtr.Zero)
{
HandleRef hwnd = new HandleRef(null, _hwnd);
if (UnsafeNativeMethods.IsWindow(hwnd))
{
UnsafeNativeMethods.IntDestroyWindow(hwnd);
}
_hwnd = IntPtr.Zero;
}
if (_hBitmap != null && !_hBitmap.IsClosed)
{
UnsafeNativeMethods.DeleteObject(_hBitmap.MakeHandleRef(null).Handle);
_hBitmap.Close();
_hBitmap = null;
}
if (_wndClass != 0)
{
// Attempt to unregister the window class. If the application has a second
// splash screen which is still open this call will fail. That's OK.
if (UnsafeNativeMethods.IntUnregisterClass(new IntPtr(_wndClass), _hInstance) != 0)
{
_defWndProc = null; // Can safely release the wndproc delegate when there are no more splash screen instances
}
_wndClass = 0;
}
if (_resourceManager != null)
{
_resourceManager.ReleaseAllResources();
}
}
private IntPtr CreateWindow(NativeMethods.BitmapHandle hBitmap, int width, int height, bool topMost)
{
if (_defWndProc == null)
{
_defWndProc = new MS.Win32.NativeMethods.WndProc(UnsafeNativeMethods.DefWindowProc);
}
MS.Win32.NativeMethods.WNDCLASSEX_D wndClass = new MS.Win32.NativeMethods.WNDCLASSEX_D();
wndClass.cbSize = Marshal.SizeOf(typeof(MS.Win32.NativeMethods.WNDCLASSEX_D));
wndClass.style = 3; /* CS_HREDRAW | CS_VREDRAW */
wndClass.lpfnWndProc = null;
wndClass.hInstance = _hInstance;
wndClass.hCursor = IntPtr.Zero;
wndClass.lpszClassName = CLASSNAME;
wndClass.lpszMenuName = string.Empty;
wndClass.lpfnWndProc = _defWndProc;
// We chose to ignore re-registration errors in RegisterClassEx on the off chance that the user
// wants to open multiple splash screens.
_wndClass = MS.Win32.UnsafeNativeMethods.IntRegisterClassEx(wndClass);
if (_wndClass == 0)
{
if (Marshal.GetLastWin32Error() != 0x582) /* class already registered */
throw new Win32Exception();
}
int screenWidth = MS.Win32.UnsafeNativeMethods.GetSystemMetrics(SM.CXSCREEN);
int screenHeight = MS.Win32.UnsafeNativeMethods.GetSystemMetrics(SM.CYSCREEN);
int x = (screenWidth - width) / 2;
int y = (screenHeight - height) / 2;
HandleRef nullHandle = new HandleRef(null, IntPtr.Zero);
int windowCreateFlags =
(int) NativeMethods.WS_EX_WINDOWEDGE |
NativeMethods.WS_EX_TOOLWINDOW |
NativeMethods.WS_EX_LAYERED |
(topMost ? NativeMethods.WS_EX_TOPMOST : 0);
// CreateWindowEx will either succeed or throw
IntPtr hWnd = MS.Win32.UnsafeNativeMethods.CreateWindowEx(
windowCreateFlags,
CLASSNAME, SR.Get(SRID.SplashScreenIsLoading),
MS.Win32.NativeMethods.WS_POPUP | MS.Win32.NativeMethods.WS_VISIBLE,
x, y, width, height,
nullHandle, nullHandle, new HandleRef(null, _hInstance), IntPtr.Zero);
// Display the image on the window
IntPtr hScreenDC = UnsafeNativeMethods.GetDC(new HandleRef());
IntPtr memDC = UnsafeNativeMethods.CreateCompatibleDC(new HandleRef(null, hScreenDC));
IntPtr hOldBitmap = UnsafeNativeMethods.SelectObject(new HandleRef(null, memDC), hBitmap.MakeHandleRef(null).Handle);
NativeMethods.POINT newSize = new NativeMethods.POINT(width, height);
NativeMethods.POINT newLocation = new NativeMethods.POINT(x, y);
NativeMethods.POINT sourceLocation = new NativeMethods.POINT(0, 0);
_blendFunc = new NativeMethods.BLENDFUNCTION();
_blendFunc.BlendOp = NativeMethods.AC_SRC_OVER;
_blendFunc.BlendFlags = 0;
_blendFunc.SourceConstantAlpha = 255;
_blendFunc.AlphaFormat = 1; /*AC_SRC_ALPHA*/
bool result = UnsafeNativeMethods.UpdateLayeredWindow(hWnd, hScreenDC, newLocation, newSize,
memDC, sourceLocation, 0, ref _blendFunc, NativeMethods.ULW_ALPHA);
UnsafeNativeMethods.SelectObject(new HandleRef(null, memDC), hOldBitmap);
UnsafeNativeMethods.ReleaseDC(new HandleRef(), new HandleRef(null, memDC));
UnsafeNativeMethods.ReleaseDC(new HandleRef(), new HandleRef(null, hScreenDC));
if (result == false)
{
UnsafeNativeMethods.HRESULT.Check(Marshal.GetHRForLastWin32Error());
}
return hWnd;
}
private void DestroyResources()
{
if (_dt != null)
{
_dt.Stop();
_dt = null;
}
if (_hwnd != IntPtr.Zero)
{
HandleRef hwnd = new HandleRef(null, _hwnd);
if (UnsafeNativeMethods.IsWindow(hwnd))
{
UnsafeNativeMethods.IntDestroyWindow(hwnd);
}
_hwnd = IntPtr.Zero;
}
if (_hBitmap != null && !_hBitmap.IsClosed)
{
UnsafeNativeMethods.DeleteObject(_hBitmap.MakeHandleRef(null).Handle);
_hBitmap.Close();
_hBitmap = null;
}
if (_wndClass != 0)
{
// Attempt to unregister the window class. If the application has a second
// splash screen which is still open this call will fail. That's OK.
if (UnsafeNativeMethods.IntUnregisterClass(new IntPtr(_wndClass), _hInstance) != 0)
{
_defWndProc = null; // Can safely release the wndproc delegate when there are no more splash screen instances
}
_wndClass = 0;
}
if (_resourceManager != null)
{
_resourceManager.ReleaseAllResources();
}
}
/// <include file='doc\PageSetupDialog.uex' path='docs/doc[@for="PageSetupDialog.RunDialog"]/*' />
/// <devdoc>
/// </devdoc>
/// <internalonly/>
protected override bool RunDialog(IntPtr hwndOwner) {
IntSecurity.SafePrinting.Demand();
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
if (pageSettings == null)
throw new ArgumentException(SR.GetString(SR.PSDcantShowWithoutPage));
NativeMethods.PAGESETUPDLG data = new NativeMethods.PAGESETUPDLG();
data.lStructSize = Marshal.SizeOf(data);
data.Flags = GetFlags();
data.hwndOwner = hwndOwner;
data.lpfnPageSetupHook = hookProcPtr;
PrinterUnit toUnit = PrinterUnit.ThousandthsOfAnInch;
// Refer VSWhidbey: 331160. Below was a breaking change from RTM and EVERETT even though this was a correct FIX.
// EnableMetric is a new Whidbey property which we allow the users to choose between the AutoConversion or not.
if (EnableMetric)
{
//take the Units of Measurement while determining the PrinterUnits...
//bug (121347)...
StringBuilder sb = new StringBuilder(2);
int result = UnsafeNativeMethods.GetLocaleInfo(NativeMethods.LOCALE_USER_DEFAULT,NativeMethods.LOCALE_IMEASURE, sb,sb.Capacity);
if (result > 0 && Int32.Parse(sb.ToString(), CultureInfo.InvariantCulture) == 0) {
toUnit = PrinterUnit.HundredthsOfAMillimeter;
}
}
if (MinMargins != null) {
Margins margins = PrinterUnitConvert.Convert(MinMargins, PrinterUnit.Display, toUnit);
data.minMarginLeft = margins.Left;
data.minMarginTop = margins.Top;
data.minMarginRight = margins.Right;
data.minMarginBottom = margins.Bottom;
}
if (pageSettings.Margins != null) {
Margins margins = PrinterUnitConvert.Convert(pageSettings.Margins, PrinterUnit.Display, toUnit);
data.marginLeft = margins.Left;
data.marginTop = margins.Top;
data.marginRight = margins.Right;
data.marginBottom = margins.Bottom;
}
// Ensure that the margins are >= minMargins.
// This is a requirement of the PAGESETUPDLG structure.
//
data.marginLeft = Math.Max(data.marginLeft, data.minMarginLeft);
data.marginTop = Math.Max(data.marginTop, data.minMarginTop);
data.marginRight = Math.Max(data.marginRight, data.minMarginRight);
data.marginBottom = Math.Max(data.marginBottom, data.minMarginBottom);
PrinterSettings printer = (printerSettings == null) ? pageSettings.PrinterSettings : printerSettings;
// GetHDevmode demands AllPrintingAndUnmanagedCode Permission : Since we are calling that function we should Assert the permision,
IntSecurity.AllPrintingAndUnmanagedCode.Assert();
try {
data.hDevMode = printer.GetHdevmode(pageSettings);
data.hDevNames = printer.GetHdevnames();
}
finally {
CodeAccessPermission.RevertAssert();
}
try {
bool status = UnsafeNativeMethods.PageSetupDlg(data);
if (!status) {
// Debug.WriteLine(Windows.CommonDialogErrorToString(Windows.CommDlgExtendedError()));
return false;
}
UpdateSettings(data, pageSettings, printerSettings); // yes, printerSettings, not printer
return true;
}
finally {
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevMode));
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevNames));
}
}
// This method should only be called from Dispose. Otherwise assumptions about the disposing/finalize state could be violated.
// force - when true, remove this subclass from the WndProc chain regardless of
// its current position. When false, remove this subclass only
// if it is possible to do so without damaging other WndProcs
// (i.e. only if this is at the head of the chain).
//
// Removing this subclass from the WndProc chain when it is not at the head
// also removes all other WndProcs that appear before this one on the chain,
// so is generally not appropriate. It is OK in the following situations:
// a) in response to the WM_NCDESTROY message
// b) in response to the AppDomainProcessExit event
// c) in response to the AppDomainExit event
// In cases (a) and (b) the HWND is being destroyed, so the earlier
// WndProcs are no longer useful anyway. In case (c), we have to remove
// all managed code from the chain lest it be called after it has been
// removed from memory; removing earlier WndProcs is unfortunate, but
// necessary. [Note that at AppDomainExit we remove all managed WndProcs,
// regardless of which AppDomain they came from. There is room for
// improvement here - we could remove only the ones belong to the AppDomain
// that is exiting. This situation seems too unlikely to worry about in V1.]
//
// This method returns true if the subclass is no longer in the WndProc chain.
//
private bool UnhookWindowProc(bool force)
{
// if we're not in the WndProc chain, there's nothing to do
if (_bond == Bond.Unattached || _bond == Bond.Detached)
{
return(true);
}
// we'll remove ourselves from the chain if we're at the head, or if
// the 'force' parameter was true.
if (!force)
{
NativeMethods.WndProc currentWndProc = UnsafeNativeMethods.GetWindowLongWndProc(new HandleRef(this, _hwndAttached));
force = (currentWndProc == _attachedWndProc);
}
// if we're not unhooking, return and report
if (!force)
{
return(false);
}
// unhook from the tracker
_bond = Bond.Orphaned; // ignore messages while we're unhooking
ManagedWndProcTracker.UnhookHwndSubclass(this);
// unhook, the Win32 way
try
{
UnsafeNativeMethods.CriticalSetWindowLong(_hwndHandleRef, NativeMethods.GWL_WNDPROC, _oldWndProc);
}
catch (System.ComponentModel.Win32Exception e)
{
if (e.NativeErrorCode != 1400) // ERROR_INVALID_WINDOW_HANDLE
{
throw;
}
}
// clear our state
_bond = Bond.Detached;
_oldWndProc = IntPtr.Zero;
_attachedWndProc = null;
_hwndAttached = IntPtr.Zero;
_hwndHandleRef = new HandleRef(null, IntPtr.Zero);
// un-Pin this object.
// Note: the GC is free to collect this object at anytime
// after we have freed this handle - that is, once all
// other managed references go away.
//AvDebug.Assert(_gcHandle.IsAllocated, "External GC handle has not been allocated.");
if (null != _gcHandle)
{
_gcHandle.Free();
}
return(true);
}
private bool RunDialogOld(IntPtr hWndOwner)
{
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
NativeMethods.OPENFILENAME_I ofn = new NativeMethods.OPENFILENAME_I();
try {
charBuffer = CharBuffer.CreateBuffer(FILEBUFSIZE);
if (fileNames != null) {
charBuffer.PutString(fileNames[0]);
}
ofn.lStructSize = Marshal.SizeOf(typeof(NativeMethods.OPENFILENAME_I));
// Degrade to the older style dialog if we're not on Win2K.
// We do this by setting the struct size to a different value
//
if (Environment.OSVersion.Platform != System.PlatformID.Win32NT ||
Environment.OSVersion.Version.Major < 5) {
ofn.lStructSize = 0x4C;
}
ofn.hwndOwner = hWndOwner;
ofn.hInstance = Instance;
ofn.lpstrFilter = MakeFilterString(filter, this.DereferenceLinks);
ofn.nFilterIndex = filterIndex;
ofn.lpstrFile = charBuffer.AllocCoTaskMem();
ofn.nMaxFile = FILEBUFSIZE;
ofn.lpstrInitialDir = initialDir;
ofn.lpstrTitle = title;
ofn.Flags = Options | (NativeMethods.OFN_EXPLORER | NativeMethods.OFN_ENABLEHOOK | NativeMethods.OFN_ENABLESIZING);
ofn.lpfnHook = hookProcPtr;
ofn.FlagsEx = NativeMethods.OFN_USESHELLITEM;
if (defaultExt != null && AddExtension) {
ofn.lpstrDefExt = defaultExt;
}
//Security checks happen here
return RunFileDialog(ofn);
}
finally {
charBuffer = null;
if (ofn.lpstrFile != IntPtr.Zero) {
Marshal.FreeCoTaskMem(ofn.lpstrFile);
}
}
}
public DialogResult ShowDialog( IWin32Window owner ) {
IntSecurity.SafeSubWindows.Demand();
if (!SystemInformation.UserInteractive) {
throw new InvalidOperationException(SR.GetString(SR.CantShowModalOnNonInteractive));
}
NativeWindow native = null;//This will be used if there is no owner or active window (declared here so it can be kept alive)
IntPtr hwndOwner = IntPtr.Zero;
DialogResult result = DialogResult.Cancel;
try {
if (owner != null) {
hwndOwner = Control.GetSafeHandle(owner);
}
if (hwndOwner == IntPtr.Zero) {
hwndOwner = UnsafeNativeMethods.GetActiveWindow();
}
if (hwndOwner == IntPtr.Zero) {
//We will have to create our own Window
native = new NativeWindow();
native.CreateHandle(new CreateParams());
hwndOwner = native.Handle;
}
if (helpMsg == 0) {
helpMsg = SafeNativeMethods.RegisterWindowMessage("commdlg_help");
}
NativeMethods.WndProc ownerProc = new NativeMethods.WndProc(this.OwnerWndProc);
hookedWndProc = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(ownerProc);
System.Diagnostics.Debug.Assert(IntPtr.Zero == defOwnerWndProc, "The previous subclass wasn't properly cleaned up");
IntPtr userCookie = IntPtr.Zero;
try {
//UnsafeNativeMethods.[Get|Set]WindowLong is smart enough to call SetWindowLongPtr on 64-bit OS
defOwnerWndProc = UnsafeNativeMethods.SetWindowLong(new HandleRef(this, hwndOwner), NativeMethods.GWL_WNDPROC, ownerProc);
if (Application.UseVisualStyles) {
userCookie = UnsafeNativeMethods.ThemingScope.Activate();
}
Application.BeginModalMessageLoop();
try {
result = RunDialog(hwndOwner) ? DialogResult.OK : DialogResult.Cancel;
}
finally {
Application.EndModalMessageLoop();
}
}
finally {
IntPtr currentSubClass = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, hwndOwner), NativeMethods.GWL_WNDPROC);
if ( IntPtr.Zero != defOwnerWndProc || currentSubClass != hookedWndProc) {
UnsafeNativeMethods.SetWindowLong(new HandleRef(this, hwndOwner), NativeMethods.GWL_WNDPROC, new HandleRef(this, defOwnerWndProc));
}
UnsafeNativeMethods.ThemingScope.Deactivate(userCookie);
defOwnerWndProc = IntPtr.Zero;
hookedWndProc = IntPtr.Zero;
//Ensure that the subclass delegate will not be GC collected until after it has been subclassed
GC.KeepAlive(ownerProc);
}
}
finally {
if (null != native) {
native.DestroyHandle();
}
}
return result;
}
/// <include file='doc\FontDialog.uex' path='docs/doc[@for="FontDialog.RunDialog"]/*' />
/// <internalonly/>
/// <devdoc>
/// <para>
/// The actual implementation of running the dialog. Inheriting classes
/// should override this if they want to add more functionality, and call
/// base.runDialog() if necessary
///
/// </para>
/// </devdoc>
protected override bool RunDialog(IntPtr hWndOwner) {
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
NativeMethods.CHOOSEFONT cf = new NativeMethods.CHOOSEFONT();
IntPtr screenDC = UnsafeNativeMethods.GetDC(NativeMethods.NullHandleRef);
NativeMethods.LOGFONT lf = new NativeMethods.LOGFONT();
Graphics graphics = Graphics.FromHdcInternal(screenDC);
// SECREVIEW : The Font.ToLogFont method is marked with the 'unsafe' modifier cause it needs to write bytes into the logFont struct,
// here we are passing that struct so the assert is safe.
//
IntSecurity.ObjectFromWin32Handle.Assert();
try {
Font.ToLogFont(lf, graphics);
}
finally {
CodeAccessPermission.RevertAssert();
graphics.Dispose();
}
UnsafeNativeMethods.ReleaseDC(NativeMethods.NullHandleRef, new HandleRef(null, screenDC));
IntPtr logFontPtr = IntPtr.Zero;
try {
logFontPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(NativeMethods.LOGFONT)));
Marshal.StructureToPtr(lf, logFontPtr, false);
cf.lStructSize = Marshal.SizeOf(typeof(NativeMethods.CHOOSEFONT));
cf.hwndOwner = hWndOwner;
cf.hDC = IntPtr.Zero;
cf.lpLogFont = logFontPtr;
cf.Flags = Options | NativeMethods.CF_INITTOLOGFONTSTRUCT | NativeMethods.CF_ENABLEHOOK;
if (minSize > 0 || maxSize > 0) {
cf.Flags |= NativeMethods.CF_LIMITSIZE;
}
//if ShowColor=true then try to draw the sample text in color,
//if ShowEffects=false then we will draw the sample text in standard control text color regardless.
//(limitation of windows control)
//
if (ShowColor || ShowEffects) {
cf.rgbColors = ColorTranslator.ToWin32(color);
}
else {
cf.rgbColors = ColorTranslator.ToWin32(SystemColors.ControlText);
}
cf.lpfnHook = hookProcPtr;
cf.hInstance = UnsafeNativeMethods.GetModuleHandle(null);
cf.nSizeMin = minSize;
if (maxSize == 0) {
cf.nSizeMax = Int32.MaxValue;
}
else {
cf.nSizeMax = maxSize;
}
Debug.Assert(cf.nSizeMin <= cf.nSizeMax, "min and max font sizes are the wrong way around");
if (!SafeNativeMethods.ChooseFont(cf)) return false;
NativeMethods.LOGFONT lfReturned = null;
lfReturned = (NativeMethods.LOGFONT)UnsafeNativeMethods.PtrToStructure(logFontPtr, typeof(NativeMethods.LOGFONT));
if (lfReturned.lfFaceName != null && lfReturned.lfFaceName.Length > 0) {
lf = lfReturned;
UpdateFont(lf);
UpdateColor(cf.rgbColors);
}
return true;
}
finally {
if (logFontPtr != IntPtr.Zero)
Marshal.FreeCoTaskMem(logFontPtr);
}
}
private bool RunLegacyDialog(IntPtr hwndOwner)
{
// Once we run the dialog, all of our communication with it is handled
// by processing WM_NOTIFY messages in our hook procedure, this.HookProc.
// NativeMethods.WndProc is a delegate with the appropriate signature
// needed for a Win32 window hook procedure.
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
// Create a new OPENFILENAME structure. OPENFILENAME is a structure defined
// in Win32's commdlg.h that contains most of the information needed to
// successfully display a file dialog box.
// NOTE: Despite the name, OPENFILENAME is the proper structure for both
// file open and file save dialogs.
NativeMethods.OPENFILENAME_I ofn = new NativeMethods.OPENFILENAME_I();
// do everything in a try block, so we always free memory in the finalizer
try
{
// Create an appropriately sized buffer to hold the filenames.
// The buffer's initial size is controlled by the FILEBUFSIZE constant,
// an arbitrary value chosen so that we will rarely have to grow the buffer.
_charBuffer = CharBuffer.CreateBuffer(FILEBUFSIZE);
// If we have a filename stored in our internal array _fileNames,
// place it in the buffer as a default filename.
if (_fileNames != null)
{
_charBuffer.PutString(_fileNames[0]);
}
// --- Set up the OPENFILENAME structure ---
// lStructSize
// Specifies the length, in bytes, of the structure.
ofn.lStructSize = Marshal.SizeOf(typeof(NativeMethods.OPENFILENAME_I));
// hwndOwner
// Handle to the window that owns the dialog box. This member can be any
// valid window handle, or it can be NULL if the dialog box has no owner.
ofn.hwndOwner = hwndOwner;
// hInstance
// This property is ignored unless OFN_ENABLETEMPLATEHANDLE or
// OFN_ENABLETEMPLATE are set. Since we do not set either,
// hInstance is ignored, so we can set it to zero.
ofn.hInstance = IntPtr.Zero;
// lpstrFilter
// Pointer to a buffer containing pairs of null-terminated filter strings.
// The last string in the buffer must be terminated by two NULL characters.
// Since our filter strings are stored terminated by vertical bar '|' chars,
// we call MakeFilterString to reformat and validate the filter string.
ofn.lpstrFilter = MakeFilterString(_filter, this.DereferenceLinks);
// nFilterIndex
// Specifies the index of the currently selected filter in the File Types
// control. Note that since 0 is reserved for a custom filter (which we
// do not support), our valid filter indexes begin at 1.
ofn.nFilterIndex = _filterIndex;
// lpstrFile
// Pointer to a buffer used to store filenames. When initializing the
// dialog, this name is used as an initial value in the File Name edit
// control. When files are selected and the function returns, the buffer
// contains the full path to every file selected.
ofn.lpstrFile = _charBuffer.AllocCoTaskMem();
// nMaxFile
// Size of the lpstrFile buffer in number of Unicode characters.
ofn.nMaxFile = _charBuffer.Length;
// lpstrInitialDir
// Pointer to a null terminated string that can specify the initial directory.
// A relatively complex algorithm is used to determine which directory is
// actually used as the initial directory - for details, see MSDN for the
// OPENFILENAME structure.
ofn.lpstrInitialDir = _initialDirectory.Value;
// lpstrTitle
// Pointer to a string to be placed in the title bar of the dialog box.
// NULL causes the title bar to display the operating system default string.
ofn.lpstrTitle = _title.Value;
// Flags
// A set of bit flags you can use to initialize the dialog box.
// Most of these will be set through public properties that then call
// GetOption or SetOption. We retrieve the flags using the Options property
// and then add three additional flags here:
//
// OFN_EXPLORER
// display an Explorer-style box (newer style)
// OFN_ENABLEHOOK
// enable the hook procedure (important for much of our functionality)
// OFN_ENABLESIZING
// allow the user to resize the dialog box
//
ofn.Flags = Options | (NativeMethods.OFN_EXPLORER |
NativeMethods.OFN_ENABLEHOOK |
NativeMethods.OFN_ENABLESIZING);
// lpfnHook
// Pointer to the hook procedure.
// Ignored unless OFN_ENABLEHOOK is set in Flags.
ofn.lpfnHook = hookProcPtr;
// FlagsEx
// Can be either zero or OFN_EX_NOPLACESBAR, depending on whether
// the Places Bar (My Computer/Favorites/etc) should be shown on the
// left side of the file dialog.
ofn.FlagsEx = NativeMethods.OFN_USESHELLITEM;
// lpstrDefExt
// Pointer to a buffer that contains the default extension; it will
// be appended to filenames if the user does not type an extension.
// Only the first three characters are appended by Windows. If this
// is NULL, no extension is appended.
if (_defaultExtension != null && AddExtension)
{
ofn.lpstrDefExt = _defaultExtension;
}
// Call into either OpenFileDialog or SaveFileDialog to show the
// actual dialog box. This call blocks until the dialog is closed;
// while dialog is open, all interaction is through HookProc.
return RunFileDialog(ofn);
}
finally
{
// Explicitly set the character buffer to null.
_charBuffer = null;
// If there is still a pointer to a memory location in
// ofn.lpstrFile, we explicitly free that memory here.
if (ofn.lpstrFile != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(ofn.lpstrFile);
}
}
}
private IntPtr CreateWindow(NativeMethods.BitmapHandle hBitmap, int width, int height, bool topMost)
{
if (_defWndProc == null)
{
_defWndProc = new MS.Win32.NativeMethods.WndProc(UnsafeNativeMethods.DefWindowProc);
}
MS.Win32.NativeMethods.WNDCLASSEX_D wndClass = new MS.Win32.NativeMethods.WNDCLASSEX_D();
wndClass.cbSize = Marshal.SizeOf(typeof(MS.Win32.NativeMethods.WNDCLASSEX_D));
wndClass.style = 3; /* CS_HREDRAW | CS_VREDRAW */
wndClass.lpfnWndProc = null;
wndClass.hInstance = _hInstance;
wndClass.hCursor = IntPtr.Zero;
wndClass.lpszClassName = CLASSNAME;
wndClass.lpszMenuName = string.Empty;
wndClass.lpfnWndProc = _defWndProc;
// We chose to ignore re-registration errors in RegisterClassEx on the off chance that the user
// wants to open multiple splash screens.
_wndClass = MS.Win32.UnsafeNativeMethods.IntRegisterClassEx(wndClass);
if (_wndClass == 0)
{
if (Marshal.GetLastWin32Error() != 0x582) /* class already registered */
{
throw new Win32Exception();
}
}
int screenWidth = MS.Win32.UnsafeNativeMethods.GetSystemMetrics(SM.CXSCREEN);
int screenHeight = MS.Win32.UnsafeNativeMethods.GetSystemMetrics(SM.CYSCREEN);
int x = (screenWidth - width) / 2;
int y = (screenHeight - height) / 2;
HandleRef nullHandle = new HandleRef(null, IntPtr.Zero);
int windowCreateFlags =
(int)NativeMethods.WS_EX_WINDOWEDGE |
NativeMethods.WS_EX_TOOLWINDOW |
NativeMethods.WS_EX_LAYERED |
(topMost ? NativeMethods.WS_EX_TOPMOST : 0);
// CreateWindowEx will either succeed or throw
IntPtr hWnd = MS.Win32.UnsafeNativeMethods.CreateWindowEx(
windowCreateFlags,
CLASSNAME, SR.Get(SRID.SplashScreenIsLoading),
MS.Win32.NativeMethods.WS_POPUP | MS.Win32.NativeMethods.WS_VISIBLE,
x, y, width, height,
nullHandle, nullHandle, new HandleRef(null, _hInstance), IntPtr.Zero);
// Display the image on the window
IntPtr hScreenDC = UnsafeNativeMethods.GetDC(new HandleRef());
IntPtr memDC = UnsafeNativeMethods.CreateCompatibleDC(new HandleRef(null, hScreenDC));
IntPtr hOldBitmap = UnsafeNativeMethods.SelectObject(new HandleRef(null, memDC), hBitmap.MakeHandleRef(null).Handle);
NativeMethods.POINT newSize = new NativeMethods.POINT(width, height);
NativeMethods.POINT newLocation = new NativeMethods.POINT(x, y);
NativeMethods.POINT sourceLocation = new NativeMethods.POINT(0, 0);
_blendFunc = new NativeMethods.BLENDFUNCTION();
_blendFunc.BlendOp = NativeMethods.AC_SRC_OVER;
_blendFunc.BlendFlags = 0;
_blendFunc.SourceConstantAlpha = 255;
_blendFunc.AlphaFormat = 1; /*AC_SRC_ALPHA*/
bool result = UnsafeNativeMethods.UpdateLayeredWindow(hWnd, hScreenDC, newLocation, newSize,
memDC, sourceLocation, 0, ref _blendFunc, NativeMethods.ULW_ALPHA);
UnsafeNativeMethods.SelectObject(new HandleRef(null, memDC), hOldBitmap);
UnsafeNativeMethods.ReleaseDC(new HandleRef(), new HandleRef(null, memDC));
UnsafeNativeMethods.ReleaseDC(new HandleRef(), new HandleRef(null, hScreenDC));
if (result == false)
{
UnsafeNativeMethods.HRESULT.Check(Marshal.GetHRForLastWin32Error());
}
return(hWnd);
}
protected override bool RunDialog(IntPtr hwndOwner)
{
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(HookProc);
if (pageSettings == null)
{
throw new ArgumentException(SR.PSDcantShowWithoutPage);
}
NativeMethods.PAGESETUPDLG data = new NativeMethods.PAGESETUPDLG();
data.lStructSize = Marshal.SizeOf(data);
data.Flags = GetFlags();
data.hwndOwner = hwndOwner;
data.lpfnPageSetupHook = hookProcPtr;
PrinterUnit toUnit = PrinterUnit.ThousandthsOfAnInch;
// Below was a breaking change from RTM and EVERETT even though this was a correct FIX.
// EnableMetric is a new Whidbey property which we allow the users to choose between the AutoConversion or not.
if (EnableMetric)
{
//take the Units of Measurement while determining the PrinterUnits...
//
StringBuilder sb = new StringBuilder(2);
int result = UnsafeNativeMethods.GetLocaleInfo(NativeMethods.LOCALE_USER_DEFAULT, NativeMethods.LOCALE_IMEASURE, sb, sb.Capacity);
if (result > 0 && int.Parse(sb.ToString(), CultureInfo.InvariantCulture) == 0)
{
toUnit = PrinterUnit.HundredthsOfAMillimeter;
}
}
if (MinMargins != null)
{
Margins margins = PrinterUnitConvert.Convert(MinMargins, PrinterUnit.Display, toUnit);
data.minMarginLeft = margins.Left;
data.minMarginTop = margins.Top;
data.minMarginRight = margins.Right;
data.minMarginBottom = margins.Bottom;
}
if (pageSettings.Margins != null)
{
Margins margins = PrinterUnitConvert.Convert(pageSettings.Margins, PrinterUnit.Display, toUnit);
data.marginLeft = margins.Left;
data.marginTop = margins.Top;
data.marginRight = margins.Right;
data.marginBottom = margins.Bottom;
}
// Ensure that the margins are >= minMargins.
// This is a requirement of the PAGESETUPDLG structure.
//
data.marginLeft = Math.Max(data.marginLeft, data.minMarginLeft);
data.marginTop = Math.Max(data.marginTop, data.minMarginTop);
data.marginRight = Math.Max(data.marginRight, data.minMarginRight);
data.marginBottom = Math.Max(data.marginBottom, data.minMarginBottom);
PrinterSettings printer = printerSettings ?? pageSettings.PrinterSettings;
data.hDevMode = printer.GetHdevmode(pageSettings);
data.hDevNames = printer.GetHdevnames();
try
{
bool status = UnsafeNativeMethods.PageSetupDlg(data);
if (!status)
{
// Debug.WriteLine(Windows.CommonDialogErrorToString(Windows.CommDlgExtendedError()));
return(false);
}
UpdateSettings(data, pageSettings, printerSettings); // yes, printerSettings, not printer
return(true);
}
finally
{
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevMode));
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevNames));
}
}
private IntPtr CreateBroadcastWindow() {
// Register the window class.
//
NativeMethods.WNDCLASS_I wndclassi = new NativeMethods.WNDCLASS_I();
IntPtr hInstance = UnsafeNativeMethods.GetModuleHandle(null);
if (!UnsafeNativeMethods.GetClassInfo(new HandleRef(this, hInstance), WndClass.lpszClassName, wndclassi)) {
if (UnsafeNativeMethods.RegisterClass(WndClass) == 0) {
windowProc = null;
Debug.Fail("Unable to register broadcast window class");
return IntPtr.Zero;
}
}
else {
//lets double check the wndproc returned by getclassinfo for defwndproc.
if (wndclassi.lpfnWndProc == DefWndProc) {
//if we are in there, it means className belongs to an unloaded appdomain.
short atom = 0;
//try to unregister it.
if (0 != UnsafeNativeMethods.UnregisterClass(WndClass.lpszClassName, new HandleRef(null, UnsafeNativeMethods.GetModuleHandle(null)))) {
atom = UnsafeNativeMethods.RegisterClass(WndClass);
}
if (atom == 0) {
do {
BumpQualifier();
atom = UnsafeNativeMethods.RegisterClass(WndClass);
} while (atom == 0 && Marshal.GetLastWin32Error() == NativeMethods.ERROR_CLASS_ALREADY_EXISTS);
}
}
}
// And create an instance of the window.
//
IntPtr hwnd = UnsafeNativeMethods.CreateWindowEx(
0,
WndClass.lpszClassName,
WndClass.lpszClassName,
NativeMethods.WS_POPUP,
0, 0, 0, 0, NativeMethods.NullHandleRef, NativeMethods.NullHandleRef,
new HandleRef(this, hInstance), null);
return hwnd;
}
public HwndWrapper(
int classStyle,
int style,
int exStyle,
int x,
int y,
int width,
int height,
string name,
IntPtr parent,
HwndWrapperHook[] hooks)
{
_ownerThreadID = new SecurityCriticalDataForSet <int>(Thread.CurrentThread.ManagedThreadId);
// First, add the set of hooks. This allows the hooks to receive the
// messages sent to the window very early in the process.
if (hooks != null)
{
for (int i = 0, iEnd = hooks.Length; i < iEnd; i++)
{
if (null != hooks[i])
{
AddHook(hooks[i]);
}
}
}
_wndProc = new SecurityCriticalData <HwndWrapperHook>(new HwndWrapperHook(WndProc));
// We create the HwndSubclass object so that we can use its
// window proc directly. We will not be "subclassing" the
// window we create.
HwndSubclass hwndSubclass = new HwndSubclass(_wndProc.Value);
// Register a unique window class for this instance.
NativeMethods.WNDCLASSEX_D wc_d = new NativeMethods.WNDCLASSEX_D();
IntPtr hNullBrush = UnsafeNativeMethods.CriticalGetStockObject(NativeMethods.NULL_BRUSH);
if (hNullBrush == IntPtr.Zero)
{
throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
}
IntPtr hInstance = UnsafeNativeMethods.GetModuleHandle(null);
// We need to keep the Delegate object alive through the call to CreateWindowEx().
// Subclass.WndProc will install a better delegate (to the same function) when it
// processes the first message.
// But this first delegate needs be held alive until then.
NativeMethods.WndProc initialWndProc = new NativeMethods.WndProc(hwndSubclass.SubclassWndProc);
// The class name is a concat of AppName, ThreadName, and RandomNumber.
// Register will fail if the string gets over 255 in length.
// So limit each part to a reasonable amount.
string appName;
if (null != AppDomain.CurrentDomain.FriendlyName && 128 <= AppDomain.CurrentDomain.FriendlyName.Length)
{
appName = AppDomain.CurrentDomain.FriendlyName.Substring(0, 128);
}
else
{
appName = AppDomain.CurrentDomain.FriendlyName;
}
string threadName;
if (null != Thread.CurrentThread.Name && 64 <= Thread.CurrentThread.Name.Length)
{
threadName = Thread.CurrentThread.Name.Substring(0, 64);
}
else
{
threadName = Thread.CurrentThread.Name;
}
// Create a suitable unique class name.
_classAtom = 0;
string randomName = Guid.NewGuid().ToString();
string className = String.Format(CultureInfo.InvariantCulture, "HwndWrapper[{0};{1};{2}]", appName, threadName, randomName);
wc_d.cbSize = Marshal.SizeOf(typeof(NativeMethods.WNDCLASSEX_D));
wc_d.style = classStyle;
wc_d.lpfnWndProc = initialWndProc;
wc_d.cbClsExtra = 0;
wc_d.cbWndExtra = 0;
wc_d.hInstance = hInstance;
wc_d.hIcon = IntPtr.Zero;
wc_d.hCursor = IntPtr.Zero;
wc_d.hbrBackground = hNullBrush;
wc_d.lpszMenuName = "";
wc_d.lpszClassName = className;
wc_d.hIconSm = IntPtr.Zero;
// Register the unique class for this instance.
// Note we use a GUID in the name so we are confident that
// the class name should be unique. And RegisterClassEx won't
// fail (for that reason).
_classAtom = UnsafeNativeMethods.RegisterClassEx(wc_d);
// call CreateWindow
_isInCreateWindow = true;
try {
_handle = new SecurityCriticalDataClass <IntPtr>(UnsafeNativeMethods.CreateWindowEx(exStyle,
className,
name,
style,
x,
y,
width,
height,
new HandleRef(null, parent),
new HandleRef(null, IntPtr.Zero),
new HandleRef(null, IntPtr.Zero),
null));
}
finally
{
_isInCreateWindow = false;
if (_handle == null || _handle.Value == IntPtr.Zero)
{
// Because the HwndSubclass is pinned, but the HWND creation failed,
// we need to manually clean it up.
hwndSubclass.Dispose();
}
}
GC.KeepAlive(initialWndProc);
}
// VSWhidbey 93449: Due to the nature of PRINTDLGEX vs PRINTDLG, separate but similar methods
// are required for showing the print dialog on Win2k and newer OS'.
private bool ShowPrintDialog(IntPtr hwndOwner, NativeMethods.WndProc hookProcPtr, NativeMethods.PRINTDLG data)
{
data.Flags = GetFlags();
data.nCopies = (short)PrinterSettings.Copies;
data.hwndOwner = hwndOwner;
data.lpfnPrintHook = hookProcPtr;
IntSecurity.AllPrintingAndUnmanagedCode.Assert();
try {
if (PageSettings == null)
{
data.hDevMode = PrinterSettings.GetHdevmode();
}
else
{
data.hDevMode = PrinterSettings.GetHdevmode(PageSettings);
}
data.hDevNames = PrinterSettings.GetHdevnames();
}
catch (InvalidPrinterException) {
data.hDevMode = IntPtr.Zero;
data.hDevNames = IntPtr.Zero;
// Leave those fields null; Windows will fill them in
}
finally {
CodeAccessPermission.RevertAssert();
}
try {
// Windows doesn't like it if page numbers are invalid
if (AllowSomePages)
{
if (PrinterSettings.FromPage < PrinterSettings.MinimumPage ||
PrinterSettings.FromPage > PrinterSettings.MaximumPage)
{
throw new ArgumentException(SR.GetString(SR.PDpageOutOfRange, "FromPage"));
}
if (PrinterSettings.ToPage < PrinterSettings.MinimumPage ||
PrinterSettings.ToPage > PrinterSettings.MaximumPage)
{
throw new ArgumentException(SR.GetString(SR.PDpageOutOfRange, "ToPage"));
}
if (PrinterSettings.ToPage < PrinterSettings.FromPage)
{
throw new ArgumentException(SR.GetString(SR.PDpageOutOfRange, "FromPage"));
}
data.nFromPage = (short)PrinterSettings.FromPage;
data.nToPage = (short)PrinterSettings.ToPage;
data.nMinPage = (short)PrinterSettings.MinimumPage;
data.nMaxPage = (short)PrinterSettings.MaximumPage;
}
if (!UnsafeNativeMethods.PrintDlg(data))
{
return(false);
}
IntSecurity.AllPrintingAndUnmanagedCode.Assert();
try {
UpdatePrinterSettings(data.hDevMode, data.hDevNames, data.nCopies, data.Flags, settings, PageSettings);
}
finally {
CodeAccessPermission.RevertAssert();
}
PrintToFile = ((data.Flags & NativeMethods.PD_PRINTTOFILE) != 0);
PrinterSettings.PrintToFile = PrintToFile;
if (AllowSomePages)
{
PrinterSettings.FromPage = data.nFromPage;
PrinterSettings.ToPage = data.nToPage;
}
// Fix Dev10 #575399, when the flag PD_USEDEVMODECOPIESANDCOLLATE is not set,
// PRINTDLG.nCopies or PRINTDLG.nCopies indicates the number of copies the user wants
// to print, and the PD_COLLATE flag in the Flags member indicates
// whether the user wants to print them collated.
// Due to a Windows OS Bug 558734, we don't need to consider Windows XP and before
if ((data.Flags & NativeMethods.PD_USEDEVMODECOPIESANDCOLLATE) == 0)
{
if (Environment.OSVersion.Version.Major >= 6)
{
PrinterSettings.Copies = data.nCopies;
PrinterSettings.Collate = ((data.Flags & NativeMethods.PD_COLLATE) == NativeMethods.PD_COLLATE);
}
}
return(true);
}
finally {
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevMode));
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevNames));
}
}
public static extern IntPtr SetWindowLongPtr64(HandleRef hWnd, int nIndex, NativeMethods.WndProc wndproc);
public DialogResult ShowDialog(IWin32Window owner)
{
if (!SystemInformation.UserInteractive)
{
throw new InvalidOperationException(SR.CantShowModalOnNonInteractive);
}
NativeWindow native = null;//This will be used if there is no owner or active window (declared here so it can be kept alive)
IntPtr hwndOwner = IntPtr.Zero;
DialogResult result = DialogResult.Cancel;
try {
if (owner != null)
{
hwndOwner = Control.GetSafeHandle(owner);
}
if (hwndOwner == IntPtr.Zero)
{
hwndOwner = UnsafeNativeMethods.GetActiveWindow();
}
if (hwndOwner == IntPtr.Zero)
{
//We will have to create our own Window
native = new NativeWindow();
native.CreateHandle(new CreateParams());
hwndOwner = native.Handle;
}
if (helpMsg == 0)
{
helpMsg = SafeNativeMethods.RegisterWindowMessage("commdlg_help");
}
NativeMethods.WndProc ownerProc = new NativeMethods.WndProc(this.OwnerWndProc);
hookedWndProc = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(ownerProc);
System.Diagnostics.Debug.Assert(IntPtr.Zero == defOwnerWndProc, "The previous subclass wasn't properly cleaned up");
IntPtr userCookie = IntPtr.Zero;
try {
//UnsafeNativeMethods.[Get|Set]WindowLong is smart enough to call SetWindowLongPtr on 64-bit OS
defOwnerWndProc = UnsafeNativeMethods.SetWindowLong(new HandleRef(this, hwndOwner), NativeMethods.GWL_WNDPROC, ownerProc);
if (Application.UseVisualStyles)
{
userCookie = UnsafeNativeMethods.ThemingScope.Activate();
}
Application.BeginModalMessageLoop();
try {
result = RunDialog(hwndOwner) ? DialogResult.OK : DialogResult.Cancel;
}
finally {
Application.EndModalMessageLoop();
}
}
finally {
IntPtr currentSubClass = UnsafeNativeMethods.GetWindowLong(new HandleRef(this, hwndOwner), NativeMethods.GWL_WNDPROC);
if (IntPtr.Zero != defOwnerWndProc || currentSubClass != hookedWndProc)
{
UnsafeNativeMethods.SetWindowLong(new HandleRef(this, hwndOwner), NativeMethods.GWL_WNDPROC, new HandleRef(this, defOwnerWndProc));
}
UnsafeNativeMethods.ThemingScope.Deactivate(userCookie);
defOwnerWndProc = IntPtr.Zero;
hookedWndProc = IntPtr.Zero;
//Ensure that the subclass delegate will not be GC collected until after it has been subclassed
GC.KeepAlive(ownerProc);
}
}
finally {
if (null != native)
{
native.DestroyHandle();
}
}
return(result);
}
public static extern IntPtr SetWindowLongPtrWndProc(HandleRef hWnd, int nIndex, NativeMethods.WndProc dwNewLong);
/// <include file='doc\PageSetupDialog.uex' path='docs/doc[@for="PageSetupDialog.RunDialog"]/*' />
/// <devdoc>
/// </devdoc>
/// <internalonly/>
protected override bool RunDialog(IntPtr hwndOwner)
{
IntSecurity.SafePrinting.Demand();
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
if (pageSettings == null)
{
throw new ArgumentException(SR.GetString(SR.PSDcantShowWithoutPage));
}
NativeMethods.PAGESETUPDLG data = new NativeMethods.PAGESETUPDLG();
data.lStructSize = Marshal.SizeOf(data);
data.Flags = GetFlags();
data.hwndOwner = hwndOwner;
data.lpfnPageSetupHook = hookProcPtr;
if (MinMargins != null)
{
PrinterUnit toUnit = PrinterUnit.ThousandthsOfAnInch;
Margins margins = PrinterUnitConvert.Convert(MinMargins, PrinterUnit.Display, toUnit);
data.minMarginLeft = margins.Left;
data.minMarginTop = margins.Top;
data.minMarginRight = margins.Right;
data.minMarginBottom = margins.Bottom;
}
if (pageSettings.Margins != null)
{
PrinterUnit toUnit = PrinterUnit.ThousandthsOfAnInch;
Margins margins = PrinterUnitConvert.Convert(pageSettings.Margins, PrinterUnit.Display, toUnit);
data.marginLeft = margins.Left;
data.marginTop = margins.Top;
data.marginRight = margins.Right;
data.marginBottom = margins.Bottom;
}
// Ensure that the margins are >= minMargins.
// This is a requirement of the PAGESETUPDLG structure.
//
data.marginLeft = Math.Max(data.marginLeft, data.minMarginLeft);
data.marginTop = Math.Max(data.marginTop, data.minMarginTop);
data.marginRight = Math.Max(data.marginRight, data.minMarginRight);
data.marginBottom = Math.Max(data.marginBottom, data.minMarginBottom);
PrinterSettings printer = (printerSettings == null) ? pageSettings.PrinterSettings : printerSettings;
IntSecurity.AllPrinting.Assert();
try {
data.hDevMode = printer.GetHdevmode(pageSettings);
data.hDevNames = printer.GetHdevnames();
}
finally {
CodeAccessPermission.RevertAssert();
}
try {
bool status = UnsafeNativeMethods.PageSetupDlg(data);
if (!status)
{
// Debug.WriteLine(Windows.CommonDialogErrorToString(Windows.CommDlgExtendedError()));
return(false);
}
UpdateSettings(data, pageSettings, printerSettings); // yes, printerSettings, not printer
return(true);
}
finally {
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevMode));
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevNames));
}
}
private bool ShowPrintDialog(IntPtr hwndOwner, NativeMethods.WndProc hookProcPtr, NativeMethods.PRINTDLG data)
{
data.Flags = GetFlags();
data.nCopies = (short)PrinterSettings.Copies;
data.hwndOwner = hwndOwner;
data.lpfnPrintHook = hookProcPtr;
try
{
if (PageSettings == null)
{
data.hDevMode = PrinterSettings.GetHdevmode();
}
else
{
data.hDevMode = PrinterSettings.GetHdevmode(PageSettings);
}
data.hDevNames = PrinterSettings.GetHdevnames();
}
catch (InvalidPrinterException)
{
data.hDevMode = IntPtr.Zero;
data.hDevNames = IntPtr.Zero;
// Leave those fields null; Windows will fill them in
}
try
{
// Windows doesn't like it if page numbers are invalid
if (AllowSomePages)
{
if (PrinterSettings.FromPage < PrinterSettings.MinimumPage ||
PrinterSettings.FromPage > PrinterSettings.MaximumPage)
{
throw new ArgumentException(string.Format(SR.PDpageOutOfRange, "FromPage"));
}
if (PrinterSettings.ToPage < PrinterSettings.MinimumPage ||
PrinterSettings.ToPage > PrinterSettings.MaximumPage)
{
throw new ArgumentException(string.Format(SR.PDpageOutOfRange, "ToPage"));
}
if (PrinterSettings.ToPage < PrinterSettings.FromPage)
{
throw new ArgumentException(string.Format(SR.PDpageOutOfRange, "FromPage"));
}
data.nFromPage = (short)PrinterSettings.FromPage;
data.nToPage = (short)PrinterSettings.ToPage;
data.nMinPage = (short)PrinterSettings.MinimumPage;
data.nMaxPage = (short)PrinterSettings.MaximumPage;
}
if (!UnsafeNativeMethods.PrintDlg(data))
{
return(false);
}
UpdatePrinterSettings(data.hDevMode, data.hDevNames, data.nCopies, data.Flags, settings, PageSettings);
PrintToFile = ((data.Flags & NativeMethods.PD_PRINTTOFILE) != 0);
PrinterSettings.PrintToFile = PrintToFile;
if (AllowSomePages)
{
PrinterSettings.FromPage = data.nFromPage;
PrinterSettings.ToPage = data.nToPage;
}
// When the flag PD_USEDEVMODECOPIESANDCOLLATE is not set,
// PRINTDLG.nCopies or PRINTDLG.nCopies indicates the number of copies the user wants
// to print, and the PD_COLLATE flag in the Flags member indicates
// whether the user wants to print them collated.
if ((data.Flags & NativeMethods.PD_USEDEVMODECOPIESANDCOLLATE) == 0)
{
PrinterSettings.Copies = data.nCopies;
PrinterSettings.Collate = ((data.Flags & NativeMethods.PD_COLLATE) == NativeMethods.PD_COLLATE);
}
return(true);
}
finally
{
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevMode));
UnsafeNativeMethods.GlobalFree(new HandleRef(data, data.hDevNames));
}
}
/// <include file='doc\PrintDialog.uex' path='docs/doc[@for="PrintDialog.RunDialog"]/*' />
/// <devdoc>
/// </devdoc>
/// <internalonly/>
// VSWhidbey 93449: Use PrintDlgEx and PRINTDLGEX on Win2k and newer OS'.
protected override bool RunDialog(IntPtr hwndOwner) {
bool returnValue = false;
IntSecurity.SafePrinting.Demand();
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
if (!UseEXDialog || (Environment.OSVersion.Platform != System.PlatformID.Win32NT ||
Environment.OSVersion.Version.Major < 5)) {
NativeMethods.PRINTDLG data = CreatePRINTDLG();
returnValue = ShowPrintDialog(hwndOwner, hookProcPtr, data);
}
else {
NativeMethods.PRINTDLGEX data = CreatePRINTDLGEX();
returnValue = ShowPrintDialog(hwndOwner, data);
}
return returnValue;
}
internal IntPtr CriticalAttach( IntPtr hwnd )
{
if(hwnd == IntPtr.Zero)
{
throw new ArgumentNullException("hwnd");
}
if(_bond != Bond.Unattached)
{
throw new InvalidOperationException();
}
NativeMethods.WndProc newWndProc = new NativeMethods.WndProc(SubclassWndProc);
IntPtr oldWndProc = UnsafeNativeMethods.GetWindowLongPtr(new HandleRef(this,hwnd), NativeMethods.GWL_WNDPROC);
HookWindowProc(hwnd, newWndProc, oldWndProc);
// Return the GC handle as a unique identifier of this
return (IntPtr) _gcHandle;
}
/// <include file='doc\ColorDialog.uex' path='docs/doc[@for="ColorDialog.RunDialog"]/*' />
/// <devdoc>
/// </devdoc>
/// <internalonly/>
protected override bool RunDialog(IntPtr hwndOwner) {
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
NativeMethods.CHOOSECOLOR cc = new NativeMethods.CHOOSECOLOR();
IntPtr custColorPtr = Marshal.AllocCoTaskMem(64);
try {
Marshal.Copy(customColors, 0, custColorPtr, 16);
cc.hwndOwner = hwndOwner;
cc.hInstance = Instance;
cc.rgbResult = ColorTranslator.ToWin32(color);
cc.lpCustColors = custColorPtr;
int flags = Options | (NativeMethods.CC_RGBINIT | NativeMethods.CC_ENABLEHOOK);
// Our docs say AllowFullOpen takes precedence over FullOpen; ChooseColor implements the opposite
if (!AllowFullOpen)
flags &= ~NativeMethods.CC_FULLOPEN;
cc.Flags = flags;
cc.lpfnHook = hookProcPtr;
if (!SafeNativeMethods.ChooseColor(cc)) return false;
if (cc.rgbResult != ColorTranslator.ToWin32(color)) color = ColorTranslator.FromOle(cc.rgbResult);
Marshal.Copy(custColorPtr, customColors, 0, 16);
return true;
}
finally {
Marshal.FreeCoTaskMem(custColorPtr);
}
}
/// <include file='doc\FontDialog.uex' path='docs/doc[@for="FontDialog.RunDialog"]/*' />
/// <internalonly/>
/// <devdoc>
/// <para>
/// The actual implementation of running the dialog. Inheriting classes
/// should override this if they want to add more functionality, and call
/// base.runDialog() if necessary
///
/// </para>
/// </devdoc>
protected override bool RunDialog(IntPtr hWndOwner)
{
NativeMethods.WndProc hookProcPtr = new NativeMethods.WndProc(this.HookProc);
NativeMethods.CHOOSEFONT cf = new NativeMethods.CHOOSEFONT();
IntPtr screenDC = UnsafeNativeMethods.GetDC(NativeMethods.NullHandleRef);
NativeMethods.LOGFONT lf = new NativeMethods.LOGFONT();
Graphics graphics = Graphics.FromHdcInternal(screenDC);
try {
Font.ToLogFont(lf, graphics);
}
finally {
graphics.Dispose();
}
UnsafeNativeMethods.ReleaseDC(NativeMethods.NullHandleRef, new HandleRef(null, screenDC));
IntPtr logFontPtr = IntPtr.Zero;
try {
logFontPtr = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(NativeMethods.LOGFONT)));
Marshal.StructureToPtr(lf, logFontPtr, false);
cf.lStructSize = Marshal.SizeOf(typeof(NativeMethods.CHOOSEFONT));
cf.hwndOwner = hWndOwner;
cf.hDC = IntPtr.Zero;
cf.lpLogFont = logFontPtr;
cf.Flags = Options | NativeMethods.CF_INITTOLOGFONTSTRUCT | NativeMethods.CF_ENABLEHOOK;
if (minSize > 0 || maxSize > 0)
{
cf.Flags |= NativeMethods.CF_LIMITSIZE;
}
//if ShowColor=true then try to draw the sample text in color,
//if ShowEffects=false then we will draw the sample text in standard control text color regardless.
//(limitation of windows control)
//
if (ShowColor || ShowEffects)
{
cf.rgbColors = ColorTranslator.ToWin32(color);
}
else
{
cf.rgbColors = ColorTranslator.ToWin32(SystemColors.ControlText);
}
cf.lpfnHook = hookProcPtr;
cf.hInstance = UnsafeNativeMethods.GetModuleHandle(null);
cf.nSizeMin = minSize;
if (maxSize == 0)
{
cf.nSizeMax = int.MaxValue;
}
else
{
cf.nSizeMax = maxSize;
}
Debug.Assert(cf.nSizeMin <= cf.nSizeMax, "min and max font sizes are the wrong way around");
if (!SafeNativeMethods.ChooseFont(cf))
{
return(false);
}
NativeMethods.LOGFONT lfReturned = null;
lfReturned = (NativeMethods.LOGFONT)UnsafeNativeMethods.PtrToStructure(logFontPtr, typeof(NativeMethods.LOGFONT));
if (lfReturned.lfFaceName != null && lfReturned.lfFaceName.Length > 0)
{
lf = lfReturned;
UpdateFont(lf);
UpdateColor(cf.rgbColors);
}
return(true);
}
finally {
if (logFontPtr != IntPtr.Zero)
{
Marshal.FreeCoTaskMem(logFontPtr);
}
}
}
public HwndWrapper(
int classStyle,
int style,
int exStyle,
int x,
int y,
int width,
int height,
string name,
IntPtr parent,
HwndWrapperHook[] hooks)
{
_ownerThreadID = new SecurityCriticalDataForSet<int>(Thread.CurrentThread.ManagedThreadId);
// First, add the set of hooks. This allows the hooks to receive the
// messages sent to the window very early in the process.
if(hooks != null)
{
for(int i = 0, iEnd = hooks.Length; i < iEnd; i++)
{
if(null != hooks[i])
AddHook(hooks[i]);
}
}
_wndProc = new SecurityCriticalData<HwndWrapperHook>(new HwndWrapperHook(WndProc));
// We create the HwndSubclass object so that we can use its
// window proc directly. We will not be "subclassing" the
// window we create.
HwndSubclass hwndSubclass = new HwndSubclass(_wndProc.Value);
// Register a unique window class for this instance.
NativeMethods.WNDCLASSEX_D wc_d = new NativeMethods.WNDCLASSEX_D();
IntPtr hNullBrush = UnsafeNativeMethods.CriticalGetStockObject(NativeMethods.NULL_BRUSH);
if (hNullBrush == IntPtr.Zero)
{
throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
}
IntPtr hInstance = UnsafeNativeMethods.GetModuleHandle( null );
// We need to keep the Delegate object alive through the call to CreateWindowEx().
// Subclass.WndProc will install a better delegate (to the same function) when it
// processes the first message.
// But this first delegate needs be held alive until then.
NativeMethods.WndProc initialWndProc = new NativeMethods.WndProc(hwndSubclass.SubclassWndProc);
// The class name is a concat of AppName, ThreadName, and RandomNumber.
// Register will fail if the string gets over 255 in length.
// So limit each part to a reasonable amount.
string appName;
if(null != AppDomain.CurrentDomain.FriendlyName && 128 <= AppDomain.CurrentDomain.FriendlyName.Length)
appName = AppDomain.CurrentDomain.FriendlyName.Substring(0, 128);
else
appName = AppDomain.CurrentDomain.FriendlyName;
string threadName;
if(null != Thread.CurrentThread.Name && 64 <= Thread.CurrentThread.Name.Length)
threadName = Thread.CurrentThread.Name.Substring(0, 64);
else
threadName = Thread.CurrentThread.Name;
// Create a suitable unique class name.
_classAtom = 0;
string randomName = Guid.NewGuid().ToString();
string className = String.Format(CultureInfo.InvariantCulture, "HwndWrapper[{0};{1};{2}]", appName, threadName, randomName);
wc_d.cbSize = Marshal.SizeOf(typeof(NativeMethods.WNDCLASSEX_D));
wc_d.style = classStyle;
wc_d.lpfnWndProc = initialWndProc;
wc_d.cbClsExtra = 0;
wc_d.cbWndExtra = 0;
wc_d.hInstance = hInstance;
wc_d.hIcon = IntPtr.Zero;
wc_d.hCursor = IntPtr.Zero;
wc_d.hbrBackground = hNullBrush;
wc_d.lpszMenuName = "";
wc_d.lpszClassName = className;
wc_d.hIconSm = IntPtr.Zero;
// Register the unique class for this instance.
// Note we use a GUID in the name so we are confident that
// the class name should be unique. And RegisterClassEx won't
// fail (for that reason).
_classAtom = UnsafeNativeMethods.RegisterClassEx(wc_d);
// call CreateWindow
_isInCreateWindow = true;
try {
_handle = new SecurityCriticalDataClass<IntPtr>(UnsafeNativeMethods.CreateWindowEx(exStyle,
className,
name,
style,
x,
y,
width,
height,
new HandleRef(null,parent),
new HandleRef(null,IntPtr.Zero),
new HandleRef(null,IntPtr.Zero),
null));
}
finally
{
_isInCreateWindow = false;
if(_handle == null || _handle.Value == IntPtr.Zero)
{
new UIPermission(UIPermissionWindow.AllWindows).Assert(); //BlessedAssert to call Dispose
try
{
// Because the HwndSubclass is pinned, but the HWND creation failed,
// we need to manually clean it up.
hwndSubclass.Dispose();
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
}
GC.KeepAlive(initialWndProc);
}
