public Task HideLoadingGrid()
        {
            LoadingIndicator.IsActive = false;

            return(Task.Run(async() =>
            {
                for (var i = 1.0; i > 0.0; i -= 0.025)
                {
                    var opacity = i;

                    if (Math.AlmostEquals(opacity, 0.7, 0.01))
                    {
                        Dispatcher.Invoke(() =>
                        {
                            LoadingGrid.IsHitTestVisible = false;
                        });
                    }

                    Dispatcher.Invoke(() =>
                    {
                        LoadingGrid.Opacity = opacity;
                    });

                    await Task.Delay(4)
                    .ConfigureAwait(false);
                }

                Dispatcher.Invoke(() =>
                {
                    LoadingGrid.Visibility = Visibility.Collapsed;
                });
            }));
        }
        public Task ShowLoadingGrid(bool status)
        {
            if (status)
            {
                _loadingGridShowing          = true;
                loadingIndicator.IsActive    = true;
                loadingGrid.Opacity          = 1.0;
                loadingGrid.IsHitTestVisible = true;
                loadingGrid.Visibility       = Visibility.Visible;

                return(Task.CompletedTask);
            }

            _loadingGridShowing       = false;
            loadingIndicator.IsActive = false;

            return(Task.Run(async() =>
            {
                for (double i = 1.0; i > 0.0; i -= 0.025)
                {
                    var opacity = i;

                    if (_loadingGridShowing)
                    {
                        break;
                    }

                    if (Math.AlmostEquals(opacity, 0.7, 0.01))
                    {
                        Dispatcher.Invoke(() =>
                        {
                            loadingGrid.IsHitTestVisible = false;
                        });
                    }

                    Dispatcher.Invoke(() =>
                    {
                        loadingGrid.Opacity = opacity;
                    });

                    await Task.Delay(4)
                    .ConfigureAwait(false);
                }

                Dispatcher.Invoke(() =>
                {
                    loadingGrid.Visibility = Visibility.Collapsed;
                });
            }));
        }
Example #3
0
        public async Task ShowConnectionFailedGrid(bool status)
        {
            await _connectionFailedGridTask
            .ConfigureAwait(true);

            var newStatus = status ? 1 : 0;
            var oldStatus = Interlocked.Exchange(
                ref _connectionFailedGridStatus, newStatus);

            if (oldStatus == newStatus)
            {
                return;
            }

            bool changeStyleNeeded;

            if (!TitleLockStatus)
            {
                TitleLockStatus = true;
                _connectionFailedGridTitleLockStatus = true;

                changeStyleNeeded = true;
            }
            else
            {
                changeStyleNeeded = false;
            }

            if (status)
            {
                LinkOpenEnable(false);
                connectionFailedIndicator.IsActive    = true;
                connectionFailedGrid.Opacity          = 1.0;
                connectionFailedGrid.IsHitTestVisible = true;
                connectionFailedGrid.Visibility       = Visibility.Visible;

                if (changeStyleNeeded)
                {
                    Resources.MergedDictionaries
                    .Add(_loadingStyle.Dictionary);
                    Resources.MergedDictionaries
                    .Add(_loadingStyle.MahAppsDictionary);
                }

                _connectionFailedGridTask = Task.CompletedTask;
                return;
            }

            connectionFailedIndicator.IsActive = false;

            if (_connectionFailedGridTitleLockStatus)
            {
                changeStyleNeeded = true;
            }

            var color = ((SolidColorBrush)FindResource("Window.Main.TitleBackground")).Color;

            _connectionFailedGridTask = Task.Run(async() =>
            {
                Action <double> changeOpacityFunction;

                if (changeStyleNeeded)
                {
                    changeOpacityFunction = opacity =>
                    {
                        connectionFailedGrid.Opacity = opacity;

                        var brush = new SolidColorBrush(
                            Color.FromArgb((byte)(255 * opacity),
                                           color.R, color.G, color.B));

                        WindowTitleBrush          = brush;
                        NonActiveWindowTitleBrush = brush;
                    };
                }
                else
                {
                    changeOpacityFunction = opacity =>
                    {
                        connectionFailedGrid.Opacity = opacity;
                    };
                }

                var isHitTestVisible = true;

                for (double i = 1.0; i > 0.0; i -= 0.025)
                {
                    var opacity = i;

                    if (isHitTestVisible &&
                        Math.AlmostEquals(opacity, 0.7, 0.01))
                    {
                        Dispatcher.Invoke(() =>
                        {
                            connectionFailedGrid.IsHitTestVisible = false;

                            Resources.MergedDictionaries
                            .Remove(_loadingStyle.MahAppsDictionary);
                        });

                        isHitTestVisible = false;
                    }

                    Dispatcher.Invoke(() =>
                    {
                        changeOpacityFunction(opacity);
                    });

                    await Task.Delay(4)
                    .ConfigureAwait(false);
                }

                Dispatcher.Invoke(() =>
                {
                    if (changeStyleNeeded)
                    {
                        Resources.MergedDictionaries
                        .Remove(_loadingStyle.Dictionary);

                        SetResourceReference(WindowTitleBrushProperty, "Window.Main.TitleBackground");
                        SetResourceReference(NonActiveWindowTitleBrushProperty, "Window.Main.NonActiveTitleBackground");
                    }

                    connectionFailedGrid.IsHitTestVisible = false;
                    connectionFailedGrid.Visibility       = Visibility.Collapsed;
                    LinkOpenEnable(true);

                    if (changeStyleNeeded)
                    {
                        TitleLockStatus = false;
                        _connectionFailedGridTitleLockStatus = false;
                    }
                });
            });
        }