WPF KeyDown/MouseDown event control data populating as flag

Install-Package Microsoft.Xaml.Behaviors.WPF

Install-Package newtonsoft.json

 

  <behavior:Interaction.Triggers>
      <behavior:EventTrigger EventName="MouseDown">
          <behavior:InvokeCommandAction Command="{Binding MouseDownCommand}"/>
      </behavior:EventTrigger>
      <behavior:EventTrigger EventName="KeyDown">
          <behavior:InvokeCommandAction Command="{Binding MouseDownCommand}"/>
      </behavior:EventTrigger>
  </behavior:Interaction.Triggers>


private ICommand mouseDownCommand;
public ICommand MouseDownCommand
{
    get
    {
        if (mouseDownCommand == null)
        {
            mouseDownCommand = new DelegateCommand(MouseDownCommandExecuted);
        }
        return mouseDownCommand;
    }
}

private void MouseDownCommandExecuted(object? obj)
{
    canLoad = !canLoad;
}

 

 

 

<Window x:Class="WpfApp10.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:behavior="http://schemas.microsoft.com/xaml/behaviors"
        xmlns:local="clr-namespace:WpfApp10"
        mc:Ignorable="d"
        Title="{Binding MainTitle}" WindowState="Maximized">
    <behavior:Interaction.Triggers>
        <behavior:EventTrigger EventName="MouseDown">
            <behavior:InvokeCommandAction Command="{Binding MouseDownCommand}"/>
        </behavior:EventTrigger>
        <behavior:EventTrigger EventName="KeyDown">
            <behavior:InvokeCommandAction Command="{Binding MouseDownCommand}"/>
        </behavior:EventTrigger>
    </behavior:Interaction.Triggers>
    <Window.DataContext>
        <local:MainVM/>
    </Window.DataContext>
    <Grid>
        <DataGrid ItemsSource="{Binding BksCollection}"
                  AutoGenerateColumns="True"
                  CanUserAddRows="False"
                  VirtualizingPanel.IsVirtualizing="True"
                  VirtualizingPanel.VirtualizationMode="Recycling"
                  VirtualizingPanel.CacheLength="5,5"
                  VirtualizingPanel.CacheLengthUnit="Item"
                  ScrollViewer.CanContentScroll="True"
                  ScrollViewer.IsDeferredScrollingEnabled="True"
                  UseLayoutRounding="True"
                  HeadersVisibility="Column"
                  BorderBrush="Cyan"
                  BorderThickness="5"
                  Margin="5">
            <DataGrid.Resources>
                <Style TargetType="DataGridRow">
                    <Setter Property="FontSize" Value="20"/>
                    <Style.Triggers>
                        <Trigger Property="IsMouseOver" Value="True">
                            <Setter Property="Foreground" Value="Red"/>
                            <Setter Property="FontWeight" Value="ExtraBold"/>
                        </Trigger>
                    </Style.Triggers>
                </Style>
            </DataGrid.Resources>
        </DataGrid>
    </Grid>
</Window>



using Newtonsoft.Json;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Net.Http;
using System.Runtime.CompilerServices;
using System.Text;
using System.Transactions;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace WpfApp10
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }
    }

    public class MainVM : INotifyPropertyChanged
    {
        private static string url = "http://172.17.0.106:5000/api/books/getbooks/1000000";
        private static HttpClient client = new HttpClient()
        {
            Timeout = TimeSpan.FromMinutes(1)
        };

        private static bool isLoading = false;

        private bool canLoad = true;

        public MainVM()
        {
            if (!DesignerProperties.GetIsInDesignMode(new DependencyObject()))
            {
                _ = AutoLoadDataAsync();
            }
        }


        private async Task AutoLoadDataAsync()
        {
            while(true)
            {
                await LoadDataAsync();
                await Task.Delay(1000);
            }
        }

        private async Task LoadDataAsync()
        {
            if (isLoading || !canLoad)
            {
                return;
            }
            isLoading = true;
            MainTitle = $"{DateTime.Now},loading...";
            try
            {
                string jsonStr = await client.GetStringAsync(url);
                if (!string.IsNullOrWhiteSpace(jsonStr))
                {
                    var bks = JsonConvert.DeserializeObject<List<Book>>(jsonStr);
                    if (bks != null && bks.Any())
                    {
                        BksCollection = new ObservableCollection<Book>(bks);
                        MainTitle = $"{DateTime.Now},loaded {BksCollection.Count} items," +
                            $"FirstId:{BksCollection.FirstOrDefault()?.Id}," +
                            $"LastId:{BksCollection.LastOrDefault()?.Id}";
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex?.Message);
            }
            finally
            {
                isLoading = false;
            }
        }


        private ICommand mouseDownCommand;
        public ICommand MouseDownCommand
        {
            get
            {
                if (mouseDownCommand == null)
                {
                    mouseDownCommand = new DelegateCommand(MouseDownCommandExecuted);
                }
                return mouseDownCommand;
            }
        }

        private void MouseDownCommandExecuted(object? obj)
        {
            canLoad = !canLoad;
        }

        private string mainTitle = $"{DateTime.Now}";
        public string MainTitle
        {
            get
            {
                return mainTitle;
            }
            set
            {
                if (value != mainTitle)
                {
                    mainTitle = value;
                    OnPropertyChanged();
                }
            }
        }

        private ObservableCollection<Book> bksCollection;
        public ObservableCollection<Book> BksCollection
        {
            get
            {
                return bksCollection;
            }
            set
            {
                if (value != bksCollection)
                {
                    bksCollection = value;
                    OnPropertyChanged();
                }
            }
        }

        public event PropertyChangedEventHandler? PropertyChanged;
        private void OnPropertyChanged([CallerMemberName] string propertyName = "")
        {
            var handler = Volatile.Read(ref PropertyChanged);
            if (handler == null)
            {
                return;
            }
            handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public class DelegateCommand : ICommand
    {
        private readonly Action<object?> execute;
        private readonly Func<object?, bool> canExecute;
        public DelegateCommand(Action<object?> executeValue, Func<object?, bool> canExecuteValue = null)
        {
            execute = executeValue ?? throw new ArgumentNullException(nameof(executeValue));
            canExecute = canExecuteValue;
        }

        public event EventHandler? CanExecuteChanged;

        public bool CanExecute(object? parameter)
        {
            return canExecute == null ? true : canExecute(parameter);
        }

        public void Execute(object? parameter)
        {
            execute(parameter);
        }

        public void RaiseCanExecuteChanged()
        {
            var handler = Volatile.Read(ref CanExecuteChanged);
            if (handler == null)
            {
                return;
            }

            var dispatcher = Application.Current?.Dispatcher;
            if (dispatcher != null && dispatcher.CheckAccess())
            {
                dispatcher.Invoke(() =>
                {
                    handler(this, EventArgs.Empty);
                }, System.Windows.Threading.DispatcherPriority.Background);
            }
        }
    }


    public class Book
    {
        public long Id { get; set; }
        public string Name { get; set; }
        public string ISBN { get; set; }
        public string Author { get; set; }
        public string Comment { get; set; }
        public string Content { get; set; }
        public string CategoryName { get; set; }
        public string Summary { get; set; }
        public string Title { get; set; }
        public string Topic { get; set; }
    }
}

 

 

 

 

 

 

 

 

 

 

 

paused

 

 

 

 

//Resumed