internal MediaContextNotificationWindow(MediaContext ownerMediaContext)
{
// Remember the pointer to the owner MediaContext that we'll forward the broadcasts to.
_ownerMediaContext = ownerMediaContext;
// Create a top-level, invisible window so we can get the WM_DWMCOMPOSITIONCHANGED
// and other DWM notifications that are broadcasted to top-level windows only.
HwndWrapper hwndNotification;
hwndNotification = new HwndWrapper(0, NativeMethods.WS_POPUP, 0, 0, 0, 0, 0, "MediaContextNotificationWindow", IntPtr.Zero, null);
_hwndNotificationHook = new HwndWrapperHook(MessageFilter);
_hwndNotification = new SecurityCriticalDataClass<HwndWrapper>(hwndNotification);
_hwndNotification.Value.AddHook(_hwndNotificationHook);
_isDisposed = false;
//
// On Vista, we need to know when the Magnifier goes on and off
// in order to switch to and from software rendering because the
// Vista Magnifier cannot magnify D3D content. To receive the
// window message informing us of this, we must tell the DWM
// we are MIL content.
//
// The Win7 Magnifier can magnify D3D content so it's not an
// issue there. In fact, Win7 doesn't even send the WM.
//
// If the DWM is not running, this call will result in NoOp.
//
ChangeWindowMessageFilter(s_dwmRedirectionEnvironmentChanged, 1 /* MSGFLT_ADD */);
MS.Internal.HRESULT.Check(MilContent_AttachToHwnd(_hwndNotification.Value.Handle));
}
public virtual Nullable<bool> ShowDialog()
{
CheckPermissionsToShowDialog();
// Don't allow file dialogs to be shown if not in interactive mode
// (for example, if we're running as a service)
if (!Environment.UserInteractive)
{
throw new InvalidOperationException(SR.Get(SRID.CantShowModalOnNonInteractive));
}
// Call GetActiveWindow to retrieve the window handle to the active window
// attached to the calling thread's message queue. We'll set the owner of
// the common dialog to this handle.
IntPtr hwndOwner = UnsafeNativeMethods.GetActiveWindow();
if (hwndOwner == IntPtr.Zero)
{
// No active window, so we'll use the parking window as the owner,
// if its available.
if (Application.Current != null)
{
hwndOwner = Application.Current.ParkingHwnd;
}
}
HwndWrapper tempParentHwnd = null;
try
{
// No active window and application wasn't available or didn't have
// a ParkingHwnd, we create a hidden parent window for the dialog to
// prevent breaking UIAutomation.
if (hwndOwner == IntPtr.Zero)
{
tempParentHwnd = new HwndWrapper(0, 0, 0, 0, 0, 0, 0, "", IntPtr.Zero, null);
hwndOwner = tempParentHwnd.Handle;
}
// Store the handle of the owner window inside our class so we can use it
// to center the dialog later.
_hwndOwnerWindow = hwndOwner;
// Signal that this thread is going to go modal.
try
{
ComponentDispatcher.CriticalPushModal();
return RunDialog(hwndOwner);
}
finally
{
ComponentDispatcher.CriticalPopModal();
}
}
finally
{
if (tempParentHwnd != null)
{
tempParentHwnd.Dispose();
}
}
}
private static void EnsureResourceChangeListener()
{
// Create a new notify window if we haven't already created one for this thread.
if (_hwndNotify == null)
{
// Create a top-level, invisible window so we can get the WM_THEMECHANGE notification
// and for HwndHost to park non-visible HwndHosts.
HwndWrapper hwndNotify;
hwndNotify = new HwndWrapper(0, NativeMethods.WS_POPUP|NativeMethods.WS_DISABLED, 0, 0, 0, 0, 0, "SystemResourceNotifyWindow", IntPtr.Zero, null);
_hwndNotify = new SecurityCriticalDataClass<HwndWrapper>(hwndNotify);
_hwndNotify.Value.Dispatcher.ShutdownFinished += OnShutdownFinished;
_hwndNotifyHook = new HwndWrapperHook(SystemThemeFilterMessage);
_hwndNotify.Value.AddHook(_hwndNotifyHook);
}
}
private void EnsureHwndSource()
{
// We don't support Activate, Deactivate, and SessionEnding
// events for browser hosted scenarios thus don't create
// this HwndSource if BrowserCallbackServices is valid
if (BrowserCallbackServices == null && _parkingHwnd == null)
{
// _appFilterHook needs to be member variable otherwise
// it is GC'ed and we don't get messages from HwndWrapper
// (HwndWrapper keeps a WeakReference to the hook)
_appFilterHook = new HwndWrapperHook(AppFilterMessage);
HwndWrapperHook[] wrapperHooks = {_appFilterHook};
_parkingHwnd = new HwndWrapper(
0,
0,
0,
0,
0,
0,
0,
"",
IntPtr.Zero,
wrapperHooks);
}
}
private HwndWrapper EnsureHiddenWindow()
{
if (_hiddenWindow == null)
{
_hiddenWindow = new HwndWrapper(
0, // classStyle
NativeMethods.WS_OVERLAPPEDWINDOW, // style
0, // exStyle
NativeMethods.CW_USEDEFAULT, // x
NativeMethods.CW_USEDEFAULT, // y
NativeMethods.CW_USEDEFAULT, // width
NativeMethods.CW_USEDEFAULT, // height
"Hidden Window", // name
IntPtr.Zero,
null
);
}
return _hiddenWindow;
}
private void Initialize(HwndSourceParameters parameters)
{
_mouse = new SecurityCriticalDataClass<HwndMouseInputProvider>(new HwndMouseInputProvider(this));
_keyboard = new SecurityCriticalDataClass<HwndKeyboardInputProvider>(new HwndKeyboardInputProvider(this));
_layoutHook = new HwndWrapperHook(LayoutFilterMessage);
_inputHook = new HwndWrapperHook(InputFilterMessage);
_hwndTargetHook = new HwndWrapperHook(HwndTargetFilterMessage);
_publicHook = new HwndWrapperHook(PublicHooksFilterMessage);
// When processing WM_SIZE, LayoutFilterMessage must be invoked before
// HwndTargetFilterMessage. This way layout will be updated before resizing
// HwndTarget, resulting in single render per resize. This means that
// layout hook should appear before HwndTarget hook in the wrapper hooks
// list. If this is done the other way around, first HwndTarget resize will
// force re-render, then layout will be updated according to the new size,
// scheduling another render.
HwndWrapperHook[] wrapperHooks = { _hwndTargetHook, _layoutHook, _inputHook, null };
if (null != parameters.HwndSourceHook)
{
// In case there's more than one delegate, add these to the event storage backwards
// so they'll get invoked in the expected order.
Delegate[] handlers = parameters.HwndSourceHook.GetInvocationList();
for (int i = handlers.Length -1; i >= 0; --i)
{
_hooks += (HwndSourceHook)handlers[i];
}
wrapperHooks[3] = _publicHook;
}
_restoreFocusMode = parameters.RestoreFocusMode;
_acquireHwndFocusInMenuMode = parameters.AcquireHwndFocusInMenuMode;
// A window must be marked WS_EX_LAYERED if (and only if):
// 1) it is not a child window
// -- AND --
// 2) a color-key is specified
// 3) or an opacity other than 1.0 is specified
// 4) or per-pixel alpha is requested.
if((parameters.WindowStyle & NativeMethods.WS_CHILD) == 0 &&
( //parameters.ColorKey != null ||
//!MS.Internal.DoubleUtil.AreClose(parameters.Opacity, 1.0) ||
parameters.UsesPerPixelOpacity))
{
parameters.ExtendedWindowStyle |= NativeMethods.WS_EX_LAYERED;
}
else
{
parameters.ExtendedWindowStyle &= (~NativeMethods.WS_EX_LAYERED);
}
_constructionParameters = parameters;
_hwndWrapper = new HwndWrapper(parameters.WindowClassStyle,
parameters.WindowStyle,
parameters.ExtendedWindowStyle,
parameters.PositionX,
parameters.PositionY,
parameters.Width,
parameters.Height,
parameters.WindowName,
parameters.ParentWindow,
wrapperHooks);
_hwndTarget = new HwndTarget(_hwndWrapper.Handle);
//_hwndTarget.ColorKey = parameters.ColorKey;
//_hwndTarget.Opacity = parameters.Opacity;
_hwndTarget.UsesPerPixelOpacity = parameters.UsesPerPixelOpacity;
if(_hwndTarget.UsesPerPixelOpacity)
{
_hwndTarget.BackgroundColor = Colors.Transparent;
// Prevent this window from being themed.
UnsafeNativeMethods.CriticalSetWindowTheme(new HandleRef(this, _hwndWrapper.Handle), "", "");
}
_constructionParameters = null;
if (!parameters.HasAssignedSize)
_sizeToContent = SizeToContent.WidthAndHeight;
_adjustSizingForNonClientArea = parameters.AdjustSizingForNonClientArea;
_treatAncestorsAsNonClientArea = parameters.TreatAncestorsAsNonClientArea;
// Listen to the UIContext.Disposed event so we can clean up.
// The HwndTarget cannot work without a MediaContext which
// is disposed when the UIContext is disposed. So we need to
// dispose the HwndTarget and also never use it again (to
// paint or process input). The easiest way to do this is to just
// dispose the HwndSource at the same time.
_weakShutdownHandler = new WeakEventDispatcherShutdown(this, this.Dispatcher);
// Listen to the HwndWrapper.Disposed event so we can clean up.
// The HwndTarget cannot work without a live HWND, and since
// the HwndSource represents an HWND, we make sure we dispose
// ourselves if the HWND is destroyed out from underneath us.
_hwndWrapper.Disposed += new EventHandler(OnHwndDisposed);
_stylus = new SecurityCriticalDataClass<HwndStylusInputProvider>(new HwndStylusInputProvider(this));
// WM_APPCOMMAND events are handled thru this.
_appCommand = new SecurityCriticalDataClass<HwndAppCommandInputProvider>(new HwndAppCommandInputProvider(this));
// Register the top level source with the ComponentDispatcher.
if (parameters.TreatAsInputRoot)
{
_weakPreprocessMessageHandler = new WeakEventPreprocessMessage(this, false);
}
AddSource();
// Register dropable window.
// The checking CallerHasPermissionWithAppDomainOptimization will call RegisterDropTarget
// safely without the security exception in case of no unmanaged code permission.
// So RegisterDropTarget will be called safely in case of having the unmanged code permission.
// Otherwise, the security exception cause System.Printing to be instatiated which will
// load system.drawing module.
if (_hwndWrapper.Handle != IntPtr.Zero &&
SecurityHelper.CallerHasPermissionWithAppDomainOptimization(new SecurityPermission(SecurityPermissionFlag.UnmanagedCode)))
{
// This call is safe since DragDrop.RegisterDropTarget is checking the unmanged
// code permission.
DragDrop.RegisterDropTarget(_hwndWrapper.Handle);
_registeredDropTargetCount++;
}
}
public void Dispose()
{
if (_hPowerNotify != IntPtr.Zero)
{
UnsafeNativeMethods.UnregisterPowerSettingNotification(_hPowerNotify);
_hPowerNotify = IntPtr.Zero;
}
// Remove any attached event handlers.
MonitorPowerEvent = null;
_hwndTargetCount = 0;
if (_notificationHwnd != null)
{
_notificationHwnd.Dispose();
_notificationHwnd = null;
}
}
public NotificationWindowHelper()
{
// Check for Vista or newer is needed for RegisterPowerSettingNotification.
// This check needs to rescoped to the said method call, if other
// notifications are implemented.
if (Utilities.IsOSVistaOrNewer)
{
// _notificationHook needs to be member variable otherwise
// it is GC'ed and we don't get messages from HwndWrapper
// (HwndWrapper keeps a WeakReference to the hook)
_notificationHook = new HwndWrapperHook(NotificationFilterMessage);
HwndWrapperHook[] wrapperHooks = { _notificationHook };
_notificationHwnd = new HwndWrapper(
0,
0,
0,
0,
0,
0,
0,
"",
IntPtr.Zero,
wrapperHooks);
Guid monitorGuid = new Guid(NativeMethods.GUID_MONITOR_POWER_ON.ToByteArray());
unsafe
{
_hPowerNotify = UnsafeNativeMethods.RegisterPowerSettingNotification(_notificationHwnd.Handle, &monitorGuid, 0);
}
}
}
