MeterVision_v3/MeterVision/Station/UCStationGrid.xaml.cs

using MeterVision.Config;
using MeterVision.db;
using MeterVision.Dlg;
using MeterVision.Helper;
using MeterVision.model;
using MeterVision.Stand;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
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 MeterVision.Station
{
    /// <summary>
    /// UCStationGrid.xaml 的交互逻辑
    /// </summary>
    public partial class UCStationGrid : UserControl, INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        private SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);

        public BulkObservableCollection<StationItem> StationItemList { get; set; }

        //修改站点参数配置命令
        //public event Action<StationItem> Station_Config;

        //修改站点事件
        //public static Action<StationItem> OnUpdateItem;
        public event Action<StationItem> OnStationItemChange;

        private StationItem _selectedStationItem;
        public StationItem SelectedStationItem
        {
            get => _selectedStationItem;
            set
            {
                if(_selectedStationItem != value)
                {
                    _selectedStationItem = value;
                    OnPropertyChanged(nameof(SelectedStationItem));
                    OnStationItemChange?.Invoke(value);
                }
            }
        }

        //要查找的站点ID
        private string _findStationId;
        private string _standId;
        private MarkFindType _markFindType;

        public async void ChangeFindAsync(string stationId, MarkFindType markFindType, string standId)
        {
            await ChangeFind(stationId, markFindType, standId);
        }

        public async Task ChangeFind(string stationId, MarkFindType markFindType,string standId)
        {
            if (!await _semaphore.WaitAsync(0)) return; // 防止重复调用

            try
            {
                _findStationId = stationId;
                _standId = standId;
                _markFindType = markFindType;

                StationPage.InitDefaulValue();
                await LoadStationItemList(true);
            }
            catch { }
            finally
            {
                _semaphore.Release();
            }
        }
        
        public CfginiItem mConfigItem { get; set; }

        public PageModel StationPage { get; set; }

        private int _totalRecords;
        public int TotalRecords
        {
            get => _totalRecords;
            set
            {
                if(_totalRecords != value)
                {
                    _totalRecords = value;
                    OnPropertyChanged(nameof(TotalRecords));
                }
            }
        }


        public UCStationGrid()
        {
            InitializeComponent();
            StationItemList = new BulkObservableCollection<StationItem>();
            dgStation.ItemsSource = StationItemList;

            mConfigItem = CfginiItem.GetConfigItem();

            StationPage = new PageModel
            {
                PageSize = mConfigItem.PageSize2, //mConfigItem.PatchPageSize,
                PageNumber = 1
            };

            //mConfigItem.OnPatchPageSizeChanged += MConfigItem_OnPatchPageSizeChanged;
            mConfigItem.OnPageSize2Changed += MConfigItem_OnPageSize2Changed;

            this.DataContext = this;
        }

        private async void MConfigItem_OnPageSize2Changed(int pageSize2)
        {
            if (!await _semaphore.WaitAsync(0)) return; // 防止重复调用
            try
            {
                StationPage.InitDefaulValue(pageSize2);
                await LoadStationItemList(true);
            }
            catch { }
            finally
            {
                _semaphore.Release();
            }
        }

        public void ChangeMarkCount()
        {
            if(SelectedStationItem == null)
            {
                return;
            }
            int iMarkCount = DBStation.GetMarkCount(SelectedStationItem.Id);
            SelectedStationItem.MarkCount = iMarkCount;

        }

        private async Task LoadStationItemList(bool scrollTop)
        {
            StationItemList.Clear();
            
            if(_findStationId == null)
            {
                return;
            }

            try
            {
                var result = await Task.Run(() =>
                {

                    //return DBStation.GetPagedTStations(StationPage.PageNumber, StationPage.PageSize,
                    return DBStation.GetPagedVStations(StationPage.PageNumber, StationPage.PageSize,
                        _findStationId, _markFindType,_standId);
                });

                //更新分页信息
                TotalRecords = result.Item1;
                StationPage.PageCount = result.Item2;
                List<TStation> stationList = result.Item3;

                //在主线中更新数据
                //Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                //{
                //int index = 0;
                //foreach(TStation station in stationList)
                //{
                //    index++;
                //    StationItem item = new StationItem(station);
                //    item.Index = index + ((StationPage.PageNumber - 1) * StationPage.PageSize);
                //    StationItemList.Add(item);
                //}

                var stationItems = stationList.Select((station, i) => new StationItem(station)
                {
                    Index = (StationPage.PageNumber - 1) * StationPage.PageSize + i + 1
                }).ToList();
                StationItemList.AddRange(stationItems);
                //StationItemList.Re

                //SelectedStationItem = null;

                if(StationItemList.Count > 0 && scrollTop)
                {
                    //await Task.Delay(100);
                    await Dispatcher.BeginInvoke(new Action(() =>
                    {
                        var scrollViewer = GetScrollViewer(dgStation);
                        scrollViewer?.ScrollToTop();
                        //dgStation.ScrollIntoView(dgStation.Items[0]);
                    }));                    
                }
                //}));
            }
            catch(Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow,
                    $"b加载数据是发生错误：{ex.Message}", "错误", 
                    MessageBoxButton.OK, MessageBoxImage.Error);
            }
            //if(StationItemList.Count > 0)
            //{
            //    SelectedStationItem = StationItemList[0];
            //}
            //else
            //{
            //    SelectedStationItem = null;
            //}            
        }

        private ScrollViewer _scrollViewer;

        private ScrollViewer GetScrollViewer(DependencyObject obj)
        {
            if (_scrollViewer != null)
            {
                return _scrollViewer;
            }

            if (obj is ScrollViewer)
            {
                _scrollViewer = (ScrollViewer)obj;
                return obj as ScrollViewer;
            }

            for (int i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++)
            {
                var child = VisualTreeHelper.GetChild(obj, i);
                var scrollViewer = GetScrollViewer(child);
                if (scrollViewer != null)
                {
                    _scrollViewer = scrollViewer;
                    return scrollViewer;
                }
            }

            return null;
        }


        private void MiUpdate_Click(object sender, RoutedEventArgs e)
        {
            if (SelectedStationItem == null) return;

            EditStationDlg2 dialog = new EditStationDlg2(SelectedStationItem)
            {
                Owner = Application.Current.MainWindow,
                WindowStartupLocation = WindowStartupLocation.CenterOwner
            };
            if (dialog.ShowDialog() == true)
            {
                SelectedStationItem = dialog.mStationItem;
            }
            //Station_Config?.Invoke(SelectedStationItem);
        }

        private void MiDelete_Click(object sender, RoutedEventArgs e)
        {
            if (SelectedStationItem == null) return;

            //获取当前行绑定的数据项
            DeleteSelectedItem(SelectedStationItem);
        }

        private static T FindAncestor<T>(DependencyObject dependencyObject) where T : DependencyObject
        {
            var parent = VisualTreeHelper.GetParent(dependencyObject);

            if (parent == null) return null;

            var parentT = parent as T;
            return parentT ?? FindAncestor<T>(parent);
        }

        private void BtnUpdateStation_Click(object sender, RoutedEventArgs e)
        {
            Button button = sender as Button;
            if (button == null) return;

            DataGridRow row = FindAncestor<DataGridRow>(button);
            if (row == null) return;

            StationItem stationItem = row.Item as StationItem;
            EditStationDlg2 dialog = new EditStationDlg2(stationItem)
            {
                Owner = Application.Current.MainWindow,
                WindowStartupLocation = WindowStartupLocation.CenterOwner
            };
            if (dialog.ShowDialog() == true)
            {
                stationItem = dialog.mStationItem;
            }
            //Station_Config?.Invoke(SelectedStationItem);
        }

        private void BtnDeleteStation_Click(object sender, RoutedEventArgs e)
        {
            Button button = sender as Button;
            if (button == null) return;

            DataGridRow row = FindAncestor<DataGridRow>(button);
            if (row == null) return;

            StationItem stationItem = row.Item as StationItem;

            DeleteSelectedItem(stationItem);
        }

        private async void DeleteSelectedItem(StationItem selectedItem)
        {
            if (selectedItem == null) return;

            MessageBoxResult result = MessageBox.Show("确定要删除此条目吗？", "确认删除", MessageBoxButton.YesNo, MessageBoxImage.Question);
            if (result != MessageBoxResult.Yes) return;

            string titleInfo = "正在删除，请稍后...";
            WaitWindow waitWindow = new WaitWindow(titleInfo)
            {
                Owner = Application.Current.MainWindow,
                WindowStartupLocation = WindowStartupLocation.CenterOwner
            };
            waitWindow.Show();

            try
            {

                bool deleteSuccess = false;
                await Task.Run(() =>
                {
                    deleteSuccess = DBStation.DeleteStationAndStandDetails(selectedItem.StandId, selectedItem.StationId);
                    //DBStation.DeleteTStation(selectedItem.StationId);
                });

                if (deleteSuccess)
                {
                    //await Application.Current.Dispatcher.BeginInvoke(new Action(() =>
                    //{
                        // 从数据源中移除该条目
                        StationItemList.Remove(selectedItem);
                        SelectedStationItem = null;
                    //}));
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(Application.Current.MainWindow, $"删除失败：{ex.Message}", "错误",
                    MessageBoxButton.OK, MessageBoxImage.Error);
            }
            finally
            {
                waitWindow.Close();
            }

        }

        public async void ClearAllStation()
        {
            if (!await _semaphore.WaitAsync(0)) return; // 防止重复调用

            try
            {
                //清空提示
                MessageBoxResult result = MessageBox.Show("确定要清空所有数据吗？", "确认清空", MessageBoxButton.YesNo, MessageBoxImage.Question);
                if (result != MessageBoxResult.Yes) return;

                string titleInfo = "正在清空数据，请稍后...";
                WaitWindow waitWindow = new WaitWindow(titleInfo)
                {
                    Owner = Application.Current.MainWindow,
                    WindowStartupLocation = WindowStartupLocation.CenterOwner
                };
                waitWindow.Show();

                try
                {
                    bool blClearAll = false;
                    await Task.Run(() =>
                    {
                        blClearAll = DBStation.ClearTStationTable();
                    });
                    if (blClearAll)
                    {
                        StationPage.InitDefaulValue();
                        await LoadStationItemList(true);
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show(Application.Current.MainWindow, $"清空失败：{ex.Message}", "错误",
                        MessageBoxButton.OK, MessageBoxImage.Error);
                }
                finally
                {
                    waitWindow.Close();
                }
            }
            catch { }
            finally
            {
                _semaphore.Release();
            }
        }

        public async Task NextPage()
        {
            if (!await _semaphore.WaitAsync(0)) return; // 防止重复调用
            try
            {
                if (StationPage.PageNumber < StationPage.PageCount)
                {
                    StationPage.PageNumber += 1;
                    await LoadStationItemList(true);
                }
            }
            catch { }
            finally
            {
                _semaphore.Release();
            }
        }

        public async Task PrePage()
        {
            if (!await _semaphore.WaitAsync(0)) return; // 防止重复调用

            try
            {
                if (StationPage.PageNumber > 1)
                {
                    StationPage.PageNumber -= 1;
                    await LoadStationItemList(true);
                }
            }
            catch{}
            finally
            {
                _semaphore.Release();
            }
        }

        public async Task FirstPage()
        {
            if (!await _semaphore.WaitAsync(0)) return; // 防止重复调用
            try
            {
                if (StationPage.PageNumber > 1)
                {
                    StationPage.PageNumber = 1;
                    await LoadStationItemList(true);
                }
            }
            catch { }
            finally
            {
                _semaphore.Release();
            }
        }

        public async Task LastPage()
        {
            if (!await _semaphore.WaitAsync(0)) return; // 防止重复调用
            try
            {
                if (StationPage.PageNumber < StationPage.PageCount)
                {
                    StationPage.PageNumber = StationPage.PageCount;
                    await LoadStationItemList(true);
                }
            }
            catch { }
            finally
            {
                _semaphore.Release();
            }
        }

        public async Task SpeciPage(int pageNumber)
        {
            if (!await _semaphore.WaitAsync(0)) return; // 防止重复调用
            try
            {
                if (pageNumber != StationPage.PageNumber &&
                    pageNumber > 0 && pageNumber <= StationPage.PageCount)
                {
                    StationPage.PageNumber = pageNumber;
                    await LoadStationItemList(true);
                }
            }
            catch { }
            finally
            {
                _semaphore.Release();
            }
        }

        //---------------------------------------------------------------------
    }
}