diff --git a/src/client/spark/Modules/Trading/Fills/FillsVM.cs b/src/client/spark/Modules/Trading/Fills/FillsVM.cs index 3afb8d280..5abb11998 100644 --- a/src/client/spark/Modules/Trading/Fills/FillsVM.cs +++ b/src/client/spark/Modules/Trading/Fills/FillsVM.cs @@ -1,114 +1,145 @@ using bts.api; -using bts.shell; using bts.spark; -using Google.Protobuf; -using mbts.spark.menu_items; -using mbts.spark.utilities; using mbts.ui; -using mbts.ui.shell; -using mbts.ui.spark; -using mbts.ui.utility; -using ProtoBuf; using System; using System.Collections.Generic; -using System.Collections.ObjectModel; using System.ComponentModel; -using System.IO; using System.Linq; using System.Reactive.Linq; -using System.Windows.Data; +using static bts.shell.FillsWindowFactory; +using static mbts.spark.DataGridColumnFilters; +using static mbts.ui.spark.FillsView; namespace mbts.spark { - internal class FillsVM : DisposableViewModelBase + class FillsVM : SecurityGrid { - public FillsVM(FillsWindowFactory factory, IBus bus, DemoOrdersModel model, SecuritySource ssrc, IEnumerable securities, IEnumerable sorting_criteria = null) { - _bus = bus; + static IObservable> _row_models(DemoOrdersModel model, IReadOnlyCollection securities) => + model.on_orderbook().Buffer(TimeSpan.FromSeconds(1)).Where(obs => obs.Count > 0).Select(obs => obs[obs.Count - 1]).Select(ob => { + var map = ob.get_fill_tuple_sec_map(); + if (securities.Count == 0) return map.SelectMany(kv => kv.Value); + else { + var sec_keys = securities.Select(s => s.Id).ToList(); + return map.Where(kv => sec_keys.Contains(kv.Key)).SelectMany(kv => kv.Value); + } + }); + + public FillsVM(IBus bus, DemoOrdersModel model, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria, FilterStates filters) + : base(_row_models(model, securities), sorting_criteria) { _model = model; - _factory = factory; - _securities = new HashSet(securities ?? Enumerable.Empty()); - _rows = new ObservableAutoWrapper(_fills, f => new Row(f, _model)); - rows_view = CollectionViewSource.GetDefaultView(_rows); if (sorting_criteria != null) rows_view.SortDescriptions.AddRange(sorting_criteria.Select(sc => sc.to_sort_description())); else rows_view.SortDescriptions.Add(new SortDescription(nameof(Row.fill_time), ListSortDirection.Descending)); - _dispose = Disposable.Create( - _context_menu = new ContextMenuVM(_context_menu_item_factory), - _model.on_orderbook().Buffer(TimeSpan.FromSeconds(1)).Where(obs => obs.Count > 0).Select(obs => obs[obs.Count - 1]).ObserveOnDispatcher().Subscribe(ob => { _order_book = ob; _update(); }) - ); - modify_security_selection = new DialogCommand(() => new SecuritySelectorDialog { - DataContext = new SecuritySelectorDialogVM("Fills", _securities.ToArray(), - secs => { - _securities = new HashSet(secs); - _update(); - }, ssrc) - }, () => true, true, -12, -30); - } - - private readonly IBus _bus; - private readonly FillsWindowFactory _factory; - private readonly DemoOrdersModel _model; - private readonly ObservableCollection _fills = new ObservableCollection(); - private readonly ObservableAutoWrapper _rows; - private HashSet _securities; - private IOrderBook _order_book = new OrderBook(); - private List _update_log = new List(); - private ContextMenuVM _context_menu; - - private void _update() { - var map = _order_book.get_fill_tuple_sec_map(); - if (_securities.Count == 0) _fills.sync_with(map.SelectMany(kv => kv.Value)); - else { - var sec_keys = _securities.Select(s => s.Id).ToList(); - _fills.sync_with(map.Where(kv => sec_keys.Contains(kv.Key)).SelectMany(kv => kv.Value)); + order_time_filter = new Time(r => r.order_time, nameof(Row.order_time)); + fill_time_filter = new Time(r => r.fill_time, nameof(Row.fill_time)); + time_in_force_filter = new DiscreteValues(_rows_vm, r => r.time_in_force, nameof(Row.time_in_force)); + order_type_filter = new DiscreteValues(_rows_vm, r => r.order_type, nameof(Row.order_type)); + account_filter = new DiscreteValues(_rows_vm, r => r.account, nameof(Row.account)); + user_filter = new DiscreteValues(_rows_vm, r => r.user, nameof(Row.user)); + exchange_filter = new DiscreteValues(_rows_vm, r => r.exchange, nameof(Row.exchange)); + security_filter = new DiscreteValues(_rows_vm, r => r.security, secs => new SecurityCriteria(secs), c => c.securities(bus), nameof(Row.security)); + side_filter = new DiscreteValues(_rows_vm, r => r.side, nameof(Row.side)); + price_filter = new DoubleMinMax(r => r.price, nameof(Row.price)); + size_filter = new UIntMinMax(r => r.size, nameof(Row.size)); + fill_percentage_filter = new DoubleMinMax(r => r.fill_percentage, nameof(Row.fill_percentage)); + order_percentage_filter = new DoubleMinMax(r => r.order_percentage, nameof(Row.order_percentage)); + order_status_filter = new DiscreteValues(_rows_vm, r => r.order_status, nameof(Row.order_status)); + bts_fill_id_filter = new RegexFinder(r => r.bts_fill_id, nameof(Row.bts_fill_id)); + bts_order_id_filter = new RegexFinder(r => r.bts_order_id, nameof(Row.bts_order_id)); + exch_order_id_filter = new RegexFinder(r => r.exch_order_id, nameof(Row.exch_order_id)); + if (filters != null) { + order_time_filter.load_state(filters.order_time); + fill_time_filter.load_state(filters.fill_time); + time_in_force_filter.load_state(filters.time_in_force); + order_type_filter.load_state(filters.order_type); + account_filter.load_state(filters.account); + user_filter.load_state(filters.user); + exchange_filter.load_state(filters.exchange); + security_filter.load_state(filters.security); + side_filter.load_state(filters.side); + price_filter.load_state(filters.price); + size_filter.load_state(filters.size); + fill_percentage_filter.load_state(filters.fill_percentage); + order_percentage_filter.load_state(filters.order_percentage); + order_status_filter.load_state(filters.order_status); + bts_fill_id_filter.load_state(filters.bts_fill_id); + bts_order_id_filter.load_state(filters.bts_order_id); + exch_order_id_filter.load_state(filters.exch_order_id); } - } - private IEnumerable _context_menu_item_factory() { - var selected_rows = _rows.Where(r => r.is_selected); - var securities = new HashSet(selected_rows.Select(r => r.security.value)); - yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); - yield return MenuItemVM.Create(new OrderTicketMenuItem(_model), securities); - yield return MenuItemVM.Create(new MarketViewMenuItem(_bus), securities); - yield return MenuItemVM.Create(new SpreadMatrixMenuItem(_bus), securities); - yield return MenuItemVM.Create(new SyntheticCreateMenuItem(_bus), securities); - yield return MenuItemVM.Create(new SyntheticStrategyMenuItem(_bus), securities); - yield return MenuItemVM.Create(new ModifyOrderRootMenuItem(_model, new HashSet(selected_rows.Select(r => r.entry.order()))), securities); - yield return MenuItemVM.Create(new CancelOrderRootMenuItem(_model, new HashSet(selected_rows.Where(r => r.entry.status() != OrderStatus.Types.Status.Canceled).Select(r => r.entry.order()))), securities); - yield return MenuItemVM.Create(new CancelBuyOrdersMenuItem(_model), securities); - yield return MenuItemVM.Create(new CancelSellOrdersMenuItem(_model), securities); - yield return MenuItemVM.Create(new CancelOrdersMenuItem(_model), securities); + _resources.Add(hook_filters(rows_view, + order_time_filter, fill_time_filter, time_in_force_filter, order_type_filter, account_filter, user_filter, exchange_filter, security_filter, side_filter, + price_filter, size_filter, fill_percentage_filter, order_percentage_filter, order_status_filter, bts_fill_id_filter, bts_order_id_filter, exch_order_id_filter + )); } - public IDialogCommand modify_security_selection { get; } - public ICollectionView rows_view { get; private set; } - public ContextMenuVM context_menu => _context_menu; + readonly DemoOrdersModel _model; - public void get_state(Stream save_here) { - _factory.save(new StartupData(_securities, rows_view.SortDescriptions.Select(sd => new SortingCriteria(sd)).ToArray()), save_here); - } + public IDataGridColumnPersistentFilter order_time_filter { get; } + public IDataGridColumnPersistentFilter fill_time_filter { get; } + public IDataGridColumnPersistentFilter time_in_force_filter { get; } + public IDataGridColumnPersistentFilter order_type_filter { get; } + public IDataGridColumnPersistentFilter account_filter { get; } + public IDataGridColumnPersistentFilter user_filter { get; } + public IDataGridColumnPersistentFilter exchange_filter { get; } + public IDataGridColumnPersistentFilter security_filter { get; } + public IDataGridColumnPersistentFilter side_filter { get; } + public IDataGridColumnPersistentFilter price_filter { get; } + public IDataGridColumnPersistentFilter size_filter { get; } + public IDataGridColumnPersistentFilter fill_percentage_filter { get; } + public IDataGridColumnPersistentFilter order_percentage_filter { get; } + public IDataGridColumnPersistentFilter order_status_filter { get; } + public IDataGridColumnPersistentFilter bts_fill_id_filter { get; } + public IDataGridColumnPersistentFilter bts_order_id_filter { get; } + public IDataGridColumnPersistentFilter exch_order_id_filter { get; } - private class Row { - public Row(FillTuple fill, DemoOrdersModel model) { + public FilterStates get_filters() => + new FilterStates { + order_time = order_time_filter.get_state(), + fill_time = fill_time_filter.get_state(), + time_in_force = time_in_force_filter.get_state(), + order_type = order_type_filter.get_state(), + account = account_filter.get_state(), + user = user_filter.get_state(), + exchange = exchange_filter.get_state(), + security = security_filter.get_state(), + side = side_filter.get_state(), + price = price_filter.get_state(), + size = size_filter.get_state(), + fill_percentage = fill_percentage_filter.get_state(), + order_percentage = order_percentage_filter.get_state(), + order_status = order_status_filter.get_state(), + bts_fill_id = bts_fill_id_filter.get_state(), + bts_order_id = bts_order_id_filter.get_state(), + exch_order_id = exch_order_id_filter.get_state() + }; + + protected override Row row_factory(FillTuple row_model) => new Row(row_model, _model); + + protected override IEnumerable get_default_sorting() { yield return new SortingCriteria(nameof(Row.fill_time), false); } + + public class Row : SecurityRow + { + public Row(FillTuple fill, DemoOrdersModel model) : base(fill.Fill.Order.Security) { _fill = fill.Fill; _entry = fill.OrderBookEntry; _model = model; - security = new SelectableViewModelBase(_fill.Order.Security, SecurityDataHelper.Comparer.Instance); uint aggr_fills = 0; foreach (var f in _entry.Fills) if (f.Timestamp <= _fill.Timestamp) aggr_fills += f.Size; order_percentage = (double)aggr_fills / (double)_fill.Order.Size; } - private readonly DemoOrdersModel _model; - private readonly DemoFill _fill; - private readonly OrderBookEntry _entry; + + readonly DemoOrdersModel _model; + readonly DemoFill _fill; + readonly OrderBookEntry _entry; + public OrderBookEntry entry => _entry; public DateTime order_time => _entry.order().Timestamp.lldatetime(); public DateTime fill_time => _fill.Timestamp.lldatetime(); public Order.Types.TimeInForce time_in_force => _fill.Order.TimeInForce; - public Order.AlgoOrderTypeOneofCase algo_type => _fill.Order.AlgoOrderTypeCase; + public Order.AlgoOrderTypeOneofCase order_type => _fill.Order.AlgoOrderTypeCase; public OrderMetadata order_metadata => _model.get_metadata(_fill.Order.AlgoOrderTypeCase); public string account => _fill.Order.Account; public string user => _fill.Order.User; public Venue exchange => _fill.Order.Security.Exchange; - public SelectableViewModelBase security { get; } public Side side => _fill.Order.Side; public double price => _fill.Price; public uint size => _fill.Size; @@ -119,21 +150,6 @@ namespace mbts.spark public string bts_fill_id => _fill.Id.Id; public string bts_order_id => _fill.Order.Id.Id; public string exch_order_id => "None because this is a simulation."; - public bool is_selected { get; set; } - } - - [ProtoContract] - public class StartupData { - public const int Version = 1; - public StartupData() { } - public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { - if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); - this.sorting_criteria = sorting_criteria; - } - [ProtoMember(1)] - public byte[][] securities; - [ProtoMember(2)] - public SortingCriteria[] sorting_criteria; } } } \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/Fills/FillsView.xaml b/src/client/spark/Modules/Trading/Fills/FillsView.xaml index d953549f6..d18ca89d5 100644 --- a/src/client/spark/Modules/Trading/Fills/FillsView.xaml +++ b/src/client/spark/Modules/Trading/Fills/FillsView.xaml @@ -1,68 +1,112 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/Fills/FillsView.xaml.cs b/src/client/spark/Modules/Trading/Fills/FillsView.xaml.cs index 3da6755f9..513c2924f 100644 --- a/src/client/spark/Modules/Trading/Fills/FillsView.xaml.cs +++ b/src/client/spark/Modules/Trading/Fills/FillsView.xaml.cs @@ -7,8 +7,37 @@ namespace mbts.ui.spark /// public partial class FillsView : UserControl { + public enum Columns { OrderTime, FillTime, User, Account, Exchange, Security, TimeInForce, AlgoType, Side, Price, Size, FillPercentage, OrderPercentage, OrderStatus, BTSFillID, BTSOrderID, ExchangeOrderID } + public FillsView() { InitializeComponent(); } } + + /* + + + + + + + + + + + + + + + + + + + + + + + + + */ } \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/Fills/FillsWindow.cs b/src/client/spark/Modules/Trading/Fills/FillsWindow.cs new file mode 100644 index 000000000..a25610250 --- /dev/null +++ b/src/client/spark/Modules/Trading/Fills/FillsWindow.cs @@ -0,0 +1,97 @@ +using bts.api; +using bts.shell; +using bts.spark; +using mbts.ui; +using mbts.ui.spark; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reactive.Linq; +using System.Threading.Tasks; +using System.Windows; +using System.Windows.Media; + +namespace mbts.spark +{ + class FillsWindow : SparkWindow + { + readonly StateSubject _vm = new StateSubject(); + + FillsWindowFactory.StartupData _state; + FillsView _view; + FillsWindowFactory _factory; + + IDisposable _subscriptions; + IReadOnlyDictionary _md = new Dictionary(); + + PartialCommand _criteria_callback_command; + + public static async Task create(FillsWindowFactory factory, IBus bus, FillsWindowFactory.StartupData state, ImageSource icon) { + var window = new FillsWindow(factory, bus, icon); + await window.initialize(state); + return window; + } + + FillsWindow(FillsWindowFactory factory, IBus bus, ImageSource icon) : base("Fills", bus, factory, SparkCommands.ShowFills.icon) { + _factory = factory; + + ITag _updated_security_criteria_tag = new SparkTags.SparkTag("Fills Callback"); + _criteria_callback_command = SparkCommand.create("Update Fills", SparkCommands.ShowFills.icon, _updated_security_criteria_tag); + + Commands = new SparkCommand[] { + SparkCommand.create("Update Securities", Icons.Admin, SparkTags.ShowAndEditPickMultiple, () => (_criteria_callback_command, _state.security_criteria)), + SparkCommands.ShowLadder.complete(_vm.SelectMany(vm => vm.current_security_md_observable(_md)), md => md.HasValue, md => md.Value), + // TODO: ShowLinkedLadder + SparkCommands.ShowOrderTicket.complete(_vm.SelectMany(vm => vm.current_security_md_observable(_md)), md => md.HasValue, md => md.Value), + // TODO: ShowLinkedOrderTicket + SparkCommands.ShowTimeAndSales.complete(_vm.SelectMany(vm => vm.current_security_observable), s => s.HasValue, s => new SecurityCriteria(s.Value)), + SparkCommands.ShowMarketView.complete(_vm.SelectMany(vm => vm.current_security_observable), s => s.HasValue, s => new SecurityCriteria(s.Value)), + // SpreadMatrix ?? + // SyntheticCreate + SparkCommands.ShowSyntheticSpreads, + // ModifyOrder - await orders + // CancelOrdersRoot ? + SparkCommands.CancelBuyOrders, + SparkCommands.CancelSellOrders, + SparkCommands.CancelOrders, + }; + + _subscriptions = Disposable.Create( + _bus.subscribe(_updated_security_criteria_tag).ObserveOnDispatcher().Subscribe(update_criteria), + _bus.subscribe(SparkTags.SecuritiesTag).Subscribe(md => _md = md)); + } + + public async Task initialize(FillsWindowFactory.StartupData state) { + Logger.notnull(state); + _state = state; + var securities = await state.security_criteria.securities(_bus); + _vm.Current()?.Dispose(); + _vm.OnNext(new FillsVM(_bus, new DemoOrdersModel(_bus), securities.ToList(), state.sorting_criteria, state.filters)); + if (_view == null) _view = new FillsView { DataContext = _vm.Current() }; + else _view.DataContext = _vm.Current(); + } + + public void update_criteria(SecurityCriteria c) => initialize(new FillsWindowFactory.StartupData(c, _vm.Current().rows_view.GetSortingCriteria(), _vm.Current().get_filters())).ignore(); + + public override UIElement Content => _view; + + SecurityMD? current_security { + get { + var security = _vm.Current().current_security; + if (security.HasValue && _md.TryGetValue(security.Value.Id, out SecurityMD md)) return md; + else return null; + } + } + + public override IEnumerable Commands { get; } + + public override FillsWindowFactory.StartupData SaveState => _state = new FillsWindowFactory.StartupData(_state.security_criteria, _vm.Current().rows_view.GetSortingCriteria(), _vm.Current().get_filters()); + + public override void Dispose() { + Disposable.dispose(ref _subscriptions); + _vm.Current()?.Dispose(); + foreach (var c in Commands.OfType()) c.Dispose(); + } + } +} \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/Fills/FillsWindowFactory.cs b/src/client/spark/Modules/Trading/Fills/FillsWindowFactory.cs index 245bffb58..b20aae422 100644 --- a/src/client/spark/Modules/Trading/Fills/FillsWindowFactory.cs +++ b/src/client/spark/Modules/Trading/Fills/FillsWindowFactory.cs @@ -1,39 +1,97 @@ using bts.api; +using bts.spark; +using mbts; using mbts.spark; using mbts.ui; -using mbts.ui.spark; +using ProtoBuf; using System; using System.Collections.Generic; -using System.Linq; using System.Reactive.Linq; using System.Threading.Tasks; -using static mbts.ui.shell.ProtoBufSerializationHelper; +using static mbts.spark.DataGridColumnFilters; -namespace bts.shell { - internal class FillsWindowFactory : ShellWindowFactory { - readonly IBus _bus; - readonly SecuritySource _ssrc; +namespace bts.shell +{ + class FillsWindowFactory : ShellWindowFactory + { + IBus _bus; + IWindowManager _wm; + IReadOnlyDictionary _securities = new Dictionary(); - public FillsWindowFactory(IShellModule owner, IBus bus, SecuritySource ssrc) : base(owner, "Fills") { + public FillsWindowFactory(TradingShellModule module, IBus bus, IWindowManager wm) : base(module, "Fills") { _bus = bus; - _ssrc = ssrc; - _dispose = _bus.subscribe(SparkTags.ShowFillsTag).Subscribe(show_fills_window); + _wm = wm; + _dispose = Disposable.Create( + bus.subscribe(SparkTags.SecuritiesTag).Subscribe(s => _securities = s), + bus.subscribe(SparkTags.ShowFillsTag).ObserveOnDispatcher().Subscribe(show) + ); } - - void show_fills_window(SecurityCriteria secs) { - } - IShellWindow create_fills_window(IEnumerable secs, IEnumerable sort) { - var vm = new FillsVM(this, _bus, new DemoOrdersModel(_bus), _ssrc, secs, sort); - var view = new FillsView { DataContext = vm, Width = 1024, Height = 800 }; - return ShellWindow.create(module, "Fills", view, vm.get_state, Icons.Ticket); - } - IShellWindow create_fills_window(FillsVM.StartupData startup_data) { - return create_fills_window(startup_data.securities?.Select(x => (SecurityImmutable)deserialize(x)).ToList(), startup_data.sorting_criteria); + public override async Task load(StartupData state) { + return await FillsWindow.create(this, _bus, state, SparkCommands.PickFills.icon); } - public override Task load(FillsVM.StartupData state) { - return Task.FromResult(create_fills_window(state)); + public async void show(SecurityCriteria criteria) { + var w = await load(new StartupData(criteria)); + _bus.post(SparkTags.ShowWindow, w); + } + + [ProtoContract] + public class StartupData + { + public const int Version = 1; + public StartupData() { } + public StartupData(SecurityCriteria securities) : this(securities, null, null) { } + public StartupData(SecurityCriteria securities, List sorting_criteria, FilterStates filters) { + this.security_criteria = securities; + this.sorting_criteria = sorting_criteria; + this.filters = filters; + } + [ProtoMember(1)] + public SecurityCriteria security_criteria; + [ProtoMember(2)] + public List sorting_criteria; + [ProtoMember(3)] + public FilterStates filters; + } + + [ProtoContract] + public class FilterStates + { + [ProtoMember(1)] + public TimeFilterState order_time; + [ProtoMember(2)] + public TimeFilterState fill_time; + [ProtoMember(3)] + public Order.Types.TimeInForce[] time_in_force; + [ProtoMember(4)] + public Order.AlgoOrderTypeOneofCase[] order_type; + [ProtoMember(5)] + public string[] account; + [ProtoMember(6)] + public string[] user; + [ProtoMember(7)] + public Venue[] exchange; + [ProtoMember(8)] + public SecurityCriteria security; + [ProtoMember(9)] + public Side[] side; + [ProtoMember(10)] + public DoubleMinMaxState price; + [ProtoMember(11)] + public UIntMinMaxState size; + [ProtoMember(12)] + public DoubleMinMaxState fill_percentage; + [ProtoMember(13)] + public DoubleMinMaxState order_percentage; + [ProtoMember(14)] + public OrderStatus.Types.Status[] order_status; + [ProtoMember(15)] + public string bts_fill_id; + [ProtoMember(16)] + public string bts_order_id; + [ProtoMember(17)] + public string exch_order_id; } } } \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/TradingShellModule.cs b/src/client/spark/Modules/Trading/TradingShellModule.cs index 135868333..b6e20fdac 100644 --- a/src/client/spark/Modules/Trading/TradingShellModule.cs +++ b/src/client/spark/Modules/Trading/TradingShellModule.cs @@ -27,7 +27,7 @@ namespace bts.shell { public TradingShellModule(IBus bus, IWindowManager wm, SecuritySource ssrc, OrdersModel orders_model) { _lwf = new LadderWindowFactory(this, bus, wm); _obwf = new OrderBookWindowFactory(this, bus, orders_model); - _fwf = new FillsWindowFactory(this, bus, ssrc); + _fwf = new FillsWindowFactory(this, bus, wm); _plwf = new PositionWindowFactory(this, bus); _order_tickets = new ShowOrderTicketHandler(bus); } diff --git a/src/client/spark/view/Controls/DataGridEx/Filters/Views/FilterTemplates.xaml b/src/client/spark/view/Controls/DataGridEx/Filters/Views/FilterTemplates.xaml index 56ad9e23e..c43063ed7 100644 --- a/src/client/spark/view/Controls/DataGridEx/Filters/Views/FilterTemplates.xaml +++ b/src/client/spark/view/Controls/DataGridEx/Filters/Views/FilterTemplates.xaml @@ -38,4 +38,10 @@ + + + + + + \ No newline at end of file