Пример #1
0
        public async Task ShowOverlayAsync(IMediaViewModel mediaModel, bool allowClosing, CancellationToken ct)
        {
            if (mediaModel == null)
            {
                throw new ArgumentNullException(nameof(mediaModel));
            }

            var    WINDOW_HANDLE          = new WindowInteropHelper(this).Handle;
            var    PRIMARY_SCREEN         = System.Windows.Forms.Screen.PrimaryScreen;
            IntPtr PREVIOUS_WINDOW_HANDLE = IntPtr.Zero;

            try
            {
                var CANCELATION_TOKEN_SOURCE = CreateOverlayLinkedTokenSource(ct);
                var CANCELATION_TOKEN        = CANCELATION_TOKEN_SOURCE.Token;

                var CONTENT = await Dispatcher.InvokeAsync(() =>
                {
                    var CC = new ContentControl()
                    {
                        Content         = mediaModel,
                        ContentTemplate = FindResource("VIDEO_PLAYER_TEMPLATE") as DataTemplate,
                    };
                    return(CC);
                });

                PREVIOUS_WINDOW_HANDLE = GetForegroundWindow();

                if (PREVIOUS_WINDOW_HANDLE == WINDOW_HANDLE)
                {
                    PREVIOUS_WINDOW_HANDLE = IntPtr.Zero;
                }

                SWP  SHOW_FLAGS = SWP.SWP_NOREDRAW | SWP.SWP_ASYNCWINDOWPOS;
                HWND SHOW_HWND  = PREVIOUS_WINDOW_HANDLE != IntPtr.Zero ? (HWND)PREVIOUS_WINDOW_HANDLE : HWND.HWND_NOTOPMOST;

                SetWindowPos(WINDOW_HANDLE,
                             SHOW_HWND,
                             0,
                             0,
                             PRIMARY_SCREEN.Bounds.Width,
                             PRIMARY_SCREEN.Bounds.Height,
                             SHOW_FLAGS);

                if (await OVERLAY_LOCK.WaitAsync(TimeSpan.Zero) == true)
                {
                    try
                    {
                        await ShowOverlayWithLockAsync(CONTENT, allowClosing, Timeout.InfiniteTimeSpan, CANCELATION_TOKEN);
                    }
                    catch
                    {
                        throw;
                    }
                    finally
                    {
                        OVERLAY_LOCK.Release();
                    }
                }
                else
                {
                    var WAIT_HANDLE  = new SemaphoreSlim(0, 1);
                    var CONTENT_LOCK = new ContentLock()
                    {
                        Content = CONTENT, WaitHandle = WAIT_HANDLE
                    };
                    OVERLAY_CONTENT_STACK.Push(CONTENT_LOCK);

                    ct.Register(async() =>
                    {
                        var NEW_STACK         = OVERLAY_CONTENT_STACK.Where(o => o != CONTENT_LOCK);
                        OVERLAY_CONTENT_STACK = new ConcurrentStack <ContentLock>(NEW_STACK);

                        if (OVERLAY_CONTENT_STACK.TryPeek(out var CURRENT_LOCK))
                        {
                            await Dispatcher.InvokeAsync(() => _OVERLAY_CONTENT_HOST.Content = CURRENT_LOCK.Content);
                        }
                    });

                    await Dispatcher.InvokeAsync(() => _OVERLAY_CONTENT_HOST.Content = CONTENT);

                    await WAIT_HANDLE.WaitAsync(Timeout.InfiniteTimeSpan, CANCELATION_TOKEN);
                }
            }
            catch
            {
                throw;
            }
            finally
            {
                var INSERT_AFTER = PREVIOUS_WINDOW_HANDLE != IntPtr.Zero ? (HWND)PREVIOUS_WINDOW_HANDLE : HWND.HWND_NOTOPMOST;
                SetWindowPos(WINDOW_HANDLE,
                             INSERT_AFTER,
                             0,
                             0,
                             PRIMARY_SCREEN.WorkingArea.Width,
                             PRIMARY_SCREEN.WorkingArea.Height,
                             SWP.SWP_NOREDRAW | SWP.SWP_ASYNCWINDOWPOS);
            }
        }
Пример #2
0
 public Task ShowOverlayAsync(IMediaViewModel mediaModel, bool allowClosing)
 {
     return(ShowOverlayAsync(mediaModel, allowClosing, CancellationToken.None));
 }
Пример #3
0
 public Task ShowOverlayAsync(IMediaViewModel mediaModel, CancellationToken ct)
 {
     return(ShowOverlayAsync(mediaModel, true, ct));
 }
 public MainViewModel(IMediaViewModel mediaViewModel, IDrawingViewModel drawingViewModel)
 {
     MediaViewModel   = mediaViewModel;
     DrawingViewModel = drawingViewModel;
 }