Compare commits

...
115 Commits
Author SHA1 Message Date
Pete Fisher 21e4ea0cd6 fixed use_onixs 2020-11-17 15:38:59 -05:00
Pedro Pinto eb53eb1cbc Used clearing account to populate tag 116 (ATID) 2020-11-17 08:52:03 -05:00
John Colvin 661243bd56 dj work (added some settings to ladder left panel) 2020-11-12 14:00:30 -06:00
Taha Afzal 447d3303d1 Time based throttles code complete 2020-09-28 09:57:29 -04:00
Taha Afzal 5693fc4444 Merge branch 'DJ_ICE' of bitbucket.org:bluetradesys/spark into DJ_ICE 2020-09-27 22:48:30 -04:00
Taha Afzal 8896066e2c Time based price throttles 2020-09-25 09:49:19 -04:00
John Colvin 4992f4e0cf config toggle to show/hide ladder scrollbar for dj (defaults to hide) 2020-09-24 16:25:43 -05:00
John Colvin 3503946011 add quote-time-throttle params to SyntheticEditor gui 2020-09-21 19:28:41 -05:00
John Colvin d31d8648f1 frozen price lines in ladder (for dj) 2020-09-09 16:39:53 -04:00
Taha Afzal 2c15f83c85 merge fix 2020-08-26 09:49:16 -04:00
Taha Afzal f9dfb04fca tooltip change 2020-08-25 23:02:02 -04:00
Taha Afzal 680b19b6fb Enable Hedging and Lean Ticks Offset 2020-08-25 22:58:15 -04:00
John Colvin f790b8f59b RiskManagement view updates when imported row overwrites existing one 2020-08-20 11:14:56 -05:00
John Colvin fbed8e5428 fix AdminModel.delete_risk_limits: don't increment i at end of iteration when an item is removed 2020-08-14 13:15:35 -05:00
John Colvin 524f3be25a RiskManagementWindow - imported rows weren't filtered by account 2020-08-14 11:21:49 -05:00
John Colvin 9823b44083 RiskManagementWindow - hook up menu display vm 2020-08-14 11:04:14 -05:00
John Colvin 30feda72bb Merged DJ_ICE_proprietary_risk into DJ_ICE 2020-08-14 10:54:47 -05:00
John Colvin 2d0e63546d Merge branch 'DJ_ICE' into DJ_ICE_proprietary_risk 2020-08-14 10:53:26 -05:00
John Colvin cc02fa1c84 risk limits import dialog (for dj) 2020-08-13 14:13:44 -05:00
Taha Afzal 6139d53e49 Merge branch 'DJ_ICE' of bitbucket.org:bluetradesys/spark into DJ_ICE 2020-08-12 15:04:34 -04:00
Taha Afzal 7f3c2e75a3 Fixed the qty in the leg fills for spreads with different exchange_qty_mults 2020-08-12 15:04:15 -04:00
John Colvin 0f61e24ae5 fix ColumnBase.SortDirection binding to DIYGridColumnModel 2020-08-12 13:00:03 -05:00
John Colvin 8da2ebee5c SelectionModel should only select the pending selection once (was reselecting it every time the items changed) 2020-08-12 12:59:19 -05:00
Pedro Pinto a1faf685eb CMake, you suck. 2020-08-11 15:59:40 -04:00
Pedro Pinto 9e2b01a723 Cleaned up branch for delivery to DJ 2020-08-11 13:54:27 -04:00
John Colvin d03c74f270 remove unused 'actual_width' prop from DIYGridColumnModel 2020-08-05 15:11:06 -05:00
John Colvin 834a28916b synchronize column model's GridColumnSettings with the column view 2020-08-05 15:10:23 -05:00
John Colvin 43ccb4e3e7 fix risk management thread name typo 2020-08-05 12:20:24 -05:00
Taha Afzal f199cb4157 Fixed the broken test (needed to update the size attribute on the managed ColdEntry 2020-08-05 10:54:43 -04:00
Taha Afzal 5a3bfd7f81 Merge branch 'DJ_ICE_proprietary_risk' of bitbucket.org:bluetradesys/spark into DJ_ICE_proprietary_risk 2020-08-04 15:40:29 -04:00
Taha Afzal bf6461c126 More logs and TAS HNG can not be the master 2020-08-04 15:40:21 -04:00
John Colvin 8892505d11 RiskManagement price cells show 4 decimal places, use commas 2020-08-04 12:11:55 -05:00
John Colvin 5d0a29432a RiskManagementVM - row sorting must refer to immutable data (else binary search can break) 2020-08-04 12:11:55 -05:00
John Colvin cd01c7ae5a RiskManagementVM - remove unused props/methods 2020-08-04 12:11:55 -05:00
Taha Afzal bf19ec0fda Merge branch 'DJ_ICE_proprietary_risk' of bitbucket.org:bluetradesys/spark into DJ_ICE_proprietary_risk 2020-08-04 13:08:14 -04:00
John Colvin 1a0158817e remove size constraints on RiskManagementControl 2020-08-04 11:28:23 -05:00
John Colvin 53853591fe move RiskManagementControl.xaml/cs to 'View' dir 2020-08-04 11:28:23 -05:00
Taha Afzal 80d4899f2c removing fake data functions (when the UI was not around) 2020-08-04 09:51:32 -04:00
Taha Afzal 75f15c50d8 working long/short pos was not getting copied in copy_positions_from 2020-08-03 18:25:40 -04:00
John Colvin f197f213f3 Risk Management ui - open edit-rows dialog near mouse 2020-08-03 15:52:26 -05:00
John Colvin a7e1b71883 TextCell available_size is updated in ArrangeOverride 2020-08-03 15:28:41 -05:00
John Colvin f9f22e1e36 add risk management window 2020-08-03 15:28:41 -05:00
John Colvin cda50f562d AdminModel - add methods to subscribe, and modify proprietary risk limits (dj) 2020-08-03 15:28:41 -05:00
John Colvin 4010298a46 parameterize SecurityStore.join (don't mess with core logic/impl) 2020-08-03 15:28:41 -05:00
John Colvin 48e701ba00 client side data types that mirror api protos (minimize client/server coupling) 2020-08-03 15:28:41 -05:00
John Colvin cb07abbf42 made new SelectorVM (todo: replace refs to old one) 2020-08-03 15:28:41 -05:00
John Colvin 3c8e2c636f add SimpleGridSettingsManagerVM (uses DIYGridColumnModels instead of the view type ColumnBase) 2020-08-03 15:28:41 -05:00
John Colvin 6a3b4ebe75 add DIYGridColumnModel, so the DIYGrid column paradigm is cleanear mvvm 2020-08-03 15:28:41 -05:00
John Colvin 80256fbe12 add get/load_state methods to non-generic IDataGridColumnFilter 2020-08-03 15:28:41 -05:00
John Colvin a0a5d82139 add PropertyEqualityComparerAttribute (supports simple automatic equality impl) 2020-08-03 15:28:41 -05:00
John Colvin ee6b00b9f2 unify SecurityCriteria initialization with securities (use pretty_name if single sec) 2020-08-03 15:28:41 -05:00
Taha Afzal 9a494ce24f Parent Child Secrity Pos Limit 2020-08-03 16:25:24 -04:00
Taha Afzal ae78ebac9a All sec based risk done (master, slave remain) 2020-07-31 17:27:06 -04:00
Taha Afzal 5c11eecbd1 SecurityLimitNode keeps working qty and positions differently 2020-07-31 00:21:17 -04:00
Taha Afzal 78a47c33c7 Fixing order rejection message 2020-07-30 14:55:11 -04:00
Taha Afzal 9dcd80e3db Security level risk controls are passed to update order 2020-07-30 13:02:22 -04:00
Taha Afzal f7563413bd New security level controls hooked to order entry 2020-07-30 11:14:45 -04:00
Taha Afzal 29c418db42 Routed the SecLimit to SecurityLimitNode 2020-07-29 18:15:18 -04:00
Taha Afzal f177efde70 Added price arg to the Limiter's can_send and can_update functions 2020-07-29 14:28:16 -04:00
Taha Afzal 3b83d105a0 Filled in the prop risk limits persistence code 2020-07-29 12:29:56 -04:00
Taha Afzal 34aafd79cd Added new risk proto and Admin API function to update it 2020-07-29 11:30:36 -04:00
Taha Afzal d3de164c53 Moved the 2500 translation to the end points of the system 2020-07-27 17:05:19 -04:00
Taha Afzal 1d1c0d6b85 Jan exps' are showing 12 for the month, adjustment for risk 2020-07-21 12:09:41 -04:00
Taha Afzal 2f127ecc18 Using day positions for risk enforcement 2020-07-20 23:48:35 -04:00
Taha Afzal 3fc080d02c Better position violation comments 2020-07-20 23:21:20 -04:00
Taha Afzal d86543261c Risk enforcement changes for ICE NG OTC markets 2020-07-20 13:01:56 -04:00
Taha Afzal 1a7fcb2027 Added is_ice_lots to the ICE sec proto 2020-07-12 17:03:37 -04:00
Taha Afzal ca6673e98f Merge branch 'prod' 2020-07-09 13:09:57 -04:00
Taha Afzal 479f3dccff Adding OnSignal (this is a new algo which is hidden by default) 2020-07-09 13:07:28 -04:00
Taha Afzal c272d8a8c2 Pyramid Algo: Takes care of the rounding error when Top == sum (child orders) 2020-07-08 13:35:21 -04:00
John Colvin fbd8bbd4a8 algo abbreviation code uses string.Join instead of list_string (the latter method is redundant, should be removed) 2020-07-07 13:16:18 -05:00
John Colvin 3da52b350f fix pure crash (algo abbreviation code choked on names that end with a space) 2020-07-07 13:15:55 -05:00
John Colvin 40bad84c48 algo studio includes algos with undefined children in the dropdown 2020-07-01 12:09:12 -05:00
Eric Harding 7f9967834d add readme note 2020-06-30 15:34:03 -04:00
Eric Harding fbaa17bc40 Add some comments to marketdata.proto 2020-06-30 13:16:30 -04:00
Eric Harding 38e3cd6197 Update market data readme 2020-06-30 13:13:48 -04:00
Eric Harding 10386311d4 Update market data readme 2020-06-29 12:25:30 -04:00
Eric Harding 629a7f8130 Remove unused class in MD 2020-06-29 12:25:14 -04:00
John Colvin e3207b921a truncate list of securities in transitive compare test (was timing out due to too many permutations) 2020-06-26 13:32:27 -05:00
Taha Afzal 98db8e61a5 Removing hardcoded ref's to Katallage 2020-06-25 17:05:10 -04:00
Taha Afzal e009316bfb Merge branch 'DJ_ICE' of bitbucket.org:bluetradesys/spark into DJ_ICE 2020-06-24 17:13:38 -04:00
Taha Afzal 5528efd2d2 Cleaning up 2020-06-24 17:13:31 -04:00
John Colvin 09f91735fe Security sort tests run with ice securities 2020-06-24 12:58:29 -05:00
John Colvin d9fc18547b SecurityHelper.Compare fallsback on 'ToString' then 'Id' comparisons to guarentee deterministic sort 2020-06-24 12:56:29 -05:00
Taha Afzal 5905ca3e92 Merging frmo master 2020-06-23 13:51:14 -04:00
John Colvin 32b7b7f40d quantity conversion for ladder right click order 2020-06-22 17:02:23 -05:00
Pedro Pinto 54e5a68730 Tweaked build tools. 2020-06-22 08:41:19 -04:00
John Colvin e7da6dd79e remove unused 'save/remove_template_cmd' props from OrderPropertiesEditor 2020-06-19 16:42:38 -05:00
John Colvin 8bf78aa880 cleanup/normalize whitespace in OrderDataHelper.cs 2020-06-19 16:37:21 -05:00
John Colvin 1c44165181 remove unused methods/props in OrderDataHelper.cs 2020-06-19 16:35:15 -05:00
John Colvin 8165ec0e3d fix AlgoProvider.get_permitted_algos (seed intersection aggregate a full set instead of empty) 2020-06-19 16:14:58 -05:00
John Colvin 7d1ec5b82a Merge remote-tracking branch 'refs/remotes/origin/DJ_ICE' into DJ_ICE 2020-06-19 15:48:55 -05:00
John Colvin 02e7fb1ee0 iceberg 'show quantity' param uses display divisor 2020-06-19 15:45:17 -05:00
John Colvin c0ea6943e1 AlgoProvider ensures synthetic security algo's last child is a Spreader algo 2020-06-19 15:12:42 -05:00
John Colvin 4c914a2d48 Merge branch 'DJ_ICE_algo_config' into DJ_ICE 2020-06-19 10:59:10 -05:00
Taha Afzal 0ee86f2dd4 CPP override fix 2020-06-19 11:58:58 -04:00
Taha Afzal 00bf3c7f47 Fixing the PNL timestamp 2020-06-19 11:10:23 -04:00
John Colvin 60d4dd87fd rename ISecurityAlgoProvider.cs -> IAlgoProvider.cs 2020-06-15 17:01:02 -05:00
John Colvin 3a7eeda70e AlgoProvider.subscribe_algos always fires at least once (doesn't depend on studio algos being present) 2020-06-15 17:00:13 -05:00
John Colvin 712146e028 Merge branch 'algo-type-config' into DJ_ICE_algo_config 2020-06-15 16:57:07 -05:00
Pedro Pinto 59774ccbb5 Updated docker 2020-06-14 15:27:18 -04:00
Pedro Pinto fcb6c9b8d9 Added a few build tools. 2020-06-14 15:27:01 -04:00
John Colvin 17b314ea3a Merge branch 'master' into algo-type-config 2020-02-07 13:35:50 -06:00
John Colvin e713210030 remove obsolete algo types from hardcoded defaults 2019-10-29 18:07:32 -05:00
John Colvin c057bf18f6 Merge remote-tracking branch 'origin/master' into algo-type-config 2019-10-29 18:07:01 -05:00
John Colvin 17a0bef824 Merge remote-tracking branch 'origin/master' into algo-type-config 2019-10-21 12:15:00 -05:00
John Colvin 9180c48b67 CompositeAlgoVM 'group' is AlgoDisplayGroup.Studio 2019-10-14 15:29:02 -05:00
John Colvin 01acbe08f5 remove dead code 2019-10-14 15:26:01 -05:00
John Colvin 8a47cd4821 exchange/security based algo type config 2019-10-14 15:19:36 -05:00
John Colvin 03050d9b07 refactor some Disposable.replace calls so that the prev hook is disposed before the new one is created 2019-10-14 13:25:21 -05:00
John Colvin 9178878880 AlgoStudio model does not really need to import AdminModel (just UserTuple) 2019-10-14 13:25:21 -05:00
John Colvin f38b1c7af9 ContractPickerModel.result getter performs dictionary lookup (was brute force enumeration) 2019-10-14 13:25:21 -05:00
John Colvin 45cd958b1e make security criteria clause immutable 2019-10-14 13:25:21 -05:00
John Colvin 4d49c8f030 add .rej to gitignore 2019-10-14 13:25:21 -05:00
John Colvin b2227ce37b DynamicOrderHelper stores dyn types in map 2019-10-14 13:25:21 -05:00
223 changed files with 8206 additions and 6468 deletions

No files matched your search

+1
View File
@@ -34,5 +34,6 @@ trace_data/
/doc/user/public/*
.ionide/*
/.ignore
*.rej
/build
.clangd/
+7
View File
@@ -1,6 +1,8 @@
cmake_minimum_required(VERSION 3.5)
project(spark)
set (USE_ONIX "TRUE")
if (WIN32)
set (platform "windows")
else ()
@@ -40,6 +42,11 @@ else ()
-fPIC -Wall -pedantic -Wextra -Werror \
-Wno-missing-braces -Wno-ignored-qualifiers \
--std=c++17 -fdiagnostics-color")
if (${USE_ONIX})
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DUSE_ONIX")
endif()
set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer -DNDEBUG -O3")
set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wno-undef")
add_subdirectory(src/server/sparkd)
+10
View File
@@ -0,0 +1,10 @@
using System.Windows;
[assembly: ThemeInfo(
ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
//(used if a resource is not found in the page,
// or application resource dictionaries)
ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
//(used if a resource is not found in the page,
// app, or any theme specific resource dictionaries)
)]
+51
View File
@@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
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 RiskUI {
/// <summary>
/// Follow steps 1a or 1b and then 2 to use this custom control in a XAML file.
///
/// Step 1a) Using this custom control in a XAML file that exists in the current project.
/// Add this XmlNamespace attribute to the root element of the markup file where it is
/// to be used:
///
/// xmlns:MyNamespace="clr-namespace:RiskUI"
///
///
/// Step 1b) Using this custom control in a XAML file that exists in a different project.
/// Add this XmlNamespace attribute to the root element of the markup file where it is
/// to be used:
///
/// xmlns:MyNamespace="clr-namespace:RiskUI;assembly=RiskUI"
///
/// You will also need to add a project reference from the project where the XAML file lives
/// to this project and Rebuild to avoid compilation errors:
///
/// Right click on the target project in the Solution Explorer and
/// "Add Reference"->"Projects"->[Select this project]
///
///
/// Step 2)
/// Go ahead and use your control in the XAML file.
///
/// <MyNamespace:CustomControl1/>
///
/// </summary>
public class CustomControl1 : Control {
static CustomControl1() {
DefaultStyleKeyProperty.OverrideMetadata(typeof(CustomControl1), new FrameworkPropertyMetadata(typeof(CustomControl1)));
}
}
}
+24
View File
@@ -0,0 +1,24 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net471</TargetFramework>
<RootNamespace>bts</RootNamespace>
<LangVersion>7.2</LangVersion>
<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
<WarningsAsErrors />
<Version>$(major).$(minor).$(patch)</Version>
<Version Condition="'$(version)'=='..'">1.0.0</Version>
</PropertyGroup>
<ItemGroup>
<Reference Include="PresentationCore" />
<Reference Include="PresentationFramework" />
<Reference Include="System.Xaml" />
<Reference Include="WindowsBase" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="../spark_api/spark_api.csproj" />
<ProjectReference Include="../Spark/Spark.csproj" />
</ItemGroup>
</Project>
+17
View File
@@ -0,0 +1,17 @@
<ResourceDictionary
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:RiskUI">
<Style TargetType="{x:Type local:CustomControl1}">
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="{x:Type local:CustomControl1}">
<Border Background="{TemplateBinding Background}"
BorderBrush="{TemplateBinding BorderBrush}"
BorderThickness="{TemplateBinding BorderThickness}">
</Border>
</ControlTemplate>
</Setter.Value>
</Setter>
</Style>
</ResourceDictionary>
+122 -2
View File
@@ -1,24 +1,33 @@
using bts;
using bts.admin.risk;
using bts.api;
using bts.api.admin;
using bts.api.core;
using bts.spark;
using bts.utils;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.ComponentModel.Composition;
using System.Linq;
using System.Reactive.Linq;
using System.Threading.Tasks;
namespace mbts.spark {
[Export]
class AdminModel : IDisposable {
public readonly UserTuple user;
readonly AdminService _service;
readonly ErrorReporter _error_reporter;
IDisposable _dispose;
IReadOnlyDictionary<uint, string> _account_map = DictionaryHelper.empty<uint, string>();
[ImportingConstructor]
AdminModel(AdminService service, UserTuple user) {
AdminModel(AdminService service, UserTuple user, SecurityStore security_store, ErrorReporter error_reporter) {
this.user = user;
_service = service;
_error_reporter = error_reporter;
// accounts
on_accounts = service.subscribei_admin_data()
.Select(up => up.all.TryGetFirst(out var ad) && ad.Users.Where(u => u.Name == user.name).TryGetSingle(out var usr) && usr.HasUserData && usr.UserData.HasAccountPermissions ?
@@ -31,6 +40,34 @@ namespace mbts.spark {
new Dictionary<uint, string>(0))
.Replay(1)
.RefCount();
// account risk limits
account_security_risk_limits = service.subscribei_admin_data().Where(ad => ad.all.Any())
.Select(upd => {
AdminDataImmutable admin_data = upd.all.First();
return admin_data.Accounts.SelectMany(acc =>
(acc.HasProprietaryRiskLimits ? acc.ProprietaryRiskLimits.SecurityLimits : Enumerable.Empty<SecurityRiskLimitUnitImmutable>())
.Select(api_limit => AccountSecurityRiskLimitsDataHelper.to_client_data(acc.Id, api_limit)))
.ToDictionary(AccountSecurityRiskLimitsDataHelper.key_fn);
})
.Table(AccountSecurityRiskLimitsDataHelper.key_fn);
// this isn't the most efficient join, but the SecurityStore join is more complex than a simple
// left join operation, because missing securities are retrieved asynchronously, then merged back into the output sequence.
// Until it is known that this inefficiency is problematic, best to leave the battle-tested SecurityStore code alone.
account_security_risk_limits = security_store.join<
TableUpdate<AccountSecurityRiskLimits, AccountSecurityKey>,
AccountSecurityRiskLimits,
AccountSecurityKey,
TableUpdate<AccountSecurityRiskLimits, AccountSecurityKey>>(account_security_risk_limits,
cli_lim => cli_lim.security_key,
table => (table.state.Values, table.added, table.changes, table.removed, AccountSecurityRiskLimitsDataHelper.key_fn),
(all, added, changes, removed, key_fn) =>
new TableUpdate<AccountSecurityRiskLimits, AccountSecurityKey>(
ImmutableDictionary.CreateRange<AccountSecurityKey, AccountSecurityRiskLimits>(
all.Select(tup => new KeyValuePair<AccountSecurityKey, AccountSecurityRiskLimits>(tup.val.key, risk_lim_with_sec(tup)))),
added.Select(risk_lim_with_sec),
changes.Select(ch => new Change<AccountSecurityRiskLimits>(risk_lim_with_sec(ch.Old), risk_lim_with_sec(ch.New))),
removed.Select(risk_lim_with_sec),
AccountSecurityRiskLimitsDataHelper.key_fn));
// users
on_users = Observable.Return(DictionaryHelper.wrap_value(user.id, user.name));
all_user_tuples = user.permissions == UserTuple.Permissions.Admin ?
@@ -45,12 +82,16 @@ namespace mbts.spark {
.Cache() :
Observable.Return(TableUpdate<UserTuple, uint>.mk_empty(UserTuple.key_fn).with_added(new[] { user }));
_dispose = on_accounts.Subscribe(map => _account_map = map);
// local methods
AccountSecurityRiskLimits risk_lim_with_sec((SecurityImmutable? sec, AccountSecurityRiskLimits val) tup) =>
tup.val.with(security: tup.sec);
}
public IObservable<IReadOnlyDictionary<uint, string>> on_users { get; }
public IObservable<IReadOnlyDictionary<uint, string>> on_accounts { get; }
public IObservable<TableUpdate<UserTuple, uint>> all_user_tuples { get; }
public IObservable<IReadOnlyList<AccountTuple>> on_account_tuples => on_accounts.Select(d => d.Select(kv => new AccountTuple(kv.Key, kv.Value)).ToListSorted(a => a.name));
public IObservable<TableUpdate<AccountSecurityRiskLimits, AccountSecurityKey>> account_security_risk_limits { get; }
public IObservable<Update<T, TKey>> permission_filter<T, TKey>(IObservable<Update<T, TKey>> positions, Func<T, uint> get_account_id) where TKey : IEquatable<TKey> =>
user.permissions == UserTuple.Permissions.Admin ?
@@ -68,7 +109,86 @@ namespace mbts.spark {
public AccountTuple? get_default_account() =>
_account_map.Select(kv => new AccountTuple(kv.Key, kv.Value)).TryFirst();
public async Task<Result<AdminServiceOperationResult>[]> set_risk_limits(IReadOnlyDictionary<uint, IEnumerable<(uint, RiskLimits)>> state) {
var results = await Task.WhenAll(state.Select(impl));
return results;
async Task<Result<AdminServiceOperationResult>> impl(KeyValuePair<uint, IEnumerable<(uint, RiskLimits)>> kv) {
var prlimits = new ProprietaryRiskLimits();
foreach (var (sec, lim) in kv.Value) {
var api_lim = AccountSecurityRiskLimitsDataHelper.from_client_data(sec, lim);
prlimits.SecurityLimits.Add(api_lim);
}
return await _service.update_proprietary_risk_limits_async(new ProprietaryRiskLimitsAPIArgument {
AccountId = kv.Key,
ProprietaryRiskLimits = prlimits
});
}
}
public Task<(bool success, string error_msg)> add_or_update_risk_limits(uint account_key, IEnumerable<(uint security_key, RiskLimits limits)> new_limits) {
return _modify_risk_limits("Updating Risk Limits", account_key, add_limits);
//
ProprietaryRiskLimits add_limits(ProprietaryRiskLimits prlimits) {
foreach (var (security_key, limits) in new_limits) {
var api_limits = AccountSecurityRiskLimitsDataHelper.from_client_data(security_key, limits);
if (prlimits.SecurityLimits.TryGetFirstIndex(l => l.SecurityKey == security_key, out int index)) {
prlimits.SecurityLimits[index] = api_limits;
} else {
prlimits.SecurityLimits.Add(api_limits);
}
}
return prlimits;
}
}
public Task<(bool success, string error_msg)> delete_risk_limits(uint account_key, IEnumerable<uint> security_keys) {
return _modify_risk_limits("Deleting Risk Limits", account_key, remove_secs);
//
ProprietaryRiskLimits remove_secs(ProprietaryRiskLimits prlimits) {
var sec_key_set = new HashSet<uint>(security_keys);
for (int i = 0; i < prlimits.SecurityLimits.Count;) {
if (sec_key_set.Contains(prlimits.SecurityLimits[i].SecurityKey)) {
prlimits.SecurityLimits.RemoveAt(i);
} else i++;
}
return prlimits;
}
}
public void Dispose() =>
Disposable.dispose(ref _dispose);
async Task<(bool success, string error_msg)> _modify_risk_limits(string op_desc, uint account_key, Func<ProprietaryRiskLimits, ProprietaryRiskLimits> modify) {
var api_limits = new ProprietaryRiskLimits();
var snapshot = await _get_current_admin_data_async();
if (!snapshot.HasValue)
return (false, "Timed out waiting for data from server.");
var mutable_snap = snapshot.Value.CloneToMutable();
if (!snapshot.Value.Accounts.TryGetFirst(acc => acc.Id == account_key, out var target_acci)) {
return (false, $"Account id '{account_key}' not found.");
}
var prlimits = target_acci.HasProprietaryRiskLimits ? target_acci.ProprietaryRiskLimits.CloneToMutable() : new ProprietaryRiskLimits();
prlimits = modify(prlimits);
if (prlimits is null) {
return (false, "Client-side modification function returned null.");
}
var req = new ProprietaryRiskLimitsAPIArgument {
AccountId = account_key,
ProprietaryRiskLimits = prlimits
};
var reply = await _error_reporter.safe_execute<AdminServiceOperationResult>(
() => _service.update_proprietary_risk_limits_async(req),
r => r.IsSuccess,
r => r.ErrorText,
op_desc);
return (reply.success, reply.value.ErrorText);
}
async Task<AdminDataImmutable?> _get_current_admin_data_async() =>
await _service.subscribei_admin_data()
.Where(upd => upd.all.Any())
.Select(upd => (AdminDataImmutable?)upd.all.First())
.FirstOrDefaultAsync(TimeSpan.FromSeconds(5));
//async Task<AdminDataImmutable?>
}
}
}
+183
View File
@@ -0,0 +1,183 @@
using bts.api;
using bts.api.admin;
using bts.utils;
using System;
namespace bts.admin.risk {
readonly struct AccountSecurityKey : IEquatable<AccountSecurityKey> {
public AccountSecurityKey(uint account, uint security) {
this.account = account;
this.security = security;
}
public uint account { get; }
public uint security { get; }
public bool Equals(AccountSecurityKey other) =>
security == other.security &&
account == other.account;
public override bool Equals(object obj) =>
obj is AccountSecurityKey other && Equals(other);
public override int GetHashCode() =>
EqualityComparer.auto_phase(security.GetHashCode(), account.GetHashCode());
public static bool operator ==(AccountSecurityKey a, AccountSecurityKey b) => a.Equals(b);
public static bool operator !=(AccountSecurityKey a, AccountSecurityKey b) => !a.Equals(b);
}
readonly struct AccountSecurityRiskLimits : IEquatable<AccountSecurityRiskLimits> {
readonly AccountTuple? _account;
public AccountSecurityRiskLimits(AccountSecurityKey key, RiskLimits limits, SecurityImmutable? security = null, AccountTuple? account = null) {
this.key = key;
this.limits = limits;
this.security = security;
_account = account;
}
public AccountSecurityKey key { get; }
public uint account_key => key.account;
public uint security_key => key.security;
public string account_name => _account?.name;
public SecurityImmutable? security { get; }
public RiskLimits limits { get; }
public bool Equals(AccountSecurityRiskLimits other) =>
key.Equals(other.key) &&
limits.Equals(other.limits);
public override bool Equals(object obj) =>
obj is AccountSecurityRiskLimits other && Equals(other);
public override int GetHashCode() =>
EqualityComparer.auto_phase(key.GetHashCode(), limits.GetHashCode());
}
readonly struct RiskLimits : IEquatable<RiskLimits> {
public RiskLimits(
bool is_position_limit_enabled,
uint max_long_position,
uint max_short_position,
bool is_clip_limit_enabled,
uint clip_limit,
bool is_price_limit_enabled,
double min_price,
double max_price) {
//
this.is_position_limit_enabled = is_position_limit_enabled;
this.max_long_position = max_long_position;
this.max_short_position = max_short_position;
this.is_clip_limit_enabled = is_clip_limit_enabled;
this.clip_limit = clip_limit;
this.is_price_limit_enabled = is_price_limit_enabled;
this.min_price = min_price;
this.max_price = max_price;
}
// position
public bool is_position_limit_enabled { get; }
public uint max_long_position { get; }
public uint max_short_position { get; }
// clip
public bool is_clip_limit_enabled { get; }
public uint clip_limit { get; }
// price
public bool is_price_limit_enabled { get; }
public double min_price { get; }
public double max_price { get; }
public bool Equals(RiskLimits other) =>
is_position_limit_enabled == other.is_position_limit_enabled &&
max_long_position == other.max_long_position &&
max_short_position == other.max_short_position &&
is_clip_limit_enabled == other.is_clip_limit_enabled &&
clip_limit == other.clip_limit &&
is_price_limit_enabled == other.is_price_limit_enabled &&
min_price == other.min_price &&
max_price == other.max_price;
public override bool Equals(object obj) =>
obj is RiskLimits other && Equals(other);
public override int GetHashCode() {
const int non_bin_bits = 28;
// Evenly split the non-binary props across the first 28 bits.
// The last 3 bits are used to represent each of the 'is_enabled' (binary) props.
var hash = EqualityComparer.auto_phase(new[] {
max_long_position.GetHashCode(),
max_short_position.GetHashCode(),
clip_limit.GetHashCode(),
min_price.GetHashCode(),
max_price.GetHashCode()
}, non_bin_bits);
if (is_position_limit_enabled)
hash |= 1 << (non_bin_bits + 1);
if (is_clip_limit_enabled)
hash |= 1 << (non_bin_bits + 2);
if (is_price_limit_enabled)
hash |= 1 << (non_bin_bits + 3);
return hash;
}
}
static class AccountSecurityRiskLimitsDataHelper {
public static readonly Func<AccountSecurityRiskLimits, AccountSecurityKey> key_fn =
a => a.key;
// Don't make this a constructor. Subscribers to this data are discouraged
// from using the server side data (client/server coupling should be minimal).
public static AccountSecurityRiskLimits to_client_data(uint account_key, SecurityRiskLimitUnitImmutable api_data) =>
new AccountSecurityRiskLimits(
new AccountSecurityKey(account_key, api_data.SecurityKey),
new RiskLimits(
api_data.EnforceNetPosLimits,
api_data.NetLongPositionLimit,
api_data.NetShortPositionLimit,
api_data.EnforceClipLimits,
api_data.ClipSize,
api_data.EnforcePriceBands,
api_data.MinSellPrice,
api_data.MaxBuyPrice));
public static AccountSecurityRiskLimits with(this AccountSecurityRiskLimits cli_data, RiskLimits? limits = null, AccountTuple? account = null, SecurityImmutable? security = null, AccountSecurityKey? key = null) =>
new AccountSecurityRiskLimits(
key ?? cli_data.key,
limits ?? cli_data.limits,
account: account ?? new AccountTuple(cli_data.account_key, cli_data.account_name),
security: security ?? cli_data.security);
public static RiskLimits with(this RiskLimits limits,
bool? is_position_limit_enabled = null,
uint? max_long_position = null,
uint? max_short_position = null,
bool? is_clip_limit_enabled = null,
uint? clip_limit = null,
bool? is_price_limit_enabled = null,
double? min_price = null,
double? max_price = null) =>
new RiskLimits(
is_position_limit_enabled ?? limits.is_position_limit_enabled,
max_long_position ?? limits.max_long_position,
max_short_position ?? limits.max_short_position,
is_clip_limit_enabled ?? limits.is_clip_limit_enabled,
clip_limit ?? limits.clip_limit,
is_price_limit_enabled ?? limits.is_price_limit_enabled,
min_price ?? limits.min_price,
max_price ?? limits.max_price);
public static SecurityRiskLimitUnit from_client_data(uint security_key, RiskLimits limits) =>
new SecurityRiskLimitUnit {
SecurityKey = security_key,
NetLongPositionLimit = limits.max_long_position,
NetShortPositionLimit = limits.max_short_position,
MaxBuyPrice = limits.max_price,
MinSellPrice = limits.min_price,
ClipSize = limits.clip_limit,
EnforceNetPosLimits = limits.is_position_limit_enabled,
EnforceClipLimits = limits.is_clip_limit_enabled,
EnforcePriceBands = limits.is_price_limit_enabled
};
}
}
@@ -0,0 +1,193 @@
using bts;
using bts.api;
using bts.api.core;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.ComponentModel.Composition;
using System.Linq;
using System.Reactive.Linq;
using System.Text.RegularExpressions;
using AlgoType = bts.api.orderman.CustomOrderDefinition.CustomOneofCase;
namespace mbts.spark {
class AlgoProviderFactory {
[ImportingConstructor]
AlgoProviderFactory(IAlgoStudioModel studio_model, DynamicOrderHelper dynamic_helper, ISecurityAuxiliaryDataModel security_auxiliary_model) {
var from_conf = config.Configuration.get<bts.config.AlgoTypeRuleSet>();
if (from_conf.rules.Count == 0) {
// There seems to be a config race bug, where the returned config values are empty, despite having entries in spark.conf.
// [John]I've only noticed it happen when attached to the debugger,
// but best to have a contingency plan in place anyways, to prevent any chance of regression.
// The fallback sets below mimic the old hardcoded algo type arrays.
var full_algo_set = new AlgoTypeSetImmutable(
ImmutableHashSet.CreateRange(EnumHelper.get_values_except(
// non-factory algos
AlgoType.None,
AlgoType.Dynamic,
AlgoType.Composite,
// obsolete algos
AlgoType.Oco,
AlgoType.TimeBox,
AlgoType.Pricer,
AlgoType.Tick,
AlgoType.Trigger,
AlgoType.QueueHolder)),
ImmutableHashSet.CreateRange(dynamic_helper.dynamic_types));
var rules = new[] {
// Glbx: Futures/Spreads
new SecurityAlgoTypeSetImmutable(
new SecurityCriteriaClause(
exchanges: new[] { Venue.Glbx },
security_types: new[] { SecurityType.Future, SecurityType.Spread }),
new AlgoTypeSetImmutable(
full_algo_set.factory_types.Except(new[] { AlgoType.Spreader }),
full_algo_set.dynamic_types)),
// Gen: Futures/Spreads
new SecurityAlgoTypeSetImmutable(
new SecurityCriteriaClause(
exchanges: EnumHelper.get_values_except(Venue.Glbx, Venue.Unset).ToArray(),
security_types: new[] { SecurityType.Future, SecurityType.Spread }),
new AlgoTypeSetImmutable(
full_algo_set.factory_types.Except(new[] { AlgoType.Spreader, AlgoType.GlbxIceberg }),
full_algo_set.dynamic_types)),
// Gen: Synthetics
new SecurityAlgoTypeSetImmutable(
new SecurityCriteriaClause(
security_types: new[] { SecurityType.Synthetic }),
new AlgoTypeSetImmutable(
ImmutableHashSet.CreateRange(new[] {
AlgoType.Spreader,
AlgoType.Iceberg,
AlgoType.Lean,
AlgoType.Join,
AlgoType.Cover,
AlgoType.Offset,
AlgoType.Top,
AlgoType.Splitter,
AlgoType.Scratch,
AlgoType.Prorata
}),
full_algo_set.dynamic_types))
};
// attachable
var attachable_algos =
ImmutableHashSet.CreateRange(new[] {
AlgoType.Iceberg,
AlgoType.Lean,
AlgoType.Join,
AlgoType.Cover,
AlgoType.Top,
AlgoType.Offset,
AlgoType.Scratch,
AlgoType.Prorata
});
var attachable_rules = Array.ConvertAll(rules,
satsi => new SecurityAlgoTypeSetImmutable(
satsi.security_criteria,
new AlgoTypeSetImmutable(
satsi.algo_type_set.factory_types.Intersect(attachable_algos),
satsi.algo_type_set.dynamic_types)));
Log.Config.warn($"Failed to load AlgoTypes config, falling back to the following algo set rules:" +
"\n\tStandard\n" +
rules.fmt_diagnostic("\n\t\t") +
"\n\n\tAttachable\n" +
attachable_rules.fmt_diagnostic("\n\t\t"));
security_algo_provider = new AlgoProvider(rules, studio_model, dynamic_helper, security_auxiliary_model);
attachable_algo_provider = new AttachableAlgoProvider(attachable_rules, studio_model, dynamic_helper, security_auxiliary_model);
} else {
var algo_type_data =
EnumHelper.get_values_except(AlgoType.Dynamic, AlgoType.Composite, AlgoType.None)
.Select(t => _get_type_data(t))
.Concat(dynamic_helper.dynamic_types.Select(dt => _get_type_data(AlgoType.Dynamic, dt)))
.ToListLazy();
var conf_sets = from_conf.rules.Select(r => _to_security_algo_set(r, dynamic_helper, algo_type_data)).ToList();
security_algo_provider = new AlgoProvider(conf_sets.Select(tup => tup.standard).ToList(), studio_model, dynamic_helper, security_auxiliary_model);
attachable_algo_provider = new AttachableAlgoProvider(conf_sets.Select(tup => tup.attachable).ToList(), studio_model, dynamic_helper, security_auxiliary_model);
}
}
[Export]
public IAlgoProvider security_algo_provider { get; }
[Export]
public IAttachableAlgoProvider attachable_algo_provider { get; }
static (string name, AlgoType factory, string dynamic) _get_type_data(AlgoType type, string dynamic_type = null) {
string type_name = type.ToString();
return (type_name, type, dynamic_type ?? type_name);
}
static SecurityCriteriaClause _to_clause(bts.config.AlgoTypeContext context) =>
context == null ?
new SecurityCriteriaClause() :
new SecurityCriteriaClause(
exchanges: context.exchanges?.Select(EnumHelper.parse<Venue>)?.ToArray(),
security_types: context.security_types?.Select(EnumHelper.parse<Security.ContractOneofCase>)?.Select(t => t.security_type())?.ToArray(),
symbols: context.symbols?.ToArray());
static (SecurityAlgoTypeSetImmutable standard, SecurityAlgoTypeSetImmutable attachable) _to_security_algo_set(
bts.config.AlgoTypeRule rule,
DynamicOrderHelper dynamic_helper,
IEnumerable<(string name, AlgoType factory, string dynamic)> algo_type_data) {
//
var factory_types = ImmutableHashSet<AlgoType>.Empty.ToBuilder();
var dynamic_types = ImmutableHashSet<string>.Empty.ToBuilder();
var attachable_factory_types = ImmutableHashSet<AlgoType>.Empty.ToBuilder();
var attachable_dynamic_types = ImmutableHashSet<string>.Empty.ToBuilder();
foreach (var a in rule.algos) {
if (Enum.TryParse(a.name, out AlgoType sys_algo) && sys_algo != AlgoType.Composite && sys_algo != AlgoType.Dynamic) {
on_sys_match(sys_algo, a.is_attachable);
}
else if (dynamic_helper.try_parse(a.name, out var dyn_type)) {
on_dyn_match(dyn_type, a.is_attachable);
} else {
foreach (var (name, factory, dynamic) in algo_type_data) {
if (Regex.Match(name, a.name).Success) {
switch (factory) {
case AlgoType.None:
case AlgoType.Composite:
// unexpected, but no need to crash
continue;
case AlgoType.Dynamic:
on_dyn_match(dynamic, a.is_attachable);
break;
default:
on_sys_match(factory, a.is_attachable);
break;
}
}
}
}
}
return (
// standard
new SecurityAlgoTypeSetImmutable(
_to_clause(rule.context),
new AlgoTypeSetImmutable(
factory_types.ToImmutable(),
dynamic_types.ToImmutable())),
// attachable
new SecurityAlgoTypeSetImmutable(
_to_clause(rule.context),
new AlgoTypeSetImmutable(
attachable_factory_types.ToImmutable(),
attachable_dynamic_types.ToImmutable())));
// local methods
void on_sys_match(AlgoType sys_algo, bool is_attachable) {
factory_types.Add(sys_algo);
if (is_attachable)
attachable_factory_types.Add(sys_algo);
}
void on_dyn_match(string dyn_algo, bool is_attachable) {
dynamic_types.Add(dyn_algo);
if (is_attachable)
attachable_dynamic_types.Add(dyn_algo);
}
}
}
}
@@ -0,0 +1,132 @@
using bts.api.core;
using bts.api.orderman;
using mbts.spark.utilities;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Reactive.Linq;
using System.Text;
using AlgoType = bts.api.orderman.CustomOrderDefinition.CustomOneofCase;
namespace mbts.spark {
readonly struct AlgoTypeSetImmutable {
public static readonly AlgoTypeSetImmutable empty = new AlgoTypeSetImmutable(ImmutableHashSet<AlgoType>.Empty, ImmutableHashSet<string>.Empty);
public readonly ImmutableHashSet<AlgoType> factory_types;
public readonly ImmutableHashSet<string> dynamic_types;
public AlgoTypeSetImmutable(
ImmutableHashSet<AlgoType> factory_types,
ImmutableHashSet<string> dynamic_types) {
this.factory_types = factory_types;
this.dynamic_types = dynamic_types;
}
}
readonly struct SecurityAlgoTypeSetImmutable {
public readonly SecurityCriteriaClause security_criteria;
public readonly AlgoTypeSetImmutable algo_type_set;
public SecurityAlgoTypeSetImmutable(SecurityCriteriaClause security_criteria, AlgoTypeSetImmutable algo_type_set, CustomOrderDefinitionImmutable? default_algo = null) {
this.security_criteria = security_criteria;
this.algo_type_set = algo_type_set;
}
}
static class AlgoTypeSetExtensions {
public static string fmt_diagnostic(this IEnumerable<SecurityAlgoTypeSetImmutable> rules, string line_delim = "\n") {
var sb = new StringBuilder();
int rule_count = 1;
using (var en = rules.GetEnumerator()) {
if (en.MoveNext()) {
string line_delim_tab1 = line_delim + "\t";
string line_delim_tab2 = line_delim + "\t\t";
append_rule(en.Current);
while (en.MoveNext()) {
sb.AppendLine();
append_rule(en.Current);
}
//
void append_rule(SecurityAlgoTypeSetImmutable r) {
sb.Append(line_delim + $"**RULE {rule_count++}**");
sb.Append(line_delim_tab1);
sb.Append("Security Criteria: ");
sb.Append(r.security_criteria.is_defined ? string.Join("; ", r.security_criteria.fmt_diagnostic_msgs()) : "(Undefined)");
sb.Append(line_delim_tab1);
// Factory
sb.Append("Factory Types:");
sb.Append(line_delim_tab2);
sb.Append(string.Join(line_delim_tab2, r.algo_type_set.factory_types));
sb.Append(line_delim_tab1);
// Dynamic
sb.Append("Dynamic Types:");
sb.Append(line_delim_tab2);
sb.Append(string.Join(line_delim_tab2, r.algo_type_set.dynamic_types));
}
}
}
return sb.ToString();
}
public static AlgoTypeSetImmutable intersect_with(this AlgoTypeSetImmutable a, AlgoTypeSetImmutable b) =>
new AlgoTypeSetImmutable(a.factory_types.Intersect(b.factory_types), a.dynamic_types.Intersect(b.dynamic_types));
public static AlgoTypeSetImmutable union_with(this AlgoTypeSetImmutable a, AlgoTypeSetImmutable b) =>
new AlgoTypeSetImmutable(a.factory_types.Union(b.factory_types), a.dynamic_types.Union(b.dynamic_types));
public static IEnumerable<AlgoData> define_algos(
this AlgoTypeSetImmutable algo_set,
DynamicOrderHelper dynamic_helper,
Func<CustomOrderDefinitionImmutable, CustomOrderDefinitionImmutable> fit_to_type = null,
uint display_qty_divisor = 1) =>
//
algo_set.factory_types
.Select(algo_type => {
var def = OrderDataHelper.Defaults.CustomOrderDefinitionImmutable(algo_type);
if (fit_to_type != null)
def = fit_to_type(def);
// multiply quantity props by display qty divisor to get appropriate actual value
if (display_qty_divisor > 1) {
switch (def.CustomCase) {
case AlgoType.Iceberg:
var mdef = def.CloneToMutable();
mdef.Iceberg.ShowQuantity *= display_qty_divisor;
def = new CustomOrderDefinitionImmutable(mdef);
break;
}
}
return def;
})
.Concat(algo_set.dynamic_types.Select(dynamic_helper.create_custom_defi))
.Select(AlgoData.from_custom_def);
public static ImmutableDictionary<AlgoKey, AlgoData> match_algos(
this IEnumerable<SecurityAlgoTypeSetImmutable> security_algo_sets,
SecurityCriteriaClause clause,
DynamicOrderHelper dynamic_helper,
Func<CustomOrderDefinitionImmutable, CustomOrderDefinitionImmutable> fit_to_type = null,
uint display_qty_divisor = 1) {
//
ImmutableDictionary<AlgoKey, AlgoData> rv = null;
foreach (var set in security_algo_sets) {
if (!clause.is_subset_of(set.security_criteria)) {
continue;
} else if (rv == null) {
rv = ImmutableDictionary.CreateRange(
set.algo_type_set.define_algos(dynamic_helper, fit_to_type, display_qty_divisor)
.Select(a => new KeyValuePair<AlgoKey, AlgoData>(a.key, a)));
} else {
foreach (var kv in rv) {
if (kv.Value.value.CustomCase == AlgoType.Dynamic) {
if (!set.algo_type_set.dynamic_types.Contains(kv.Value.value.Dynamic.DynamicOrderType))
rv = rv.Remove(kv.Key);
} else if (!set.algo_type_set.factory_types.Contains(kv.Value.value.CustomCase))
rv = rv.Remove(kv.Key);
}
}
}
return rv ?? ImmutableDictionary<AlgoKey, AlgoData>.Empty;
}
}
}
@@ -0,0 +1,234 @@
using bts.api;
using bts.api.core;
using bts.api.orderman;
using bts.utils;
using mbts.spark.utilities;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Reactive.Linq;
namespace mbts.spark {
interface IAlgoProvider {
AlgoTypeSetImmutable get_permitted_algos(SecurityImmutable security);
AlgoTypeSetImmutable get_permitted_algos(SecurityCriteriaClause clause);
IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_algos();
IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_algos(SecurityImmutable security);
IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_algos(SecurityCriteriaClause clause);
}
// This interface is used to distinguish the attachable algo provider
// from the standard one wrt MEF export/import.
interface IAttachableAlgoProvider : IAlgoProvider { }
class AlgoProvider : IAlgoProvider {
readonly IEnumerable<SecurityAlgoTypeSetImmutable> _security_algo_types;
readonly IAlgoStudioModel _studio_model;
readonly ISecurityAuxiliaryDataModel _security_auxiliary_model;
readonly IObservable<TableUpdate<AlgoData, AlgoKey>> _studio_algos_source;
readonly DynamicOrderHelper _dynamic_helper;
readonly AlgoTypeSetImmutable _full_set;
public AlgoProvider(IEnumerable<SecurityAlgoTypeSetImmutable> algo_sets, IAlgoStudioModel studio_model, DynamicOrderHelper dynamic_helper, ISecurityAuxiliaryDataModel security_auxiliary_model) {
_security_algo_types = algo_sets;
_studio_model = studio_model;
_dynamic_helper = dynamic_helper;
_full_set = new AlgoTypeSetImmutable(
ImmutableHashSet.CreateRange(
EnumHelper.get_values_except(CustomOrderDefinition.CustomOneofCase.None, CustomOrderDefinition.CustomOneofCase.Dynamic, CustomOrderDefinition.CustomOneofCase.Composite)),
ImmutableHashSet.CreateRange(dynamic_helper.dynamic_types));
_security_auxiliary_model = security_auxiliary_model;
/// initialize <see cref="_studio_algos_source"/> with an empty table, so the
/// <see cref="UpdateExtensions.AppendTable{T, TKey}(IObservable{TableUpdate{T, TKey}}, IEnumerable{T})"/>
/// calls made by the 'subscribe_algos' methods will fire at least once, even if the underlying
/// studio algos stream is empty have been created (this would be the case if the user had not yet created any studio algos).
/// <see cref="subscribe_algos"/>,
/// <see cref="subscribe_algos(SecurityCriteriaClause)"/>,
/// <see cref="subscribe_algos(SecurityImmutable)"/>
_studio_algos_source = studio_model.definitions
.StartWith(TableUpdate<AlgoData, AlgoKey>.mk_empty(AlgoData.key_fn))
.Cache();
}
public AlgoTypeSetImmutable get_permitted_algos(SecurityImmutable security) =>
_security_algo_types.Where(p => p.security_criteria.includes(security))
.Select(sec_algos => sec_algos.algo_type_set)
.Aggregate(_full_set, (result, algos) => result.intersect_with(algos));
public AlgoTypeSetImmutable get_permitted_algos(SecurityCriteriaClause clause) =>
_security_algo_types.Where(p => p.security_criteria.is_subset_of(clause))
.Select(sec_algos => sec_algos.algo_type_set)
.Aggregate(_full_set, (result, algos) => result.intersect_with(algos));
public IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_algos() =>
_studio_algos_source
.AppendTable(_security_algo_types
.Select(s => s.algo_type_set)
.Aggregate(AlgoTypeSetImmutable.empty, (a, b) => a.union_with(b))
.define_algos(_dynamic_helper));
public IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_algos(SecurityCriteriaClause security_clause) {
var system_algos = _security_algo_types.match_algos(
security_clause,
_dynamic_helper,
def => _fit_to_type(def, security_clause, _security_algo_types));
return _studio_algos_source.Select(
a => (algo: a, fitted_def: _fit_to_type(a.value, security_clause, _security_algo_types)),
tup => tup.algo.key)
.Select(tup => AlgoData.create(tup.fitted_def, tup.algo.name, tup.algo.key), a => a.key)
.AppendTable(system_algos.Values);
}
public IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_algos(SecurityImmutable security) {
var clause = new SecurityCriteriaClause(
exchanges: new[] { security.Exchange },
security_types: new[] { security.security_type() });
// i.e., non-studio algos
var system_algos = _security_algo_types.match_algos(
clause,
_dynamic_helper,
def => _fit_to_type(def, security, _security_algo_types),
_security_auxiliary_model.get_display_quantity_divisor(security));
return _studio_algos_source.Select(
a => (algo: a, fitted_def: _fit_to_type(a.value, security, _security_algo_types)),
tup => tup.algo.key)
// filter out algos that use an unsupported root, because this would have the effect of duplicating the default algo
// (e.g., GlbxIceberg orders would be converted to Limit/Spreader orders for non-Glbx securities).
.Filter(tup => tup.fitted_def.actual().CustomCase == tup.algo.value.actual().CustomCase, tup => tup.algo.key)
.Select(tup => AlgoData.create(tup.fitted_def, tup.algo.name, tup.algo.key), AlgoData.key_fn)
.AppendTable(system_algos.Values);
}
protected virtual void assign_fallback_algo(CustomOrderDefinition mdef, SecurityCriteriaClause security_clause) {
if (security_clause.security_types.empty_if_null().Contains(Security.ContractOneofCase.Synthetic.security_type())) {
mdef.Spreader = new SpreaderOrderDefinition();
} else {
mdef.Limit = new LimitOrderDefinition();
}
}
protected virtual void assign_fallback_algo(CustomOrderDefinition mdef, SecurityImmutable security) {
if (security.ContractCase == Security.ContractOneofCase.Synthetic) {
mdef.Spreader = new SpreaderOrderDefinition {
Security = security.CloneToMutable()
};
} else {
mdef.Limit = new LimitOrderDefinition();
}
}
CustomOrderDefinitionImmutable _fit_to_type(CustomOrderDefinitionImmutable defi, SecurityCriteriaClause security_clause, IEnumerable<SecurityAlgoTypeSetImmutable> algo_sets) {
var mroot = defi.CloneToMutable();
if (_fit_to_type(mroot, security_clause, algo_sets)) {
defi = new CustomOrderDefinitionImmutable(mroot);
}
return defi;
}
CustomOrderDefinitionImmutable _fit_to_type(CustomOrderDefinitionImmutable defi, SecurityImmutable security, IEnumerable<SecurityAlgoTypeSetImmutable> algo_sets) {
var mroot = defi.CloneToMutable();
if (_fit_to_type(mroot, security, algo_sets)) {
defi = new CustomOrderDefinitionImmutable(mroot);
}
return defi;
}
bool _fit_to_type(CustomOrderDefinition mdef, SecurityCriteriaClause security_clause, IEnumerable<SecurityAlgoTypeSetImmutable> algo_sets) {
while (mdef.CustomCase == CustomOrderDefinition.CustomOneofCase.Composite)
mdef = mdef.Composite.Definition;
var sec_sets = algo_sets.Where(s => security_clause.is_subset_of(s.security_criteria));
if (mdef.CustomCase == CustomOrderDefinition.CustomOneofCase.Dynamic) {
if (!algo_sets.All(s => s.algo_type_set.dynamic_types.Contains(mdef.Dynamic.DynamicOrderType))) {
assign_fallback_algo(mdef, security_clause);
return true;
}
} else if (!sec_sets.All(s => s.algo_type_set.factory_types.Contains(mdef.CustomCase))) {
assign_fallback_algo(mdef, security_clause);
return true;
}
return OrderDataHelper.get_child_algo_data(mdef).Count(cad => _fit_to_type(cad.get_child(mdef), security_clause, algo_sets)) > 0;
}
bool _fit_to_type(CustomOrderDefinition mdef, SecurityImmutable security, IEnumerable<SecurityAlgoTypeSetImmutable> algo_sets) {
while (mdef.CustomCase == CustomOrderDefinition.CustomOneofCase.Composite)
mdef = mdef.Composite.Definition;
var sec_sets = algo_sets.Where(s => s.security_criteria.includes(security));
if (mdef.CustomCase == CustomOrderDefinition.CustomOneofCase.Dynamic) {
if (!sec_sets.All(s => s.algo_type_set.dynamic_types.Contains(mdef.Dynamic.DynamicOrderType))) {
assign_fallback_algo(mdef, security);
return true;
}
} else if (!sec_sets.All(s => s.algo_type_set.factory_types.Contains(mdef.CustomCase))) {
assign_fallback_algo(mdef, security);
return true;
}
return OrderDataHelper.get_child_algo_data(mdef).Count(cad => _fit_to_type(cad.get_child(mdef), security, algo_sets)) > 0;
}
}
class AttachableAlgoProvider : AlgoProvider, IAttachableAlgoProvider {
public AttachableAlgoProvider(IEnumerable<SecurityAlgoTypeSetImmutable> algo_sets, IAlgoStudioModel studio_model, DynamicOrderHelper dynamic_helper, ISecurityAuxiliaryDataModel security_auxiliary_model)
: base(algo_sets, studio_model, dynamic_helper, security_auxiliary_model) { }
// arbitrarily assign LimitOrderDefinition (this is just a placeholder; the real child is the attach target algo).
// Note: although 'None' might seem approrpriate, the server requires a valid definition (perhaps this will change in the future).
protected override void assign_fallback_algo(CustomOrderDefinition mdef, SecurityCriteriaClause security_clause) =>
mdef.Limit = new LimitOrderDefinition();
// arbitrarily assign LimitOrderDefinition (this is just a placeholder; the real child is the attach target algo).
// Note: although 'None' might seem approrpriate, the server requires a valid definition (perhaps this will change in the future).
protected override void assign_fallback_algo(CustomOrderDefinition mdef, SecurityImmutable security) =>
mdef.Limit = new LimitOrderDefinition();
}
static class AlgoProviderExtensions {
// This stream filters out composite algos that are not subsets of the non-composite algo types in the table
// (normally, such composites are 'auto-fit,' meaning the algo nodes that are not part of the set are replaced with ones that are).
// For example, consider a composite algo the following structure: Offset -> GlbxIceberg.
// If an update arrives with these noncomposite types: "Iceberg, Limit, Market," that composite algo is not a subset of the non-composite algo types,
// because GlbxIceberg is not in the table, so it would only be added to the table if/when GlbxIceberg arrives.
public static IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_complete_algos(this IAlgoProvider algo_provider, bool allow_undefined_child = false) =>
subscribe_complete_algos(algo_provider.subscribe_algos(), allow_undefined_child);
public static IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_complete_algos(IObservable<TableUpdate<AlgoData, AlgoKey>> source, bool allow_undefined_child = false) =>
Observable.Create<TableUpdate<AlgoData, AlgoKey>>(o => {
var last_out = TableUpdate<AlgoData, AlgoKey>.mk_empty(AlgoData.key_fn);
var incomplete_composites = ImmutableHashSet<AlgoData>.Empty;
return source.Subscribe(table => {
var bd = last_out.to_builder();
foreach (var algo in incomplete_composites.Where(a => _validate_algo_structure(a.value, table.state, allow_undefined_child))) {
incomplete_composites = incomplete_composites.Remove(algo);
bd.add_or_update(algo);
}
foreach (var a in table.removed.Concat(table.changes.Old()))
bd.remove(a.key);
foreach (var a in table.added.Concat(table.changed)) {
if (_validate_algo_structure(a.value, table.state, allow_undefined_child)) {
bd.add_or_update(a);
} else {
incomplete_composites = incomplete_composites.Add(a);
}
}
o.OnNext(last_out = bd.to_table());
});
});
static bool _validate_algo_structure(CustomOrderDefinitionImmutable custom_def, IReadOnlyDictionary<AlgoKey, AlgoData> allowed_algo_parts, bool allow_undefined_child) =>
OrderDataHelper.enumerate_algo_structure(custom_def)
.Select((algo_node, index) =>
// None is an acceptable algo type as long as it's not the root algo (i.e., index > 0)
(index > 0 && allow_undefined_child && algo_node.type == CustomOrderDefinition.CustomOneofCase.None) || _is_part_contained(algo_node, allowed_algo_parts))
.All();
static bool _is_part_contained((CustomOrderDefinition.CustomOneofCase type, string dyn, uint studio_id, uint spreader_sec) structure, IReadOnlyDictionary<AlgoKey, AlgoData> state) =>
structure.type == CustomOrderDefinition.CustomOneofCase.Composite ||
structure.type == CustomOrderDefinition.CustomOneofCase.Dynamic ?
state.ContainsKey(AlgoKey.from_dynamic_type(structure.dyn)) :
state.ContainsKey(AlgoKey.from_known_type(structure.type));
}
}
@@ -276,7 +276,7 @@ namespace mbts.spark {
ob_settings.filters = new bts.shell.orderbook.FilterStates {
statuses = new[] { OrderStatus.Working },
sides = new[] { side },
security_criteria = new SecurityCriteria(security)
security_criteria = SecurityCriteria.from_securities(security)
};
_bus.post(SparkTags.ShowOrderBookTag, ob_settings);
}
@@ -66,7 +66,7 @@ namespace mbts.spark {
if (_sorted_selected_security_criteria_backing != null) {
_selected_security_criteria_backing = _sorted_selected_security_criteria_backing;
} else if (_vm != null)
_selected_security_criteria_backing = new SecurityCriteria(_vm.selected_rows.Select(r => r.security));
_selected_security_criteria_backing = SecurityCriteria.from_securities(_vm.selected_rows.Select(r => r.security));
}
return _selected_security_criteria_backing;
}
@@ -92,7 +92,7 @@ namespace mbts.spark {
}
}
var comp = comp_builder.to_comparer();
_sorted_selected_security_criteria_backing = new SecurityCriteria(_vm.selected_rows.Ordered(comp).Select(r => r.security));
_sorted_selected_security_criteria_backing = SecurityCriteria.from_securities(_vm.selected_rows.Ordered(comp).Select(r => r.security));
}
}
return _sorted_selected_security_criteria_backing;
@@ -135,7 +135,7 @@ namespace bts.shell.time_and_sales {
.complete(selected_rows_src, always_true, get_fills_startup_data),
// mview
SparkCommands.ShowMarketView
.complete(selected_rows_src, always_true, rows => rows.Count > 0 ? new SecurityCriteria(rows.Select(r => r.security)) : _security_criteria),
.complete(selected_rows_src, always_true, rows => rows.Count > 0 ? SecurityCriteria.from_securities(rows.Select(r => r.security)) : _security_criteria),
// pause
toggle_is_paused_cmd,
// change securities
@@ -180,7 +180,7 @@ namespace bts.shell.time_and_sales {
FillsSettings get_fills_startup_data(ImmutableHashSet<TimeAndSalesRowVM> rows) =>
new FillsSettings(new FillsFilterStates {
security = rows.Count > 0 ? new SecurityCriteria(rows.Select(r => r.security)) : _security_criteria
security = rows.Count > 0 ? SecurityCriteria.from_securities(rows.Select(r => r.security)) : _security_criteria
});
string get_is_paused_cmd_title() =>
@@ -46,7 +46,7 @@ namespace bts.shell {
async void _show_synthetic_create(SecurityCriteria security_criteria) {
var found_securities = await security_criteria.securities(_bus);
var respect_clause_security_ordering_is_possible = security_criteria.clauses.Any(clause => clause.security_keys != null && clause.security_keys.Count > 0);
var respect_clause_security_ordering_is_possible = security_criteria.clauses.Any(clause => clause.security_keys != null && clause.security_keys.Length > 0);
if (!respect_clause_security_ordering_is_possible) {
_show_synthetic_create(found_securities.Values.ToList());
} else {
@@ -114,6 +114,8 @@ namespace bts.shell {
public static QuoteInsideMarketDistanceWithTravel QuoteInsideMarketDistanceWithTravel => new QuoteInsideMarketDistanceWithTravel { Priority = RulePriority };
public static QuoteInsideMarketDistance QuoteInsideMarketDistance => new QuoteInsideMarketDistance { Priority = RulePriority };
public static QuoteInsideMarketDistanceThrottle QuoteInsideMarketDistanceThrottle => new QuoteInsideMarketDistanceThrottle();
public static QuoteTimeBasedThrottle QuoteTimeBasedThrottle => new QuoteTimeBasedThrottle { DelayToImprove = 0, DelayToRun = 0 };
#endregion
#region PreHedge
@@ -79,7 +79,7 @@ namespace mbts.spark {
), SparkCommands.ShowOrders.complete(() => {
var ob_settings = bts.shell.orderbook.OrderBookStartupData.Default;
ob_settings.filters = new bts.shell.orderbook.FilterStates {
security_criteria = new SecurityCriteria(_vm.value.row_vms.Select(r => r.security))
security_criteria = SecurityCriteria.from_securities(_vm.value.row_vms.Select(r => r.security))
};
return ob_settings;
}), SparkCommands.window_settings_command(new DialogCommand(() => {
@@ -10,13 +10,13 @@ namespace mbts.spark {
public override string man_page { get; } = string.Empty;
public override bool get_value(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.EnableHedging;
leg_tup.leg_params.SendHedge is null || leg_tup.leg_params.SendHedge.Val;
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) =>
leg_tup.leg_params.EnableHedging = value;
public override bool has_errors(IReadOnlyCollection<LegSpreaderParamsTuple> leg_tups) =>
!leg_tups.Any(lt => lt.leg_params.EnableHedging);
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) {
if (leg_tup.leg_params.SendHedge is null)
leg_tup.leg_params.SendHedge = new bts.spark.NullableBoolean();
leg_tup.leg_params.SendHedge.Val = value;
}
}
}
}
}
@@ -0,0 +1,21 @@
using mbts.ui.spark;
using System;
namespace mbts.spark {
partial class SyntheticEditorVM {
class LeanOffsetTicksModel : RowModelBase<int> {
public override string display_name { get; } = "Lean Offset Ticks";
public override string help_text { get; } = "Improvement (in ticks) to the lean market";
public override string man_page { get; } = string.Empty;
public override int get_value(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.QuoteParams?.LeanOffsetTicks ?? 0;
public override void set_value(LegSpreaderParamsTuple leg_tup, int value) {
if (leg_tup.leg_params.QuoteParams is null)
leg_tup.leg_params.QuoteParams = new bts.spark.QuoteParams();
leg_tup.leg_params.QuoteParams.LeanOffsetTicks = value;
}
}
}
}
@@ -0,0 +1,40 @@
using bts.shell;
using bts.spark;
using mbts.ui.spark;
using System.Collections.Generic;
namespace mbts.spark {
partial class SyntheticEditorVM {
class QuoteTimeThrottleDelayToImproveModel : RowModelBase<uint> {
readonly IDictionary<int, uint> _value_store = new Dictionary<int, uint>();
public override string display_name { get; } = "Delay to Improve (ms)";
public override string help_text { get; } = string.Empty;
public override string man_page { get; } = string.Empty;
public override ParameterSection[] section_path { get; } = new[] { Sections.Quote, Subsections.TimeThrottle };
public void apply_value(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup).DelayToImprove = _value_from_store(leg_tup);
public override uint get_value(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup) is QuoteTimeBasedThrottle throttle ?
throttle.DelayToImprove :
_value_from_store(leg_tup);
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) {
_value_store[leg_tup.id] = value;
if (_get_throttle(leg_tup) is QuoteTimeBasedThrottle throttle)
throttle.DelayToImprove = value;
}
protected override bool _get_enabled(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup) != null;
QuoteTimeBasedThrottle _get_throttle(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.QuoteParams.TimeBasedThrottle;
uint _value_from_store(LegSpreaderParamsTuple leg_tup) =>
_value_store.GetValueOrDefault(leg_tup.id, _ => SyntheticDataHelper.Defaults.QuoteTimeBasedThrottle.DelayToImprove);
}
}
}
@@ -0,0 +1,40 @@
using bts.shell;
using bts.spark;
using mbts.ui.spark;
using System.Collections.Generic;
namespace mbts.spark {
partial class SyntheticEditorVM {
class QuoteTimeThrottleDelayToRunModel : RowModelBase<uint> {
readonly IDictionary<int, uint> _value_store = new Dictionary<int, uint>();
public override string display_name { get; } = "Delay To Run (ms)";
public override string help_text { get; } = string.Empty;
public override string man_page { get; } = string.Empty;
public override ParameterSection[] section_path { get; } = new[] { Sections.Quote, Subsections.TimeThrottle };
public void apply_value(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup).DelayToRun = _value_from_store(leg_tup);
public override uint get_value(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup) is QuoteTimeBasedThrottle throttle ?
throttle.DelayToRun :
_value_from_store(leg_tup);
public override void set_value(LegSpreaderParamsTuple leg_tup, uint value) {
_value_store[leg_tup.id] = value;
if (_get_throttle(leg_tup) is QuoteTimeBasedThrottle throttle)
throttle.DelayToRun = value;
}
protected override bool _get_enabled(LegSpreaderParamsTuple leg_tup) =>
_get_throttle(leg_tup) != null;
QuoteTimeBasedThrottle _get_throttle(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.QuoteParams.TimeBasedThrottle;
uint _value_from_store(LegSpreaderParamsTuple leg_tup) =>
_value_store.GetValueOrDefault(leg_tup.id, _ => SyntheticDataHelper.Defaults.QuoteTimeBasedThrottle.DelayToRun);
}
}
}
@@ -0,0 +1,38 @@
using bts.shell;
using mbts.ui.spark;
namespace mbts.spark {
partial class SyntheticEditorVM {
class QuoteTimeThrottleEnabledModel : RowModelBase<bool> {
readonly QuoteTimeThrottleDelayToRunModel _delay_to_run;
readonly QuoteTimeThrottleDelayToImproveModel _delay_to_improve;
public QuoteTimeThrottleEnabledModel(QuoteTimeThrottleDelayToRunModel delay_to_run, QuoteTimeThrottleDelayToImproveModel delay_to_improve) {
_delay_to_run = delay_to_run;
_delay_to_improve = delay_to_improve;
}
public override string display_name { get; } = string.Empty;
public override string help_text { get; } = string.Empty;
public override string man_page { get; } = string.Empty;
public override ParameterSection[] section_path { get; } = new[] { Sections.Quote, Subsections.TimeThrottle };
public override bool get_value(LegSpreaderParamsTuple leg_tup) =>
leg_tup.leg_params.QuoteParams.TimeBasedThrottle != null;
public override void set_value(LegSpreaderParamsTuple leg_tup, bool value) {
if (value) {
if (leg_tup.leg_params.QuoteParams.TimeBasedThrottle == null) {
leg_tup.leg_params.QuoteParams.TimeBasedThrottle = SyntheticDataHelper.Defaults.QuoteTimeBasedThrottle;
_delay_to_run.apply_value(leg_tup);
_delay_to_improve.apply_value(leg_tup);
}
} else {
leg_tup.leg_params.QuoteParams.TimeBasedThrottle = null;
}
_delay_to_run.set_enabled(leg_tup, value);
_delay_to_improve.set_enabled(leg_tup, value);
}
}
}
}
@@ -108,6 +108,10 @@ namespace mbts.spark {
"Reduces re-quoting updates by defining a region on either side " +
"of the working quoting order, inside which quote updates will not be sent.");
public static ParameterSection TimeThrottle =>
new ParameterSection("Time Throttle", true,
"Reduces re-quoting updates by requiring a minimum amount of time to elapse between quotes.");
public static ParameterSection Conditional =>
new ParameterSection("Conditional", true,
"Reduces re-quoting updates by only quoting if N ticks away from the opposite " +
@@ -85,9 +85,7 @@ namespace mbts.spark {
icon = Icons.Synthetics;
_has_working_orders = backing(nameof(has_working_orders), false);
contract_picker_model = new ContractPickerModel(bus, false, null, new SecurityCriteria(new[] {
new SecurityCriteriaClause() {
exchanges = EnumHelper.get_values_except(Venue.Bts).ToArray()
}
new SecurityCriteriaClause(exchanges: EnumHelper.get_values_except(Venue.Bts).ToArray())
}));
contract_picker_model.cancel_action += _close_new_leg_popup;
contract_picker_model.ok_action += () => {
@@ -198,6 +196,9 @@ namespace mbts.spark {
var quote_throttle_outside_ticks = new QuoteThrottleOutsideTicksModel();
var quote_throttle_inside_ticks = new QuoteThrottleInsideTicksModel();
var quote_time_throttle_delay_to_run = new QuoteTimeThrottleDelayToRunModel();
var quote_time_throttle_delay_to_improve = new QuoteTimeThrottleDelayToImproveModel();
var conditional_quoting_ticks = new ConditionalQuotingTicksModel();
var conditional_quoting_price_type = new ConditionalQuotingPriceTypeModel();
@@ -225,17 +226,24 @@ namespace mbts.spark {
_quantity_model,
_price_mult_model,
is_quote_model,
//new EnableHedgeModel(), //TAHA_SPREADER
new EnableHedgeModel(), //TAHA_SPREADER
new HedgeRatioModel(),
//new MinLeanQtyModel(), //TAHA_SPREADER
new LeanOffsetTicksModel(),
//new QuoteHiddenModel(),
new QuoteQueueHolderModel(),
new MarketDataTypeModel(),
new ShowQuantityEnabledModel(show_quantity_quantity),
show_quantity_quantity,
// Throttle
new QuoteThrottleEnabledModel(quote_throttle_inside_ticks, quote_throttle_outside_ticks),
quote_throttle_inside_ticks,
quote_throttle_outside_ticks,
// Time Throttle
new QuoteTimeThrottleEnabledModel(quote_time_throttle_delay_to_run, quote_time_throttle_delay_to_improve),
quote_time_throttle_delay_to_run,
quote_time_throttle_delay_to_improve,
new ConditionalQuoteEnabledModel(conditional_quoting_ticks, conditional_quoting_price_type),
conditional_quoting_ticks,
//conditional_quoting_price_type,
@@ -169,7 +169,7 @@ namespace mbts.spark {
void _show_order_book() {
var ob_settings = bts.shell.orderbook.OrderBookStartupData.Default;
ob_settings.filters = new bts.shell.orderbook.FilterStates {
security_criteria = new SecurityCriteria(security)
security_criteria = SecurityCriteria.from_securities(security)
};
_bus.post(SparkTags.ShowOrderBookTag, ob_settings);
}
@@ -9,6 +9,8 @@ namespace mbts.spark {
// This is a core data type on the front end, so data validation is strict, as bad values may yield weird/difficult to track bugs.
// Descriptive factory methods are favored over public constructors, as they are less likely to be misused.
struct AlgoData : IEquatable<AlgoData> {
public static readonly Func<AlgoData, AlgoKey> key_fn = a => a.key;
public readonly CustomOrderDefinitionImmutable value;
public readonly string name;
public readonly AlgoKey key;
@@ -128,6 +128,7 @@ namespace mbts.spark {
}
public bool is_persisted => mode == Mode.Persisted;
public bool is_composite => _composite_key.HasValue || _unpersisted.HasValue;
public uint persisted => _composite_key.Value;
public Guid unpersisted => _unpersisted.Value;
@@ -199,6 +200,15 @@ namespace mbts.spark {
}
return EqualityComparer.phase_hash(hash, phase_mult);
}
public override string ToString() {
switch (mode) {
case Mode.Dynamic: return $"Dynamic: {dynamic_type}";
case Mode.Factory: return $"Factory: {factory}";
case Mode.Persisted: return $"Composite: {persisted}";
case Mode.Unpersisted: return $"(Composite): {unpersisted}";
default: return mode.ToString();
}
}
public static bool operator ==(AlgoKey a, AlgoKey b) => a.Equals(b);
public static bool operator !=(AlgoKey a, AlgoKey b) => !a.Equals(b);
@@ -12,20 +12,20 @@ namespace mbts.spark {
[Export(typeof(IAlgoStudioModel))]
class AlgoStudioFlatDefinitionModel : IAlgoStudioModel, IDisposable {
readonly AlgoDefinitionService _service;
readonly AdminModel _admin_model;
readonly UserTuple _user;
readonly ErrorReporter _error_reporter;
IReadOnlyDictionary<AlgoKey, AlgoData> _algos = DictionaryHelper.empty<AlgoKey, AlgoData>();
IDisposable _dispose;
[ImportingConstructor]
public AlgoStudioFlatDefinitionModel(AlgoDefinitionService service, IAlgoDefinitionMetadataService metadata_service, AdminModel admin_model, ErrorReporter error_reporter) {
public AlgoStudioFlatDefinitionModel(AlgoDefinitionService service, IAlgoDefinitionMetadataService metadata_service, UserTuple user, ErrorReporter error_reporter) {
_service = service;
this.metadata_service = metadata_service;
_admin_model = admin_model;
_user = user;
_error_reporter = error_reporter;
definitions =
service.subscribei_algo_definitions()
.Filter(r => r.Metadata.IsActive && _admin_model.user.can_access_user_data(r.Metadata.CreatorUserId))
.Filter(r => r.Metadata.IsActive && _user.can_access_user_data(r.Metadata.CreatorUserId))
.SelectKeyValue(_definition_data, d => d.key)
.Table()
.Cache();
@@ -37,7 +37,7 @@ namespace mbts.spark {
public async Task<AlgoData?> save_definition(AlgoData definition_data) {
var (value, success) = await _error_reporter.safe_execute(() => _service.save_algo_definition_async(
_with_key(new AlgoDefinitionUpdateRequest { UserId = _admin_model.user.id, Algo = _api_definition(definition_data) }, definition_data.key)),
_with_key(new AlgoDefinitionUpdateRequest { UserId = _user.id, Algo = _api_definition(definition_data) }, definition_data.key)),
r => r.Success, r => r.ErrorMessage, "saving definition");
if (success)
return _definition_data(new AlgoDefinitionRecordImmutable(value.Record));
@@ -93,4 +93,4 @@ namespace mbts.spark {
}
}
}
}
}
@@ -11,6 +11,8 @@ namespace mbts.spark {
/// decouple the client-side key type from the server-side one, so both key types may evolve independently moving forward.
/// </summary>
struct AlgoDefinitionMetadata : IEquatable<AlgoDefinitionMetadata> {
public static readonly Func<AlgoDefinitionMetadata, AlgoKey> key_fn = m => m.id;
public readonly AlgoKey id, default_template;
readonly AlgoKey[] _favorite_templates;
public readonly bool is_favorite, is_hidden;
@@ -35,34 +35,21 @@ namespace mbts.spark {
Comparer<IAlgoVM>.Create(_CompareUtils.compare_names)
}).to_comparer().to_safe();
public static void update_persisted_definitions(ObservableKeyedCollection<AlgoDefinitionVM, AlgoKey> target, TableUpdate<AlgoData, AlgoKey> update, Func<AlgoData, AlgoDefinitionVM> factory) {
foreach (var d in update.removed)
target.Remove(d.key);
foreach (var d in update.changed)
public static void update_persisted_definitions(ObservableKeyedCollection<AlgoDefinitionVM, AlgoKey> target, TableUpdate<AlgoData, AlgoKey> update, Func<AlgoData, AlgoDefinitionVM> factory) =>
update_persisted_definitions(target, update.added, update.changed, update.removed.Select(AlgoData.key_fn), factory);
public static void update_persisted_definitions(ObservableKeyedCollection<AlgoDefinitionVM, AlgoKey> target, IEnumerable<AlgoData> added, IEnumerable<AlgoData> changed, IEnumerable<AlgoKey> removed, Func<AlgoData, AlgoDefinitionVM> factory) {
foreach (var k in removed)
target.Remove(k);
foreach (var d in changed)
target[d.key].load(d);
foreach (var d in update.added) {
foreach (var d in added) {
if (target.TryGetValue(d.key, out AlgoDefinitionVM def)) {
def.load(d);
} else target.Add(factory(d));
}
}
public static void update_persisted_definition_wrappers(IDictionary<AlgoKey, IAlgoVM> target, TableUpdate<AlgoData, AlgoKey> update, Func<AlgoData, AlgoDefinitionVM> factory) {
foreach (var d in update.removed)
target.Remove(d.key);
foreach (var d in update.changed) {
var vm = target[d.key];
if (vm is AlgoVMWrapper wrapper) {
wrapper.value.load(d);
} else vm.load_from(d.value);
}
foreach (var d in update.added) {
if (target.TryGetValue(d.key, out IAlgoVM def)) {
def.load_from(d.value);
} else target.Add(d.key, new AlgoVMWrapper(factory(d)));
}
}
public static void commit_all(this IEnumerable<AlgoParamRowVM> algo_param_rows) =>
algo_param_rows.Select(r => r.param).commit_all();
@@ -42,21 +42,21 @@ namespace mbts.spark {
readonly Property<string> _name, _abbreviation;
readonly ObservableKeyedCollection<IAlgoVM, AlgoKey> _algo_roots = new ObservableKeyedCollection<IAlgoVM, AlgoKey>(vm => vm.id);
readonly DeferrableActionWrapper _refresh_on_local_changes;
readonly Property<AlgoFormats> _selected_format;
readonly EnumMaskInt32<AlgoEditingPermissions> _permissions_mask = new EnumMaskInt32<AlgoEditingPermissions>();
int? _favorite_index;
Brush _badge_fill;
Snapshot? _committed;
AlgoDefinitionMetadata _metadata;
IDisposable _loaded_data_hook;
public static AlgoDefinitionVM create(OrdersModel model, AlgoData data, AlgoFormats init_format = AlgoFormats.Exchange, AlgoEditingPermissions editing_permissions = (AlgoEditingPermissions)int.MaxValue) =>
new AlgoDefinitionVM(model, data, init_format, editing_permissions);
public static AlgoDefinitionVM create(OrdersModel model, AlgoData data, AlgoEditingPermissions editing_permissions = (AlgoEditingPermissions)int.MaxValue) =>
new AlgoDefinitionVM(model, data, editing_permissions);
public static AlgoDefinitionVM create_placeholder(OrdersModel model, CustomOrderDefinitionImmutable def, string name, AlgoFormats init_format) =>
new AlgoDefinitionVM(model, AlgoData.create_unpersisted(def, name), init_format, (AlgoEditingPermissions)int.MaxValue);
public static AlgoDefinitionVM create_placeholder(OrdersModel model, CustomOrderDefinitionImmutable def, string name) =>
new AlgoDefinitionVM(model, AlgoData.create_unpersisted(def, name), (AlgoEditingPermissions)int.MaxValue);
AlgoDefinitionVM(OrdersModel model, AlgoData def_data, AlgoFormats init_format, AlgoEditingPermissions init_permissions) {
AlgoDefinitionVM(OrdersModel model, AlgoData def_data, AlgoEditingPermissions init_permissions) {
// init core data
_model = model;
_permissions_mask.mask = init_permissions;
@@ -80,7 +80,6 @@ namespace mbts.spark {
// init backing props
_name = backing(nameof(name), def_data.name);
_abbreviation = backing(nameof(abbreviation), string.Empty);
_selected_format = backing(nameof(selected_format), init_format);
_is_favorite = backing(nameof(is_favorite), () => _favorite_index.HasValue);
_is_expanded = backing(nameof(is_expanded), true);
_is_selected = backing(nameof(is_selected), true);
@@ -133,17 +132,6 @@ namespace mbts.spark {
break;
}
var permission_src = _permissions_mask.observe_result();
resources.Add(_selected_format.observe_current(true).CombineLatest(permission_src, (fmt, perms) => (fmt, perms))
.SubscribeEach(t => {
if ((t.perms & AlgoEditingPermissions.AllowEditStructure) != 0) {
using (_refresh_on_local_changes.defer_execution()) {
var algo_data = model.factory.default_algos(t.fmt);
var default_algo = AlgoKey.from_known_type(OrderDataHelper.get_default_algo(t.fmt));
return this.load_algo_data_recursive(algo_data, default_algo);
}
}
return Disposable.empty;
}));
resources.Add(permission_src.Subscribe(_ => RaisePropertyChanged(nameof(editing_permissions))));
resources.Add(this.connect_data(permission_src));
resources.Add(this.connect_data(Observable.Return(model)));
@@ -202,9 +190,6 @@ namespace mbts.spark {
public EnabledValueVM<Color> custom_badge_color { get; } = new EnabledValueVM<Color>();
public ObservableCollection<ColorPaletteVM> custom_badge_color_palettes { get; } = new ObservableCollection<ColorPaletteVM>();
public Brush badge_fill => _badge_fill;
// format
public AlgoFormats selected_format { get => _selected_format.Value; set => _selected_format.set(value); }
public ObservableCollection<AlgoFormats> formats { get; } = new ObservableCollection<AlgoFormats> { AlgoFormats.Exchange, AlgoFormats.Spreader, AlgoFormats.Exchange | AlgoFormats.Spreader };
// visual states
public ObservableCollection<string> edit_pane_visual_states => _edit_pane_vs_model.states;
public ObservableCollection<string> tree_view_visual_states => _tree_view_vs_model.states;
@@ -270,17 +255,14 @@ namespace mbts.spark {
void IObserver<(IReadOnlyDictionary<AlgoKey, AlgoData> algo_data, AlgoKey? default_algo)>.OnError(Exception error) { }
#endregion
void _load_algo_data(IReadOnlyDictionary<AlgoKey, AlgoData> algo_data, AlgoKey? default_algo) {
var orig_algo = algo_root?.id;
_algo_roots.SyncWithDictionary(algo_data, d => OrderTypeVMFactory.create(d, is_expanded: true));
if (!try_select(orig_algo) && !try_select(default_algo))
algo_root = algo_roots.FirstOrDefault();
//
bool try_select(AlgoKey? algo_key) {
if (algo_key.HasValue && _algo_roots.TryGetValue(algo_key.Value, out IAlgoVM match)) {
void _load_algo_data(IReadOnlyDictionary<AlgoKey, AlgoData> data, AlgoKey? default_algo) {
Disposable.dispose(ref _loaded_data_hook);
_algo_roots.SyncWithDictionary(data, d => OrderTypeVMFactory.create(d, is_expanded: true));
_loaded_data_hook = ObservableAutoWrapper.connect_item_hooks(algo_roots, vm =>
ObservableAutoWrapper.connect_item_actions(vm.child_algo_selectors, s => s.load_algo_data(data, null)));
if (algo_root == null || !_algo_roots.ContainsKey(algo_root.id)) {
if (default_algo.HasValue && _algo_roots.TryGetValue(default_algo.Value, out IAlgoVM match))
algo_root = match;
return true;
} else return false;
}
}
@@ -346,7 +328,7 @@ namespace mbts.spark {
// pass a copy of the persisted state - rather than use local values - because if something goes wrong, it is better to be in sync with data fresh from the server/api.
public AlgoDefinitionVM to_persisted(AlgoData def) =>
new AlgoDefinitionVM(_model, def, selected_format, editing_permissions_mask);
new AlgoDefinitionVM(_model, def, editing_permissions_mask);
public AlgoData create_algo_def() =>
AlgoData.create(algo_root == null ? new CustomOrderDefinitionImmutable(new CustomOrderDefinition()) : algo_root.definition, name, key);
@@ -368,7 +350,6 @@ namespace mbts.spark {
void _assign_from_data(Snapshot state) {
_assign_from_data(state.data);
_selected_format.set(state.format);
_abbreviation.set(state.abbreviation);
custom_badge_color.set_nullable(state.custom_badge_color);
}
@@ -429,41 +410,36 @@ namespace mbts.spark {
}
Snapshot _snapshot() =>
new Snapshot(create_algo_def(), abbreviation, custom_badge_color.get_nullable(), selected_format);
new Snapshot(create_algo_def(), abbreviation, custom_badge_color.get_nullable());
public struct Snapshot : IEquatable<Snapshot> {
public readonly AlgoData data;
public readonly string abbreviation;
public readonly Color? custom_badge_color;
public readonly AlgoFormats format;
public Snapshot(AlgoData data, string abbreviation, Color? custom_badge_color, AlgoFormats format) {
public Snapshot(AlgoData data, string abbreviation, Color? custom_badge_color) {
this.data = data;
this.abbreviation = abbreviation;
this.custom_badge_color = custom_badge_color;
this.format = format;
}
public bool Equals(Snapshot other) =>
data == other.data &&
abbreviation == other.abbreviation &&
custom_badge_color == other.custom_badge_color &&
format == other.format;
custom_badge_color == other.custom_badge_color;
public override bool Equals(object obj) => EqualityComparer.equals_obj(this, obj);
public override int GetHashCode() =>
EqualityComparer.aggregate_hash(
data.GetHashCode(),
abbreviation?.GetHashCode() ?? 0,
custom_badge_color?.GetHashCode() ?? 0,
(int)format);
custom_badge_color?.GetHashCode() ?? 0);
#if DEBUG
public override string ToString() {
var sb = new System.Text.StringBuilder();
sb.Append($"name: {data.name}; ");
sb.Append($"abbrev.: {abbreviation}; ");
sb.Append($"badge: {custom_badge_color} ");
sb.Append($"fmt: {format} ");
sb.Append($"def: {data.value}");
return sb.ToString();
}
@@ -477,7 +453,6 @@ namespace mbts.spark {
public bool Equals(Snapshot x, Snapshot y) =>
x.abbreviation == y.abbreviation &&
x.custom_badge_color == y.custom_badge_color &&
x.format == y.format &&
x.data.key == y.data.key &&
x.data.name == y.data.name &&
x.data.value.Equals(y.data.value);
@@ -1,7 +1,11 @@
using bts;
using bts.api;
using bts.api.core;
using bts.api.orderman;
using bts.collections;
using bts.utils;
using mbts.collections;
using mbts.spark.utilities;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.utility;
@@ -37,7 +41,6 @@ namespace mbts.spark {
}
class AlgoStudioVM : DisposableViewModelBase {
static readonly AlgoFormats _studio_formats = AlgoFormats.Exchange;
readonly OrdersModel _model;
readonly Property<AlgoDefinitionVM> _selected_definition;
readonly Property<IAlgoVM> _editable_content;
@@ -70,12 +73,24 @@ namespace mbts.spark {
_revert_cmd_tooltip = backing(nameof(revert_cmd_tooltip), get_revert_tooltip);
//
_dispose = new CompositeDisposable(
_model.algo_model.definitions.Subscribe(_definitions_update_buffer),
_definitions_update_buffer.OnDispatcher().Subscribe(u => {
var orig_selected_def = selected_definition;
AlgoCollectionHelper.update_persisted_definitions(_definitions, u, d => AlgoDefinitionVM.create(model, d, _studio_formats));
_model.subscribe_complete_algos(allow_undefined_child: true).OnDispatcher().Subscribe(_definitions_update_buffer),
_definitions_update_buffer.OnDispatcher()
.SubscribeEach(u => {
u.FilterIncremental(a => a.key.is_composite, out var added, out var changes, out var removed);
AlgoCollectionHelper.update_persisted_definitions(
_definitions, added, changes.New(), removed.Select(AlgoData.key_fn), algo => AlgoDefinitionVM.create(_model, algo));
if (selected_definition == null)
selected_definition = definitions.FirstOrDefault();
// Load the algo building blocks (i.e., factory and dynamic algos):
// - Composite algos cannot reference other composite algos - that would create awkward dependency issues as composite algos can be modified/deleted.
// - Spreader algos are filtered out as well, because that don't actually mean anything to the algo structure.
// Synthetic securities in our system are defined by a set of contract legs, and a [single]strategy.
// Note: synthetic strategy templates, however, could be introduced at a later date (no reason why 1 synthetic security couldn't have several ExecutionStrategies).
var algo_building_blocks = new FilteredDictionary<AlgoKey, AlgoData>(
u.state,
a => a.key.mode == AlgoKey.Mode.Dynamic || (a.key.mode == AlgoKey.Mode.Factory && a.key.factory != CustomOrderDefinition.CustomOneofCase.Spreader));
return ObservableAutoWrapper.connect_item_actions(_definitions.AsCollection(),
d => ((IAlgoSelector)d).load_algo_data(algo_building_blocks, null));
}),
_model.algo_model.metadata_service.subscribe_metadata().OnDispatcher().Subscribe(meta => {
_persisted_meta = meta;
@@ -125,7 +140,7 @@ namespace mbts.spark {
}
void add_definition_common(CustomOrderDefinitionImmutable def, string name) {
var new_def = AlgoDefinitionVM.create_placeholder(_model, def, name, _studio_formats);
var new_def = AlgoDefinitionVM.create_placeholder(_model, def, name);
_definitions.Add(new_def);
selected_definition = new_def;
request_view_focus_name?.Invoke(new_def);
@@ -1,214 +0,0 @@
using bts.api;
using bts.api.orderman;
using bts.collections;
using bts.spark;
using mbts.spark.utilities;
using mbts.ui;
using mbts.ui.controls;
using mbts.ui.shell;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Reactive.Disposables;
using System.Reactive.Linq;
using System.Threading.Tasks;
using System.Windows.Input;
namespace mbts.spark {
class AlgoVMWrapper : DisposableViewModelBase, IAlgoVM,
IObserver<SecurityMD?>,
IObserver<SecurityImmutable?>,
IObserver<OrdersModel>,
IObserver<AlgoEditingPermissions> {
static readonly HashSet<string>
_algo_root_echo_props = new HashSet<string> {
nameof(is_expanded),
nameof(editing_permissions),
nameof(definition),
nameof(display_name)
};
static readonly IReadOnlyDictionary<string, string>
_value_echo_props = new Dictionary<string, string> {
{ nameof(AlgoDefinitionVM.name), nameof(display_name) },
{ nameof(AlgoDefinitionVM.abbreviation), nameof(abbreviation) },
{ nameof(AlgoDefinitionVM.badge_fill), nameof(meta) }
};
readonly ObservableAggregateCollection<IAlgoSelector> _child_algo_selectors = new ObservableAggregateCollection<IAlgoSelector>();
readonly ObservableAggregateCollection<IAlgoParamVM> _algo_params = new ObservableAggregateCollection<IAlgoParamVM>();
readonly DisposableContainer _value_hooks = new DisposableContainer();
Action _definition_changed = () => { };
_ObservedData? _data_cache;
AlgoDefinitionVM _value;
public AlgoVMWrapper(AlgoDefinitionVM algo_definition_vm) {
value = algo_definition_vm;
_dispose = new CompositeDisposable(_value_hooks) {
_child_algo_selectors.clear_collections,
_algo_params.clear_collections,
() => _value?.Dispose()
};
}
public event Action definition_changed { add => _definition_changed += value; remove => _definition_changed -= value; }
public AlgoDefinitionVM value {
get => _value;
set {
if (_value != value) {
_value?.Dispose();
_value = value;
_value_hooks.replace(_set_hooks(value));
RaisePropertyChanged(nameof(value));
}
}
}
public AlgoKey id => _value.key;
public CustomOrderDefinition.CustomOneofCase order_type => _algo_root?.order_type ?? CustomOrderDefinition.CustomOneofCase.None;
public OrderMetadata meta {
get {
if (_value != null) {
if (_value.custom_badge_color.enabled)
return new OrderMetadata { Color = value.custom_badge_color.value.rgb_color(), KeyBinding = value.abbreviation.if_null_or_empty(value.name) };
else if (_value.algo_root != null)
return _value.algo_root.meta;
}
return OrderDataHelper.get_metadata(order_type);
}
}
public AlgoEditingPermissions editing_permissions => _value?.editing_permissions ?? AlgoEditingPermissions.None;
public bool can_expand => _algo_root?.can_expand ?? false;
public bool is_expanded {
get => _value.algo_root?.is_expanded ?? false;
set {
if (_value != null)
_value.is_expanded = value;
}
}
public string display_name => _value?.name ?? string.Empty;
public string abbreviation => _value?.abbreviation;
public AlgoDisplayGroup group => _value?.group ?? AlgoDisplayGroup.BTS;
public CustomOrderDefinitionImmutable definition => _algo_root?.definition ?? new CustomOrderDefinitionImmutable(new CustomOrderDefinition());
public ObservableCollection<IAlgoSelector> child_algo_selectors => _child_algo_selectors;
[EditorBrowsable(EditorBrowsableState.Never)]
public ObservableCollection<IAlgoSelector> child_algo_selectors_view {
get {
_value?.algo_root?.ensure_init();
return _child_algo_selectors;
}
}
public IReadOnlyObservableCollection<IAlgoParamVM> algo_params => _algo_params;
[EditorBrowsable(EditorBrowsableState.Never)]
public dynamic children_vm => _algo_root?.children_vm;
IAlgoVM _algo_root => _value?.algo_root;
public void assign_to(CustomOrderDefinition value) => _algo_root?.assign_to(value);
public bool key_match(KeyEventArgs e) => _algo_root?.key_match(e) ?? false;
public void load_from(CustomOrderDefinitionImmutable value) => _algo_root?.load_from(value);
public void load_many(IEnumerable<CustomOrderDefinitionImmutable> values) => _algo_root?.load_many(values);
void IAlgoVM.ensure_init() => _value?.algo_root?.ensure_init();
IDisposable _set_hooks(AlgoDefinitionVM vm) {
var algo_root_subs = new DisposableContainer();
vm.PropertyChanged += on_value_prop_changed;
return new CompositeDisposable(
vm.observe_algo_root().Subscribe(r => {
algo_root_subs.replace(null);
_child_algo_selectors.clear_collections();
_algo_params.clear_collections();
if (r != null) {
if (_data_cache.HasValue) {
_data_cache.Value.forward_to(r);
}
_child_algo_selectors.add_collection(r.child_algo_selectors);
_algo_params.add_collection(r.algo_params);
((INotifyPropertyChanged)r).PropertyChanged += on_algo_root_prop_changed;
algo_root_subs.replace(new CompositeDisposable(
r.subscribe_definition().Subscribe(_ => _definition_changed?.Invoke())) {
() => ((INotifyPropertyChanged)r).PropertyChanged -= on_algo_root_prop_changed
});
}
RaisePropertyChanged(nameof(group));
}),
algo_root_subs) {
() => vm.PropertyChanged -= on_value_prop_changed
};
void on_algo_root_prop_changed(object sender, PropertyChangedEventArgs e) {
if (_algo_root_echo_props.Contains(e.PropertyName))
RaisePropertyChanged(e.PropertyName);
}
void on_value_prop_changed(object sender, PropertyChangedEventArgs e) {
if (_value_echo_props.TryGetValue(e.PropertyName, out string wrapper_prop))
RaisePropertyChanged(wrapper_prop);
}
}
// permissions
void IObserver<AlgoEditingPermissions>.OnNext(AlgoEditingPermissions value) {
_data_cache = _data_cache?.with(value) ?? new _ObservedData(value, default, default, default);
(_algo_root as IObserver<AlgoEditingPermissions>)?.OnNext(value);
}
void IObserver<AlgoEditingPermissions>.OnError(Exception error) { }
void IObserver<AlgoEditingPermissions>.OnCompleted() { }
// model
void IObserver<OrdersModel>.OnNext(OrdersModel value) {
_data_cache = _data_cache?.with(value) ?? new _ObservedData(default, value, default, default);
(_algo_root as IObserver<OrdersModel>)?.OnNext(value);
}
void IObserver<OrdersModel>.OnError(Exception error) { }
void IObserver<OrdersModel>.OnCompleted() { }
// security
void IObserver<SecurityImmutable?>.OnNext(SecurityImmutable? value) {
_data_cache = _data_cache?.with(value) ?? new _ObservedData(default, default, value, default);
(_algo_root as IObserver<SecurityImmutable?>)?.OnNext(value);
}
void IObserver<SecurityImmutable?>.OnError(Exception error) { }
void IObserver<SecurityImmutable?>.OnCompleted() { }
// security md
void IObserver<SecurityMD?>.OnNext(SecurityMD? value) {
_data_cache = _data_cache?.with(value) ?? new _ObservedData(default, default, default, value);
(_algo_root as IObserver<SecurityMD?>)?.OnNext(value);
}
void IObserver<SecurityMD?>.OnError(Exception error) { }
void IObserver<SecurityMD?>.OnCompleted() { }
struct _ObservedData {
public readonly AlgoEditingPermissions permissions;
public readonly OrdersModel model;
public readonly SecurityImmutable? security;
public readonly SecurityMD? security_md;
public _ObservedData(AlgoEditingPermissions permissions, OrdersModel model, SecurityImmutable? security, SecurityMD? security_md) {
this.permissions = permissions;
this.model = model;
this.security = security;
this.security_md = security_md;
}
public void forward_to(IAlgoVM recipient) {
(recipient as IObserver<AlgoEditingPermissions>)?.OnNext(permissions);
if (model != null)
(recipient as IObserver<OrdersModel>)?.OnNext(model);
if (security_md.HasValue)
(recipient as IObserver<SecurityMD?>)?.OnNext(security_md);
if (security.HasValue)
(recipient as IObserver<SecurityImmutable?>)?.OnNext(security);
}
public _ObservedData with(AlgoEditingPermissions? permissions) =>
new _ObservedData(permissions ?? this.permissions, model, security, security_md);
public _ObservedData with(OrdersModel model) =>
new _ObservedData(permissions, model, security, security_md);
public _ObservedData with(SecurityImmutable? security) =>
new _ObservedData(permissions, model, security, security_md);
public _ObservedData with(SecurityMD? security_md) =>
new _ObservedData(permissions, model, security, security_md);
}
}
}
@@ -302,7 +302,7 @@
<!--Double-->
<usp:AlgoParamTemplateSelector.DoubleTemplate>
<DataTemplate>
<TextBlock Text="{Binding param.value, Converter={StaticResource DoubleTextConverter}}"/>
<TextBlock Text="{Binding param.display_value, Converter={StaticResource DoubleTextConverter}}"/>
</DataTemplate>
</usp:AlgoParamTemplateSelector.DoubleTemplate>
<!--Enum-->
@@ -406,7 +406,7 @@
<!--Double-->
<usp:AlgoParamTemplateSelector.DoubleTemplate>
<DataTemplate>
<c:TickUpDownDouble x:Name="tick_up_down" Focusable="False" HorizontalAlignment="Stretch" Value="{Binding param.value, UpdateSourceTrigger=PropertyChanged}" ArrowKeyTickModifiers="Ctrl">
<c:TickUpDownDouble x:Name="tick_up_down" Focusable="False" HorizontalAlignment="Stretch" Value="{Binding param.display_value, UpdateSourceTrigger=PropertyChanged}" ArrowKeyTickModifiers="Ctrl">
<c:TickUpDownDouble.CommandBindings>
<CommandBinding Command="{x:Static u:NavigationHelper.MoveFocusCommand}" Executed="{x:Static u:NavigationHelper.KeyboardMoveFocusExecuted}"/>
</c:TickUpDownDouble.CommandBindings>
@@ -39,31 +39,6 @@ namespace mbts.spark {
}
}
static IDisposable _wrap_rows(AlgoDefinitionVM algo_def, ObservableAggregateCollection<AlgoParamRowVM> rows, bool include_algo_type_rows) {
AlgoParamRowVM root = null;
ObservableAggregateCollection<AlgoParamRowVM> algo_params;
if (include_algo_type_rows) {
// while normal params live and die with the selected algo-type (when the algo-type changes, they are removed, and replaced with params for the new algo type),
// the algo-type row is constant (it is the row with the algo-type dropdown, which the user may use to select different algos).
algo_params = new ObservableAggregateCollection<AlgoParamRowVM>();
rows.add_collection(new ObservableAppendCollection<AlgoParamRowVM>(algo_params, root = new AlgoSelectorParamRowVM(new AlgoVMWrapper(algo_def), algo_def, null)).AsReadOnly());
} else {
algo_params = rows;
}
return algo_def.observe_algo_root().SubscribeEach(a => {
algo_params.clear_collections();
if (a == null)
return Disposable.empty;
var child_rows = new ObservableAggregateCollection<AlgoParamRowVM>();
/// Note: the order of operations here matters
/// <see cref="_wrap_rows(IAlgoVM, AlgoParamRowVM, ObservableAggregateCollection{AlgoParamRowVM}, bool)" /> has the potential to trigger a lot of CollectionChanged events (depending on how deep the algo-tree is).
/// There is no need to burden the aggregate 'rows' with echoing all of these events, if the child-row collection is finished changing when it is added to the aggregate.
var hook = _wrap_rows(a, root, child_rows, include_algo_type_rows);
algo_params.add_collection(child_rows.AsReadOnly());
return hook;
});
}
static IDisposable _wrap_rows(IAlgoVM algo_root, AlgoParamRowVM parent, ObservableAggregateCollection<AlgoParamRowVM> all_rows, bool include_algo_type_rows) {
var wrapped_params = new ObservableAutoWrapper<AlgoParamRowVM, IAlgoParamVM>(algo_root.algo_params, pvm => new AlgoParamRowVM(algo_root, pvm, parent));
var selector_params = new ObservableCollection<AlgoParamRowVM>();
@@ -85,4 +60,4 @@ namespace mbts.spark {
}
}
}
}
}
@@ -106,7 +106,7 @@
</GroupBox.Header>
<ContentControl
Grid.IsSharedSizeScope="True"
Content="{Binding algo_root, Converter={x:Static usp:AlgoContentTemplateSelector.DataContextConverter}}"
Content="{Binding algo_root}"
ContentTemplateSelector="{StaticResource AlgoTemplateSelector}"
Margin="{StaticResource Margin.TP1}"
Visibility="{Binding algo_root.can_expand, Converter={StaticResource BooleanToVisibilityConverter}}"
@@ -6,6 +6,7 @@ using bts.utils;
using mbts.ui;
using mbts.ui.settings;
using mbts.ui.spark;
using mbts.ui.utility.text;
using ProtoBuf;
using System;
using System.Collections.Generic;
@@ -13,6 +14,7 @@ using System.Collections.Immutable;
using System.ComponentModel;
using System.Linq;
using System.Windows;
using System.Windows.Media;
namespace mbts.spark {
// IMPORTANT: BE SURE TO ADD ANY NEW PROPERTIES TO THE EQUALS FUNCTION!
@@ -166,6 +168,10 @@ namespace mbts.spark {
[ProtoContract]
class LadderMarketBreakLine : IEquatable<LadderMarketBreakLine> {
public enum RefreshMode {
Auto,
Manual
}
// this class is 100% mutable (there are literally 0 readonly members),
// so GetHashCode must return the same hash for every instance.
static readonly int _type_hash = typeof(LadderMarketBreakLine).GetHashCode();
@@ -173,6 +179,8 @@ namespace mbts.spark {
public bool show { get; set; }
[ProtoMember(2)]
public uint color { get; set; }
[ProtoMember(3)]
public RefreshMode refresh_mode { get; set; }
public uint? color_nullable {
get {
@@ -185,7 +193,8 @@ namespace mbts.spark {
public bool Equals(LadderMarketBreakLine other) =>
other != null &&
other.show == show &&
other.color == color;
other.color == color &&
other.refresh_mode == refresh_mode;
public override bool Equals(object obj) =>
Equals(obj as LadderMarketBreakLine);
@@ -317,6 +326,123 @@ namespace mbts.spark {
public static bool operator !=(LadderMiniOrderBookSettings a, LadderMiniOrderBookSettings b) => !a.Equals(b);
}
[ProtoContract]
class LadderPanelPricePointSettings : IEquatable<LadderPanelPricePointSettings> {
public static LadderPanelPricePointSettings Default =>
new LadderPanelPricePointSettings {
day_change = new DaySettings {
font = _default_font,
negative_font_color = Colors.Red.rgb_color(),
negative_background_color = Colors.Transparent.rgb_color(),
positive_font_color = Colors.Green.rgb_color(),
positive_background_color = Colors.Transparent.rgb_color()
},
session_low = _default_item,
session_high = _default_item,
open = _default_item,
settlement = _default_item,
volume = _default_item
};
[ProtoMember(1)]
public DaySettings day_change { get; set; }
[ProtoMember(2)]
public ItemSettings session_low { get; set; }
[ProtoMember(3)]
public ItemSettings session_high { get; set; }
[ProtoMember(4)]
public ItemSettings open { get; set; }
[ProtoMember(5)]
public ItemSettings settlement { get; set; }
[ProtoMember(6)]
public ItemSettings volume { get; set; }
public bool Equals(LadderPanelPricePointSettings other) =>
other != null &&
day_change.safe_equals(other.day_change) &&
session_high.safe_equals(other.session_high) &&
session_high.safe_equals(other.session_high) &&
open.safe_equals(other.open) &&
settlement.safe_equals(other.settlement) &&
volume.safe_equals(other.volume);
static FontParamsProto _default_font =>
new FontParamsProto {
font_color = Colors.Black.rgb_color(),
typeface = new TypefaceProto(TextUtils.StandardFontFamilyName, FontWeights.Bold.ToOpenTypeWeight())
};
static ItemSettings _default_item =>
new ItemSettings {
font = _default_font,
background_color = Colors.Transparent.rgb_color(),
show_label = true
};
[ProtoContract]
readonly struct SignedColorPair : IEquatable<SignedColorPair> {
[ProtoMember(1)]
public uint positive_color { get; }
[ProtoMember(2)]
public uint negative_color { get; }
public bool Equals(SignedColorPair other) =>
positive_color == other.positive_color &&
negative_color == other.negative_color;
}
[ProtoContract]
public class ItemSettings : IEquatable<ItemSettings> {
[ProtoMember(1)]
public FontParamsProto font { get; set; }
[ProtoMember(2)]
public uint background_color { get; set; }
[ProtoMember(3)]
public bool show_label { get; set; }
public bool Equals(ItemSettings other) =>
other != null &&
font.safe_equals(other.font) &&
background_color == other.background_color &&
show_label == other.show_label;
}
[ProtoContract]
public class DaySettings : IEquatable<DaySettings> {
[ProtoMember(1)]
public FontParamsProto font { get; set; }
// [neutral] background
[ProtoMember(2)]
public uint background_color { get; set; }
[ProtoMember(3)]
public bool show_label { get; set; }
// negative
[ProtoMember(4)]
public uint negative_font_color { get; set; }
[ProtoMember(5)]
public uint negative_background_color { get; set; }
// positive
[ProtoMember(6)]
public uint positive_font_color { get; set; }
[ProtoMember(7)]
public uint positive_background_color { get; set; }
public uint neutral_foreground => font?.font_color ?? 0;
public bool Equals(DaySettings other) =>
other != null &&
font.safe_equals(other.font) &&
background_color == other.background_color &&
show_label == other.show_label &&
negative_font_color == other.negative_font_color &&
negative_background_color == other.negative_background_color &&
positive_font_color == other.positive_font_color &&
positive_background_color == other.positive_background_color;
}
}
// IMPORTANT: BE SURE TO ADD ANY NEW PROPERTIES TO THE EQUALS FUNCTION!
// 1 important reason at this time:
// From the settings dialog, default settings will only be persisted when they are NOT EQUAL to the current default settings.
@@ -425,6 +551,7 @@ namespace mbts.spark {
auto_clear_visible = true,
clear_visible = true,
order_entry_panel_initial_width = _default_order_entry_panel_width,
panel_price_point_settings = LadderPanelPricePointSettings.Default,
zoom_slider_visible = false,
zoom_factor = _default_zoom_factor,
net_change = NetChangeTerms.None,
@@ -605,6 +732,8 @@ namespace mbts.spark {
[ProtoMember(900)]
public LadderOrderLimits ladder_order_limits { get; set; }
[ProtoMember(901)]
public LadderPanelPricePointSettings panel_price_point_settings { get; set; }
public void sanitize() =>
sanitize(this);
@@ -639,6 +768,8 @@ namespace mbts.spark {
s.mini_ob = new LadderMiniOrderBookSettings(s.mini_ob.value.with(sorting_criterion: bts.shell.orderbook.OrderBookStartupData.default_mini_grid.general.sorting_criterion));
#pragma warning restore CS0612 // Type or member is obsolete
s.row_height = LadderRender.measure_row_height(s);
if (s.panel_price_point_settings is null)
s.panel_price_point_settings = LadderPanelPricePointSettings.Default;
return s;
}
@@ -712,7 +843,8 @@ namespace mbts.spark {
a.max_clip == b.max_clip &&
a.price_display_format == b.price_display_format &&
a.status_message_visible == b.status_message_visible &&
a.ladder_order_limits.safe_equals(b.ladder_order_limits);
a.ladder_order_limits.safe_equals(b.ladder_order_limits) &&
a.panel_price_point_settings.safe_equals(b.panel_price_point_settings);
public bool Equals(LadderSettings other) =>
profile_equals(this, other) &&
@@ -144,7 +144,7 @@ namespace mbts.spark {
string candidate = string.Empty;
if (a.HasValue) {
var algo_name = a.Value.name;
var words = algo_name.Split(delim);
var words = algo_name.Split(delim, StringSplitOptions.RemoveEmptyEntries);
if (words.Length == 1) {
var single_word = words[0];
if (single_word.Length > 1) {
@@ -153,7 +153,7 @@ namespace mbts.spark {
candidate = single_word;
}
} else {
candidate = words.Take(2).Select(w => w.Substring(0, 1)).list_string(string.Empty);
candidate = string.Join(string.Empty, words.Take(2).Select(w => w.Substring(0, 1)));
}
}
return candidate.ToUpper();
@@ -302,7 +302,7 @@ namespace mbts.spark {
var state = new bts.shell.orderbook.OrderBookStartupData(
new bts.shell.orderbook.FilterStates {
security_criteria = new SecurityCriteria(_owner.security),
security_criteria = SecurityCriteria.from_securities(_owner.security),
price = price_filter,
statuses = new[] { OrderStatus.Working },
order_types = AlgoID.exchange_algo_keys
@@ -0,0 +1,112 @@
using bts.proto;
using mbts.ui;
using mbts.ui.shell;
using System.Windows;
using System.Windows.Media;
using mbts.ui.utility.text;
using FontFamily = System.Windows.Media.FontFamily;
namespace mbts.spark {
class LadderPanelPricePointVM : ViewModelBase, IValueFactoryVM<LadderPanelPricePointSettings.ItemSettings> {
Color _background_color = Colors.Transparent, _font_color = Colors.Black;
FontFamily _font_family = TextUtils.StandardFontFamily;
double _font_size = FontSizes.Small;
FontWeight _font_weight = FontWeights.Bold;
bool _show = true, _show_label = true;
public Color background_color { get => _background_color; set => Set(ref _background_color, value); }
public Color font_color { get => _font_color; set => Set(ref _font_color, value); }
public FontFamily font_family { get => _font_family; set => Set(ref _font_family, value); }
public double font_size { get => _font_size; set => Set(ref _font_size, value); }
public FontWeight font_weight { get => _font_weight; set => Set(ref _font_weight, value); }
public bool show {
get => _show;
set {
if (Set(ref _show, value))
RaisePropertyChanged(nameof(actual_show_label));
}
}
public bool show_label {
get => _show_label;
set {
if (Set(ref _show_label, value))
RaisePropertyChanged(nameof(actual_show_label));
}
}
public bool actual_show_label => _show && _show_label;
public LadderPanelPricePointSettings.ItemSettings create() =>
new LadderPanelPricePointSettings.ItemSettings {
font = new FontParamsProto {
font_color = font_color.rgb_color(),
font_size = font_size,
typeface = new TypefaceProto(font_family.name_or_default(), font_weight.ToOpenTypeWeight())
},
background_color = background_color.rgb_color(),
show_label = show_label
};
public void load_from(LadderPanelPricePointSettings.ItemSettings value) {
if (value is null)
return;
load_from(value.font);
show_label = value.show_label;
background_color = value.background_color.argb_color();
}
protected void load_from(FontParamsProto font) {
if (font is null) {
font_weight = FontWeights.Bold;
font_size = FontSizes.Small;
show_label = true;
} else {
font_family = string.IsNullOrEmpty(font.font_family) ?
TextUtils.StandardFontFamily :
new FontFamily(font.font_family);
font_weight = FontWeight.FromOpenTypeWeight(font.font_weight);
font_size = font.font_size;
font_color = font.font_color.argb_color();
}
}
}
class LadderPanelRelativePricePointVM : LadderPanelPricePointVM, IValueFactoryVM<LadderPanelPricePointSettings.DaySettings> {
Color
_negative_font_color = Colors.Red,
_negative_background_color = Colors.Transparent,
_positive_font_color = Colors.Green,
_positive_background_color = Colors.Transparent;
// negative
public Color negative_font_color { get => _negative_font_color; set => Set(ref _negative_font_color, value); }
public Color negative_background_color { get => _negative_background_color; set => Set(ref _negative_background_color, value); }
// positive
public Color positive_font_color { get => _positive_font_color; set => Set(ref _positive_font_color, value); }
public Color positive_background_color { get => _positive_background_color; set => Set(ref _positive_background_color, value); }
public void load_from(LadderPanelPricePointSettings.DaySettings value) {
if (value is null)
return;
load_from(value.font);
show_label = value.show_label;
background_color = value.background_color.argb_color();
negative_font_color = value.negative_font_color.argb_color();
negative_background_color = value.negative_background_color.argb_color();
positive_font_color = value.positive_font_color.argb_color();
positive_background_color = value.positive_background_color.argb_color();
}
public new LadderPanelPricePointSettings.DaySettings create() {
var base_settings = base.create();
return new LadderPanelPricePointSettings.DaySettings {
font = base_settings.font,
show_label = base_settings.show_label,
background_color = base_settings.background_color,
negative_font_color = negative_font_color.rgb_color(),
negative_background_color = negative_background_color.rgb_color(),
positive_font_color = positive_font_color.rgb_color(),
positive_background_color = positive_background_color.rgb_color()
};
}
}
}
@@ -7,6 +7,7 @@ using bts.proto;
using bts.shell.orderbook;
using bts.utils;
using mbts.collections;
using mbts.spark.utilities;
using mbts.ui;
using mbts.ui.controls;
using mbts.ui.controls.color_picker;
@@ -15,6 +16,7 @@ using mbts.ui.spark;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Collections.ObjectModel;
@@ -30,6 +32,10 @@ using TextUtils = mbts.ui.utility.text.TextUtils;
namespace mbts.spark {
class LadderSettingsVM : DisposableViewModelBase, IWindowSettingsVM<LadderSettings>, IValueFactory<LadderSettings>, IObservable<LadderSettings>, ITemplateSelectorKey {
public static Type PanelPricePointType => typeof(PanelPricePointVM);
public static Type PanelRelativePricePointType => typeof(PanelRelativePricePointVM);
public static Type PanelVisibilityType => typeof(OrderEntryPanelItemVisibilityVM);
readonly Property<LadderSettings.BadgeStyle> _badge_style;
readonly Property<uint> _alternate_order_size, _max_clip;
readonly DelegateProperty<double> _row_height;
@@ -60,17 +66,11 @@ namespace mbts.spark {
_bid_mkt_line = new LadderMarketBreakLineVM("Bid"),
_ask_mkt_line = new LadderMarketBreakLineVM("Ask"),
_mid_mkt_line = new LadderMarketBreakLineVM("Mid"),
_session_low_mkt_line = new LadderMarketBreakLineVM("Session Low", 2, 1),
_session_high_mkt_line = new LadderMarketBreakLineVM("Session High", 2, 1, false),
_session_range_fill = new LadderMarketBreakLineVM("Session Range", 0, 0, false);
_session_low_mkt_line = new LadderMarketBreakLineVM("Session Low", 2, 1, can_edit_refresh_mode: false),
_session_high_mkt_line = new LadderMarketBreakLineVM("Session High", 2, 1, false, can_edit_refresh_mode: false),
_session_range_fill = new LadderMarketBreakLineVM("Session Range", 0, 0, false, can_edit_refresh_mode: false);
OrderEntryPanelItemVisibilityVM
_zoom_slider_visbility = new OrderEntryPanelItemVisibilityVM("Zoom Slider"),
_day_visibility = new OrderEntryPanelItemVisibilityVM("Day Change"),
_high_visibility = new OrderEntryPanelItemVisibilityVM("High"),
_low_visibility = new OrderEntryPanelItemVisibilityVM("Low"),
_open_visibility = new OrderEntryPanelItemVisibilityVM("Open"),
_settle_visibility = new OrderEntryPanelItemVisibilityVM("Settle"),
_volume_visibility = new OrderEntryPanelItemVisibilityVM("Volume"),
_account_visibility = new OrderEntryPanelItemVisibilityVM("Account"),
_tif_visibility = new OrderEntryPanelItemVisibilityVM("Time In Force"),
_order_type_visibility = new OrderEntryPanelItemVisibilityVM("Order Type"),
@@ -84,6 +84,14 @@ namespace mbts.spark {
_cancel_sells_visibility = new OrderEntryPanelItemVisibilityVM("Cancel Sells"),
_cancel_all_visibility = new OrderEntryPanelItemVisibilityVM("Cancel All"),
_status_message_visibility = new OrderEntryPanelItemVisibilityVM("Status Message");
PanelRelativePricePointVM
_day_change = new PanelRelativePricePointVM("Day Change");
PanelPricePointVM
_session_high = new PanelPricePointVM("High"),
_session_low = new PanelPricePointVM("Low"),
_open = new PanelPricePointVM("Open"),
_settlement = new PanelPricePointVM("Settle"),
_volume_panel_item = new PanelPricePointVM("Volume");
public LadderSettingsVM(OrdersModel model, SecurityImmutable security) {
_model = model;
@@ -115,7 +123,16 @@ namespace mbts.spark {
foreach (var c in _observable_components)
c.PropertyChanged += on_prop_changed;
favorite_algos_vm.items.CollectionChanged += on_favorite_algo_items_CollectionChanged;
_algo_definitions.AddRange(_model.factory.default_algos(security).Values.Select(algo_factory));
_algo_definitions.AddRange(_model.get_permitted_algos(security).factory_types
.Select(OrderDataHelper.Defaults.CustomOrderDefinitionImmutable)
.Select(AlgoData.from_custom_def)
.Select(algo_factory));
_algo_definitions.AddRange(_model.get_permitted_algos(security).dynamic_types
.Select(dyn_type => new CustomOrderDefinitionImmutable(new CustomOrderDefinition {
Dynamic = _model.dynamic_helper.create_def(dyn_type)
}))
.Select(AlgoData.from_custom_def)
.Select(algo_factory));
_dispose = new CompositeDisposable(
_model.factory.subscribe_accounts().OnDispatcher().Subscribe(acc_map => {
_accounts.SyncWithDictionary(MappedDictionary.create(acc_map, account_factory));
@@ -144,7 +161,7 @@ namespace mbts.spark {
c.PropertyChanged -= on_prop_changed;
}
AccountTuple? account_factory(uint key, string name) => new AccountTuple(key, name);
AlgoDefinitionVM algo_factory(AlgoData data) => AlgoDefinitionVM.create(_model, data, is_synthetic ? AlgoFormats.Spreader : AlgoFormats.Exchange);
AlgoDefinitionVM algo_factory(AlgoData data) => AlgoDefinitionVM.create(_model, data);
}
public event Action result_changed;
@@ -238,15 +255,15 @@ namespace mbts.spark {
}
}
public IEnumerable<OrderEntryPanelItemVisibilityVM> order_entry_panel_items {
public IEnumerable order_entry_panel_items {
get {
yield return _zoom_slider_visbility;
yield return _day_visibility;
yield return _high_visibility;
yield return _low_visibility;
yield return _open_visibility;
yield return _settle_visibility;
yield return _volume_visibility;
yield return _day_change;
yield return _session_high;
yield return _session_low;
yield return _open;
yield return _settlement;
yield return _volume_panel_item;
yield return _account_visibility;
yield return _tif_visibility;
yield return _order_type_visibility;
@@ -285,12 +302,12 @@ namespace mbts.spark {
yield return _session_range_fill;
// left panel
yield return _zoom_slider_visbility;
yield return _day_visibility;
yield return _high_visibility;
yield return _low_visibility;
yield return _open_visibility;
yield return _settle_visibility;
yield return _volume_visibility;
yield return _day_change;
yield return _session_high;
yield return _session_low;
yield return _open;
yield return _settlement;
yield return _volume_panel_item;
yield return _account_visibility;
yield return _tif_visibility;
yield return _order_type_visibility;
@@ -349,12 +366,18 @@ namespace mbts.spark {
zoom_factor = settings.zoom_factor;
// left-panel (show/hide)
_zoom_slider_visbility.show = settings.zoom_slider_visible;
_day_visibility.show = settings.day_visible;
_high_visibility.show = settings.high_visible;
_low_visibility.show = settings.low_visible;
_open_visibility.show = settings.open_visible;
_settle_visibility.show = settings.settle_visible;
_volume_visibility.show = settings.volume_visible;
_day_change.show = settings.day_visible;
_day_change.load_from(settings.panel_price_point_settings.day_change);
_session_high.show = settings.high_visible;
_session_high.load_from(settings.panel_price_point_settings.session_high);
_session_low.show = settings.low_visible;
_session_low.load_from(settings.panel_price_point_settings.session_low);
_open.show = settings.open_visible;
_open.load_from(settings.panel_price_point_settings.open);
_settlement.show = settings.settle_visible;
_settlement.load_from(settings.panel_price_point_settings.settlement);
_volume_panel_item.show = settings.volume_visible;
_volume_panel_item.load_from(settings.panel_price_point_settings.volume);
_account_visibility.show = settings.account_visible;
_tif_visibility.show = settings.tif_visible;
_order_type_visibility.show = settings.order_type_visible;
@@ -416,6 +439,15 @@ namespace mbts.spark {
clone.session_low_line = _session_low_mkt_line.get_settings();
clone.session_high_line = _session_high_mkt_line.get_settings();
clone.session_range_fill = _session_range_fill.get_settings();
// left-panel price items
clone.panel_price_point_settings = new LadderPanelPricePointSettings {
day_change = _day_change.create(),
open = _open.create(),
session_low = _session_low.create(),
session_high = _session_high.create(),
volume = _volume_panel_item.create(),
settlement = _settlement.create(),
};
// left-panel (defaults)
clone.default_time_in_force = default_time_in_force;
// - account
@@ -430,12 +462,12 @@ namespace mbts.spark {
clone.order_entry_panel_initial_width = _order_entry_panel_width;
clone.zoom_factor = zoom_factor;
// left-panel (components)
clone.day_visible = _day_visibility.show;
clone.high_visible = _high_visibility.show;
clone.low_visible = _low_visibility.show;
clone.open_visible = _open_visibility.show;
clone.settle_visible = _settle_visibility.show;
clone.volume_visible = _volume_visibility.show;
clone.day_visible = _day_change.show;
clone.high_visible = _session_high.show;
clone.low_visible = _session_low.show;
clone.open_visible = _open.show;
clone.settle_visible = _settlement.show;
clone.volume_visible = _volume_panel_item.show;
clone.account_visible = _account_visibility.show;
clone.tif_visible = _tif_visibility.show;
clone.order_type_visible = _order_type_visibility.show;
@@ -591,12 +623,14 @@ namespace mbts.spark {
public class LadderMarketBreakLineVM : ViewModelBase {
readonly Property<Color> _color;
readonly Property<bool> _show;
LadderMarketBreakLine.RefreshMode _refresh_mode;
public LadderMarketBreakLineVM(string name, int column_index = 0, int column_span = 5, bool show_session_range = true) {
public LadderMarketBreakLineVM(string name, int column_index = 0, int column_span = 5, bool show_session_range = true, bool can_edit_refresh_mode = true) {
this.name = name;
this.column_index = column_index;
this.column_span = column_span;
this.show_session_range = show_session_range;
this.can_edit_refresh_mode = can_edit_refresh_mode;
palettes = new ObservableCollection<ColorPaletteVM>(ColorPalette.all_presets().Select(p => new ColorPaletteVM(p)));
_color = backing(nameof(color), Colors.Black);
_show = backing(nameof(show), false);
@@ -608,21 +642,25 @@ namespace mbts.spark {
public Color color { get => _color.Value; set => _color.Value = value; }
public bool show { get => _show.Value; set => _show.Value = value; }
public bool show_session_range { get; }
public bool can_edit_refresh_mode { get; }
public LadderMarketBreakLine.RefreshMode refresh_mode { get => _refresh_mode; set => Set(ref _refresh_mode, value); }
public ObservableCollection<ColorPaletteVM> palettes { get; }
public void assign_from(LadderMarketBreakLine settings) {
color = settings.color.rgb_color();
show = settings.show;
refresh_mode = settings.refresh_mode;
}
public LadderMarketBreakLine get_settings() =>
new LadderMarketBreakLine {
color = new BTSColor(color).ToUint(),
show = show
show = show,
refresh_mode = refresh_mode
};
}
public class OrderEntryPanelItemVisibilityVM : ViewModelBase {
public class OrderEntryPanelItemVisibilityVM : ViewModelBase, ITemplateSelectorKey {
readonly Property<bool> _show;
public OrderEntryPanelItemVisibilityVM(string name) {
@@ -633,6 +671,63 @@ namespace mbts.spark {
public string name { get; }
public bool show { get => _show.Value; set => _show.Value = value; }
string ITemplateSelectorKey.key => LadderSettingsPanelTemplateKeys.VisibilityItem;
}
public class PanelPricePointVM : LadderPanelPricePointVM, ITemplateSelectorKey {
ObservableCollection<ColorPaletteVM>
_font_color_palettes,
_background_color_palettes;
public PanelPricePointVM(string name) =>
this.name = name;
public string name { get; }
public ObservableCollection<ColorPaletteVM> font_color_palettes => _font_color_palettes ??
(_font_color_palettes = ColorPalette.all_presets().to_viewmodels());
public ObservableCollection<ColorPaletteVM> background_color_palettes => _background_color_palettes ??
(_background_color_palettes = ColorPalette.all_presets().to_viewmodels());
string ITemplateSelectorKey.key => LadderSettingsPanelTemplateKeys.PricePoint;
}
public class PanelRelativePricePointVM : LadderPanelRelativePricePointVM, ITemplateSelectorKey {
ObservableCollection<ColorPaletteVM>
_negative_font_color_palettes,
_negative_background_color_palettes,
_neutral_font_color_palettes,
_neutral_background_color_palettes,
_positive_font_color_palettes,
_positive_background_color_palettes;
public PanelRelativePricePointVM(string name) =>
this.name = name;
public string name { get; }
//negative
public ObservableCollection<ColorPaletteVM> negative_font_color_palettes => _negative_font_color_palettes ??
(_negative_font_color_palettes = ColorPalette.all_presets().to_viewmodels());
public ObservableCollection<ColorPaletteVM> negative_background_color_palettes => _negative_background_color_palettes ??
(_negative_background_color_palettes = ColorPalette.all_presets().to_viewmodels());
// neutral
public ObservableCollection<ColorPaletteVM> neutral_font_color_palettes => _neutral_font_color_palettes ??
(_neutral_font_color_palettes = ColorPalette.all_presets().to_viewmodels());
public ObservableCollection<ColorPaletteVM> neutral_background_color_palettes => _neutral_background_color_palettes ??
(_neutral_background_color_palettes = ColorPalette.all_presets().to_viewmodels());
// positive
public ObservableCollection<ColorPaletteVM> positive_font_color_palettes => _positive_font_color_palettes ??
(_positive_font_color_palettes = ColorPalette.all_presets().to_viewmodels());
public ObservableCollection<ColorPaletteVM> positive_background_color_palettes => _positive_background_color_palettes ??
(_positive_background_color_palettes = ColorPalette.all_presets().to_viewmodels());
string ITemplateSelectorKey.key => LadderSettingsPanelTemplateKeys.RelativePricePoint;
}
public class VolumeColumnVM : ViewModelBase {
@@ -27,7 +27,7 @@ namespace mbts.spark {
readonly IBus _bus;
readonly LadderModel _model;
readonly Property<double> _high, _low, _change, _open, _settlement, _left_panel_width, _zoom_factor;
readonly Property<double> _high, _low, _day_change, _open, _settlement, _left_panel_width, _zoom_factor;
//readonly Property<double> _window_width, _window_height;
readonly Property<uint> _orders_column_width, _bid_column_width, _price_column_width, _ask_column_width, _last_column_width, _volume_column_width, _piq_column_width;
readonly Property<ulong> _volume;
@@ -73,7 +73,7 @@ namespace mbts.spark {
this.order_properties_vm = order_properties_vm;
_high = backing(nameof(high), double.NaN);
_low = backing(nameof(low), double.NaN);
_change = backing(nameof(change), double.NaN);
_day_change = backing(nameof(day_change), double.NaN);
_open = backing(nameof(open), double.NaN);
_settlement = backing(nameof(settlement), double.NaN);
// init window-specific settings: these properties should not observe settings updates; they are independent from the settings dialog, so it doesn't make sense that the settings dialog should cause them to change.
@@ -108,7 +108,7 @@ namespace mbts.spark {
(_show_high = bool_prop(nameof(show_high), s => s.high_visible)).set,
(_show_low = bool_prop(nameof(show_low), s => s.low_visible)).set,
(_show_open = bool_prop(nameof(show_open), s => s.open_visible)).set,
(_show_settle = bool_prop(nameof(show_settle), s => s.settle_visible)).set,
(_show_settle = bool_prop(nameof(show_settlement), s => s.settle_visible)).set,
(_show_volume = bool_prop(nameof(show_volume), s => s.volume_visible)).set,
(_show_account = bool_prop(nameof(show_account), s => s.account_visible)).set,
(_show_tif = bool_prop(nameof(show_tif), s => s.tif_visible)).set,
@@ -139,8 +139,15 @@ namespace mbts.spark {
_piq_column_width.set(s.piq_column.width);
_volume_column_width.set(s.volume_column.general.width);
// left panel/zoom
day_change_style.load_from(s.panel_price_point_settings.day_change);
open_style.load_from(s.panel_price_point_settings.open);
session_low_style.load_from(s.panel_price_point_settings.session_low);
session_high_style.load_from(s.panel_price_point_settings.session_high);
settlement_style.load_from(s.panel_price_point_settings.settlement);
volume_style.load_from(s.panel_price_point_settings.volume);
_left_panel_width.set(s.order_entry_panel_initial_width);
_zoom_factor.set(s.zoom_factor);
RaisePropertyChanged(nameof(day_change_font_color), nameof(day_change_background_color));
}
};
PropertyAutoWrapper<LadderSettings, bool> bool_prop(string name, Func<LadderSettings, bool> get_bool) =>
@@ -159,6 +166,7 @@ namespace mbts.spark {
settings_command = new DelegateCommand(() => request_settings_dialog?.Invoke());
orders = new ObservableCollection<LadderOrderVM>();
_day_change.Changed += (o, n) => RaisePropertyChanged(nameof(day_change_font_color), nameof(day_change_background_color));
_dispose = Disposable.Create(
settings.OnDispatcher().Subscribe(settings_observer),
@@ -301,15 +309,30 @@ namespace mbts.spark {
public SecurityImmutable security => _model.security;
public uint display_quantity_divisor { get; }
public LadderSettings current_settings { get; private set; }
// left panel values
public double high => _high.Value;
public double low => _low.Value;
public double change => _change.Value;
public double day_change => _day_change.Value;
public double open => _open.Value;
public double settlement => _settlement.Value;
public double position => _position;
public double day_position => _day_position;
public double raw_day_position => _raw_day_position;
public ulong volume => _volume.Value;
// left panel styles
public LadderPanelRelativePricePointVM day_change_style { get; } = new LadderPanelRelativePricePointVM();
public Color day_change_font_color => day_change > 0 ?
day_change_style.positive_font_color :
(day_change < 0 ? day_change_style.negative_font_color : day_change_style.font_color);
public Color day_change_background_color => day_change > 0 ?
day_change_style.positive_background_color :
(day_change < 0 ? day_change_style.negative_background_color : day_change_style.background_color);
public LadderPanelPricePointVM open_style { get; } = new LadderPanelPricePointVM();
public LadderPanelPricePointVM settlement_style { get; } = new LadderPanelPricePointVM();
public LadderPanelPricePointVM session_high_style { get; } = new LadderPanelPricePointVM();
public LadderPanelPricePointVM session_low_style { get; } = new LadderPanelPricePointVM();
public LadderPanelPricePointVM volume_style { get; } = new LadderPanelPricePointVM();
//
public bool auto_clear { get => _auto_clear.Value; set => _auto_clear.set(value); }
public CalculatorLogic size_calculator { get; } = new CalculatorLogic(0);
/// Important: <see cref="order_properties_vm"/> can be null.
@@ -328,7 +351,7 @@ namespace mbts.spark {
public bool show_high => _show_high.view;
public bool show_low => _show_low.view;
public bool show_open => _show_open.view;
public bool show_settle => _show_settle.view;
public bool show_settlement => _show_settle.view;
public bool show_volume => _show_volume.view;
public bool show_account => _show_account.view;
public bool show_tif => _show_tif.view;
@@ -398,7 +421,8 @@ namespace mbts.spark {
public uint last_column_width { get => _last_column_width.Value; set => _last_column_width.set(value); }
public uint piq_column_width { get => _piq_column_width.Value; set => _piq_column_width.set(value); }
public uint volume_column_width { get => _volume_column_width.Value; set => _volume_column_width.set(value); }
public uint alternate_order_size_from_settings => current_settings.alternate_order_size;
public uint actual_alternate_order_size =>
(current_settings?.alternate_order_size ?? 0) * Math.Max(1, display_quantity_divisor);
public bool show_warn_on_cross_from_settings => current_settings.show_warn_on_cross;
public bool enforce_max_clip_from_settings => current_settings.enforce_max_clip;
public uint max_clip_from_settings => current_settings.max_clip;
@@ -446,6 +470,14 @@ namespace mbts.spark {
if (order_properties_vm.selected_algo_definition != null)
rv.default_algo = AlgoID.from_algo_key(order_properties_vm.selected_algo_definition.key);
}
rv.panel_price_point_settings = new LadderPanelPricePointSettings {
day_change = day_change_style.create(),
open = open_style.create(),
settlement = settlement_style.create(),
session_low = session_low_style.create(),
session_high = session_high_style.create(),
volume = volume_style.create()
};
return rv;
}
@@ -489,11 +521,11 @@ namespace mbts.spark {
public Task send_order_async((double price, Side? side, MouseButton button) args) {
if (order_properties_vm != null && args.button != MouseButton.Middle) {
var size_from_alternate = args.button == MouseButton.Right;
if (!DoubleHelper.IsNaNOrInfinity(args.price) && args.side.HasValue && !HasErrors && !order_properties_vm.HasErrors && (!size_from_alternate || current_settings.alternate_order_size > 0)) {
if (!DoubleHelper.IsNaNOrInfinity(args.price) && args.side.HasValue && !HasErrors && !order_properties_vm.HasErrors && (!size_from_alternate || actual_alternate_order_size > 0)) {
if (!size_from_alternate && (!size_calculator.value.HasValue || size_calculator.value.Value == 0)) {
size_calculator.flash_error();
} else {
uint size = size_from_alternate ? current_settings.alternate_order_size : (uint)Math.Abs(size_calculator.value ?? 0);
uint size = size_from_alternate ? actual_alternate_order_size : (uint)Math.Abs(size_calculator.value ?? 0);
// enforce max clip
if (enforce_max_clip_from_settings && size > max_clip_from_settings) {
size = max_clip_from_settings;
@@ -530,7 +562,7 @@ namespace mbts.spark {
if (fav_algo != null) {
if (_favorite_algo_map.TryGetValue(fav_algo.key, out var d)) {
if (!d.flags.HasFlag(LadderFavoriteAlgoFlags.Sticky) && !order_properties_vm.try_pop_selected_algo_definition()) {
var key = new AlgoKey(OrderDataHelper.get_default_algo(OrderDataHelper.get_algo_format(security.ContractCase)));
var key = new AlgoKey(OrderDataHelper.get_default_algo(security.ContractCase));
if (order_properties_vm.try_get_algo_definition(key, out var r)) {
order_properties_vm.selected_algo_definition = r;
}
@@ -566,12 +598,12 @@ namespace mbts.spark {
_open.set(md.open_price);
_settlement.set(md.settlement_price);
if (!double.IsNaN(last.price)) {
_change.set(last.price - md.settlement_price);
_day_change.set(last.price - md.settlement_price);
} else {
ulong unused = 0;
_model.md.get_bbo(ref unused, out NativePriceSize bid, out NativePriceSize ask);
double mid = TickUtils.mid_tick(security.ContractSpec, bid.price, ask.price);
_change.set(mid - md.settlement_price);
_day_change.set(mid - md.settlement_price);
}
_volume.set(volume);
_misc_time = _model.md.misc_timestamp;
@@ -582,7 +614,7 @@ namespace mbts.spark {
void _show_book() {
var ob_settings = bts.shell.orderbook.OrderBookStartupData.Default;
ob_settings.filters = new bts.shell.orderbook.FilterStates {
security_criteria = new SecurityCriteria(security)
security_criteria = SecurityCriteria.from_securities(security)
};
_bus.post(SparkTags.ShowOrderBookTag, ob_settings);
}
@@ -29,6 +29,7 @@ using System.Windows.Media.Animation;
namespace mbts.spark {
partial class LadderGridHost : Control {
const int _min_row_count = 501, _max_row_count = 2001;
static readonly bool _show_scrollbar = config.Configuration.get<bts.config.LadderKnobs>().show_scrollbar;
int _row_count = _min_row_count;
@@ -82,6 +83,8 @@ namespace mbts.spark {
_ordershost = new LadderOrdersHost(this) { HorizontalAlignment = HorizontalAlignment.Left, VerticalAlignment = VerticalAlignment.Stretch };
var scrollViewerFactory = new FrameworkElementFactory(typeof(ScrollViewer));
scrollViewerFactory.SetValue(FocusableProperty, false);
if (!_show_scrollbar)
scrollViewerFactory.SetValue(ScrollViewer.VerticalScrollBarVisibilityProperty, ScrollBarVisibility.Hidden);
Template = new ControlTemplate() {
VisualTree = scrollViewerFactory
};
@@ -353,7 +356,9 @@ namespace mbts.spark {
return;
}
} else if (_vm != null) {
uint size = e.ChangedButton == MouseButton.Right ? _vm.alternate_order_size_from_settings : _vm.size_calculator.value ?? 0;
uint size = e.ChangedButton == MouseButton.Right ?
_vm.actual_alternate_order_size :
_vm.size_calculator.value ?? 0;
// does the size violate the local max clip
if (_vm.enforce_max_clip_from_settings && size > _vm.max_clip_from_settings) {
@@ -711,8 +716,10 @@ namespace mbts.spark {
// with meticulous attention to detail.
_tick_sub = Disposable.Create(() => local_vm.on_tick -= _tick);
_vm_sub = Disposable.Create(() => local_vm.request_recenter -= on_request_recenter);
void on_request_recenter() =>
void on_request_recenter() {
RecenterCommand?.ExecuteIfCan(null);
_refresh_frozen_mkt_lines();
}
}
}
@@ -781,6 +788,14 @@ namespace mbts.spark {
#endregion
void _refresh_frozen_mkt_lines() {
if (_price_list is null)
return;
_mkt_break_lines.refresh_frozen();
_refresh_bid_mkt_break();
_refresh_ask_mkt_break();
_refresh_mid_mkt_break();
}
void _on_vm_disposed(bool obj) =>
_dispose_resources();
@@ -812,6 +827,7 @@ namespace mbts.spark {
} else {
_scroll_to_row(_row_count / 2);
}
_refresh_frozen_mkt_lines();
}
}
@@ -886,13 +902,28 @@ namespace mbts.spark {
}
void _refresh_bid_mkt_break() =>
_render_mkt_break(_bid_mkt_break_vis, _mkt_break_lines.bid, _settings.bid_break_line.color);
_render_mkt_break(
_bid_mkt_break_vis,
_settings.bid_break_line.refresh_mode == LadderMarketBreakLine.RefreshMode.Manual ?
_mkt_break_lines.frozen_bid :
_mkt_break_lines.bid,
_settings.bid_break_line.color);
void _refresh_ask_mkt_break() =>
_render_mkt_break(_ask_mkt_break_vis, _mkt_break_lines.ask, _settings.ask_break_line.color);
_render_mkt_break(
_ask_mkt_break_vis,
_settings.ask_break_line.refresh_mode == LadderMarketBreakLine.RefreshMode.Manual ?
_mkt_break_lines.frozen_ask :
_mkt_break_lines.ask,
_settings.ask_break_line.color);
void _refresh_mid_mkt_break() =>
_render_mkt_break(_mid_mkt_break_vis, _mkt_break_lines.mid, _settings.mid_break_line.color);
_render_mkt_break(
_mid_mkt_break_vis,
_settings.mid_break_line.refresh_mode == LadderMarketBreakLine.RefreshMode.Manual ?
_mkt_break_lines.frozen_mid :
_mkt_break_lines.mid,
_settings.mid_break_line.color);
void _refresh_session_low_line() {
if (_settings.session_low_line.show && _mkt_break_lines.low_render_index.HasValue)
@@ -1168,6 +1199,7 @@ namespace mbts.spark {
}
}
}
_refresh_frozen_mkt_lines();
_visualHost.AddVisualChild(_mid_mkt_break_vis);
_visualHost.AddVisualChild(_ask_mkt_break_vis);
_visualHost.AddVisualChild(_bid_mkt_break_vis);
@@ -1263,7 +1295,8 @@ namespace mbts.spark {
// Note: The values contained here do NOT necessarily represent true data, as they will be NaN/null if their respective visual is hidden in LadderSettings
class MarketBreakLines {
readonly LadderGridHost _owner;
double _bid, _ask, _mid, _origin, _session_low, _session_high;
double _bid = double.NaN, _ask = double.NaN, _mid = double.NaN, _origin, _session_low, _session_high;
double _frozen_bid = double.NaN, _frozen_ask = double.NaN, _frozen_mid = double.NaN, _frozen_origin = double.NaN;
int? _low_index, _high_index;
public MarketBreakLines(LadderGridHost owner) =>
@@ -1277,6 +1310,11 @@ namespace mbts.spark {
public bool session_range_dirty => session_low_dirty || session_high_dirty;
public bool origin_dirty { get; private set; }
public double frozen_bid => double.IsNaN(_frozen_bid) ? (_frozen_bid = _bid) : _frozen_bid;
public double frozen_ask => double.IsNaN(_frozen_ask) ? (_frozen_ask = _ask) : _frozen_ask;
public double frozen_mid => double.IsNaN(_frozen_mid) ? (_frozen_mid = _mid) : _frozen_mid;
public double frozen_origin => double.IsNaN(_frozen_origin) ? (_frozen_origin = _origin) : _frozen_origin;
public double bid => _bid;
public double ask => _ask;
public double mid => _mid;
@@ -1320,7 +1358,14 @@ namespace mbts.spark {
LadderSettings _settings => _owner._settings;
public void refresh_frozen() {
_refresh(true);
}
public void refresh() {
_refresh(false);
}
void _refresh(bool update_frozen) {
bid_dirty = ConvertUtils.update_value_type(ref _bid, _settings.bid_break_line.show ? _owner._get_bid_market_break() : double.NaN);
ask_dirty = ConvertUtils.update_value_type(ref _ask, _settings.ask_break_line.show ? _owner._get_ask_market_break() : double.NaN);
mid_dirty = ConvertUtils.update_value_type(ref _mid, _settings.mid_break_line.show ? _owner._get_mid_market_break() : double.NaN);
@@ -1340,6 +1385,11 @@ namespace mbts.spark {
if (double.IsNaN(new_origin))
new_origin = _owner._get_bid_market_break();
origin_dirty = ConvertUtils.update_value_type(ref _origin, new_origin);
if (update_frozen) {
_frozen_bid = _bid;
_frozen_ask = _ask;
_frozen_mid = _mid;
}
}
}
}
@@ -50,6 +50,18 @@
<cv:KeyValue Key="{u:Int 0}" Value="{u:Visibility Collapsed}"/>
</cv:ValueMap>
<c:BadgeTextLinesConverter x:Key="BadgeTextLinesConverter"/>
<cv:ValueMap x:Key="RefreshModeToBooleanConverter">
<cv:KeyValue Key="{x:Static Manual, MemberType={u:Nested sp:LadderMarketBreakLine.RefreshMode}}">
<cv:KeyValue.Value>
<sys:Boolean>false</sys:Boolean>
</cv:KeyValue.Value>
</cv:KeyValue>
<cv:KeyValue Key="{x:Static Auto, MemberType={u:Nested sp:LadderMarketBreakLine.RefreshMode}}">
<cv:KeyValue.Value>
<sys:Boolean>true</sys:Boolean>
</cv:KeyValue.Value>
</cv:KeyValue>
</cv:ValueMap>
<Style x:Key="ColumnBackground" TargetType="Rectangle">
<Setter Property="Grid.RowSpan" Value="3"/>
@@ -161,6 +173,160 @@
</Setter>
</Style>
<Style x:Key="LeftPanelPriceFontColorPopup" TargetType="c:PopupControl">
<Setter Property="Width" Value="60"/>
<Setter Property="Margin" Value="4,2"/>
<Setter Property="HorizontalAlignment" Value="Left"/>
</Style>
<Style x:Key="LeftPanelPricePopup" TargetType="c:PopupControl">
<Setter Property="Background" Value="{StaticResource ComboBox.Static.Background}"/>
<Setter Property="HorizontalAlignment" Value="Stretch"/>
<Setter Property="Padding" Value="6,2"/>
<Setter Property="PopupContainerStyle">
<Setter.Value>
<Style TargetType="Border" BasedOn="{StaticResource PopupContainerStyleBase}">
<Setter Property="Padding" Value="4"/>
</Style>
</Setter.Value>
</Setter>
<Setter Property="MinHeight" Value="24"/>
<Setter Property="Header" Value="..."/>
<Setter Property="Content" Value="{Binding}"/>
<Setter Property="ShowExpanderArrow" Value="False"/>
<Setter Property="ContentTemplate">
<Setter.Value>
<DataTemplate>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<c:FontPicker
Grid.ColumnSpan="2"
SelectedFontFamily="{Binding font_family}"
SelectedFontSize="{Binding font_size}"
SelectedFontWeight="{Binding font_weight}"
/>
<TextBlock Grid.Row="2" VerticalAlignment="Center" Margin="4,0">Font Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="2"
Grid.Column="1"
Palettes="{Binding font_color_palettes}"
SelectedColor="{Binding font_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="4" VerticalAlignment="Center">Background Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="4"
Grid.Column="1"
Palettes="{Binding background_color_palettes}"
SelectedColor="{Binding background_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<CheckBox Grid.Row="6" IsChecked="{Binding show_label}">Show Label</CheckBox>
</Grid>
</DataTemplate>
</Setter.Value>
</Setter>
</Style>
<Style x:Key="LeftPanelRelativePricePopup" TargetType="c:PopupControl" BasedOn="{StaticResource LeftPanelPricePopup}">
<Setter Property="ContentTemplate">
<Setter.Value>
<DataTemplate>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush}}"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<c:FontPicker
Grid.ColumnSpan="2"
SelectedFontFamily="{Binding font_family}"
SelectedFontSize="{Binding font_size}"
SelectedFontWeight="{Binding font_weight}"
/>
<TextBlock Grid.Row="2" VerticalAlignment="Center">Negative Font Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="2"
Grid.Column="1"
Palettes="{Binding negative_font_color_palettes}"
SelectedColor="{Binding negative_font_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="4" VerticalAlignment="Center">Negative Font Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="4"
Grid.Column="1"
Palettes="{Binding negative_background_color_palettes}"
SelectedColor="{Binding negative_background_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="6" VerticalAlignment="Center">Neutral Font Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="6"
Grid.Column="1"
Palettes="{Binding neutral_font_color_palettes}"
SelectedColor="{Binding neutral_font_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="8" VerticalAlignment="Center">Neutral Background Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="8"
Grid.Column="1"
Palettes="{Binding neutral_background_color_palettes}"
SelectedColor="{Binding neutral_background_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="10" VerticalAlignment="Center">Positive Font Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="10"
Grid.Column="1"
Palettes="{Binding positive_font_color_palettes}"
SelectedColor="{Binding positive_font_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<TextBlock Grid.Row="12" VerticalAlignment="Center">Positive Background Color</TextBlock>
<c:ColorPickerPopup
Grid.Row="12"
Grid.Column="1"
Palettes="{Binding positive_background_color_palettes}"
SelectedColor="{Binding positive_background_color}"
Style="{StaticResource LeftPanelPriceFontColorPopup}"
/>
<CheckBox Grid.Row="14" IsChecked="{Binding show_label}">Show Label</CheckBox>
</Grid>
</DataTemplate>
</Setter.Value>
</Setter>
</Style>
<Style x:Key="LadderColumnSample" TargetType="Border">
<Setter Property="Grid.Column" Value="6"/>
<Setter Property="Background" Value="{Binding background, Converter={StaticResource ColorToBrushConverter}}"/>
@@ -455,6 +621,68 @@
</DataTemplate>
</u:TemplateSelectorKeyValue>
</u:KeyedTemplateSelector>
<u:KeyedTemplateSelector x:Key="OrderEntryPanelItemTemplateSelector">
<u:TemplateSelectorKeyValue Key="{x:Static usp:LadderSettingsPanelTemplateKeys.VisibilityItem}">
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="A"/>
<ColumnDefinition Width="*" SharedSizeGroup="B"/>
</Grid.ColumnDefinitions>
<Border Margin="0,5,5,0">
<CheckBox Content="{Binding name}" FlowDirection="RightToLeft" IsChecked="{Binding show}">
<CheckBox.Resources>
<Style TargetType="{x:Type Path}">
<Setter Property="FlowDirection" Value="LeftToRight" />
</Style>
</CheckBox.Resources>
</CheckBox>
</Border>
</Grid>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="{x:Static usp:LadderSettingsPanelTemplateKeys.PricePoint}">
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="A"/>
<ColumnDefinition Width="*" SharedSizeGroup="B"/>
</Grid.ColumnDefinitions>
<Border Margin="0,5,5,0">
<CheckBox Content="{Binding name}" FlowDirection="RightToLeft" IsChecked="{Binding show}">
<CheckBox.Resources>
<Style TargetType="{x:Type Path}">
<Setter Property="FlowDirection" Value="LeftToRight" />
</Style>
</CheckBox.Resources>
</CheckBox>
</Border>
<c:PopupControl Grid.Column="1" Margin="4,2" Style="{StaticResource LeftPanelPricePopup}"/>
</Grid>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="{x:Static usp:LadderSettingsPanelTemplateKeys.RelativePricePoint}">
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="A"/>
<ColumnDefinition Width="*" SharedSizeGroup="B"/>
</Grid.ColumnDefinitions>
<Border Margin="0,5,5,0">
<CheckBox Content="{Binding name}" FlowDirection="RightToLeft" IsChecked="{Binding show}">
<CheckBox.Resources>
<Style TargetType="{x:Type Path}">
<Setter Property="FlowDirection" Value="LeftToRight" />
</Style>
</CheckBox.Resources>
</CheckBox>
</Border>
<c:PopupControl Grid.Column="1" Margin="4,2" Style="{StaticResource LeftPanelRelativePricePopup}"/>
</Grid>
</DataTemplate>
</u:TemplateSelectorKeyValue>
</u:KeyedTemplateSelector>
</UserControl.Resources>
<TabControl>
<TabControl.ItemContainerStyle>
@@ -525,10 +753,12 @@
<ColumnDefinition SharedSizeGroup="c2"/>
<ColumnDefinition SharedSizeGroup="c3"/>
<ColumnDefinition SharedSizeGroup="c4"/>
<ColumnDefinition SharedSizeGroup="c5"/>
</Grid.ColumnDefinitions>
<TextBlock Grid.Column="1" HorizontalAlignment="Center" Margin="6,0" Text="Show" VerticalAlignment="Center"/>
<TextBlock Grid.Column="2" HorizontalAlignment="Center" Margin="6,0" Text="Color" VerticalAlignment="Center"/>
<TextBlock Grid.Column="3" Grid.ColumnSpan="2" HorizontalAlignment="Center" Margin="6,0" Text="Sample" VerticalAlignment="Center"/>
<TextBlock Grid.Column="2" HorizontalAlignment="Center" Margin="6,0" Text="Auto Refresh" VerticalAlignment="Center"/>
<TextBlock Grid.Column="3" HorizontalAlignment="Center" Margin="6,0" Text="Color" VerticalAlignment="Center"/>
<TextBlock Grid.Column="4" Grid.ColumnSpan="2" HorizontalAlignment="Center" Margin="6,0" Text="Sample" VerticalAlignment="Center"/>
</Grid>
<ItemsControl Grid.Row="1" ItemsSource="{Binding mkt_break_items}" Margin="8,0">
<ItemsControl.ItemTemplate>
@@ -540,20 +770,28 @@
<ColumnDefinition SharedSizeGroup="c2"/>
<ColumnDefinition SharedSizeGroup="c3"/>
<ColumnDefinition SharedSizeGroup="c4"/>
<ColumnDefinition SharedSizeGroup="c5"/>
</Grid.ColumnDefinitions>
<Border Grid.Column="0" Background="{u:BTSColor header}" Padding="6,3">
<TextBlock VerticalAlignment="Center" Text="{Binding name}" Foreground="{u:BTSColor header_text}"/>
</Border>
<CheckBox Grid.Column="1" HorizontalAlignment="Center" VerticalAlignment="Center" IsChecked="{Binding show}"/>
<c:ColorPickerPopup
<CheckBox
Grid.Column="2"
HorizontalAlignment="Center"
VerticalAlignment="Center"
IsChecked="{Binding refresh_mode, Converter={StaticResource RefreshModeToBooleanConverter}, Mode=TwoWay}"
IsEnabled="{Binding can_edit_refresh_mode}"
/>
<c:ColorPickerPopup
Grid.Column="3"
BorderBrush="Transparent"
BorderThickness="0"
PopupPlacement="Left"
Palettes="{Binding palettes}"
SelectedColor="{Binding color}"
/>
<Grid Grid.Column="3" Grid.ColumnSpan="2" Height="27">
<Grid Grid.Column="4" Grid.ColumnSpan="2" Height="27">
<Grid.ColumnDefinitions>
<ColumnDefinition/>
<ColumnDefinition/>
@@ -623,7 +861,7 @@
</Rectangle.Fill>
</Rectangle>
</Grid>
<Rectangle Grid.Column="1" Grid.ColumnSpan="5" Fill="DimGray" Height="1" HorizontalAlignment="Stretch" VerticalAlignment="Bottom"/>
<Rectangle Grid.Column="1" Grid.ColumnSpan="6" Fill="DimGray" Height="1" HorizontalAlignment="Stretch" VerticalAlignment="Bottom"/>
</Grid>
</DataTemplate>
</ItemsControl.ItemTemplate>
@@ -909,27 +1147,23 @@
<TextBlock VerticalAlignment="Center">Left Panel Width</TextBlock>
<Grid Grid.Column="2">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="{Binding Source={StaticResource SliderValueTextWidth}}"/>
<ColumnDefinition Width="Auto"/>
</Grid.ColumnDefinitions>
<Slider Grid.Column="2" Minimum="{x:Static sp:LadderView.MinLeftPanelWidth}" Maximum="{x:Static sp:LadderView.MaxLeftPanelWidth}" Value="{Binding order_entry_panel_width}"/>
<TextBlock Grid.Column="4" VerticalAlignment="Center" Text="{Binding order_entry_panel_width, StringFormat='0.00'}"/>
<Slider Grid.Column="0" Minimum="{x:Static sp:LadderView.MinLeftPanelWidth}" Maximum="{x:Static sp:LadderView.MaxLeftPanelWidth}" Value="{Binding order_entry_panel_width}"/>
<TextBlock Grid.Column="2" VerticalAlignment="Center" Text="{Binding order_entry_panel_width, StringFormat='0.00'}"/>
</Grid>
<!--Zoom Factor-->
<TextBlock Grid.Row="2" VerticalAlignment="Center">Zoom Factor</TextBlock>
<Grid Grid.Row="2" Grid.Column="2">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="*"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="{Binding Source={StaticResource SliderValueTextWidth}}"/>
<ColumnDefinition Width="Auto"/>
</Grid.ColumnDefinitions>
<Slider Grid.Column="2" Minimum="{x:Static sp:LadderView.MinZoomFactor}" Maximum="{x:Static sp:LadderView.MaxZoomFactor}" Value="{Binding zoom_factor}"/>
<TextBlock Grid.Column="4" VerticalAlignment="Center" Text="{Binding zoom_factor, StringFormat='0.00'}"/>
<Slider Grid.Column="0" Minimum="{x:Static sp:LadderView.MinZoomFactor}" Maximum="{x:Static sp:LadderView.MaxZoomFactor}" Value="{Binding zoom_factor}"/>
<TextBlock Grid.Column="2" VerticalAlignment="Center" Text="{Binding zoom_factor, StringFormat='0.00'}"/>
</Grid>
<!--
- Note the 'Delays' in the 'SelectedItem' bindings; this is a workaround for a wpf quirk when the DataContext switches (i.e., when the selected Profile changes in the ShellSettingsDialog).
@@ -944,7 +1178,7 @@
<ComboBox Grid.Row="6" Grid.Column="2" ItemsSource="{Binding time_in_force_options}" SelectedItem="{Binding default_time_in_force, Delay=1}"/>
<!--Algo-->
<TextBlock Grid.Row="8" Grid.Column="0" VerticalAlignment="Center">Algo</TextBlock>
<ComboBox Grid.Row="8" Grid.Column="6" ItemsSource="{Binding Source={StaticResource AlgoDefinitionsViewSource}}" SelectedItem="{Binding default_algo, Delay=1}">
<ComboBox Grid.Row="8" Grid.Column="2" ItemsSource="{Binding Source={StaticResource AlgoDefinitionsViewSource}}" SelectedItem="{Binding default_algo, Delay=1}">
<ComboBox.GroupStyle>
<GroupStyle ContainerStyle="{StaticResource ComboBox.DelineatedGroupContainerStyle}"/>
</ComboBox.GroupStyle>
@@ -966,30 +1200,16 @@
</Grid>
</GroupBox>
<GroupBox Grid.Column="2" Header="Show/Hide" Padding="8,4">
<ItemsControl Grid.IsSharedSizeScope="True" ItemsSource="{Binding order_entry_panel_items}">
<ItemsControl
Grid.IsSharedSizeScope="True"
ItemsSource="{Binding order_entry_panel_items}"
ItemTemplateSelector="{StaticResource OrderEntryPanelItemTemplateSelector}"
>
<ItemsControl.ItemsPanel>
<ItemsPanelTemplate>
<UniformGrid Columns="2" Focusable="False"/>
</ItemsPanelTemplate>
</ItemsControl.ItemsPanel>
<ItemsControl.ItemTemplate>
<DataTemplate>
<Grid>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto" SharedSizeGroup="A" />
</Grid.ColumnDefinitions>
<Border Margin="0,5,5,0">
<CheckBox Content="{Binding name}" FlowDirection="RightToLeft" IsChecked="{Binding show}">
<CheckBox.Resources>
<Style TargetType="{x:Type Path}">
<Setter Property="FlowDirection" Value="LeftToRight" />
</Style>
</CheckBox.Resources>
</CheckBox>
</Border>
</Grid>
</DataTemplate>
</ItemsControl.ItemTemplate>
</ItemsControl>
</GroupBox>
<!--
@@ -37,4 +37,10 @@ namespace mbts.ui.spark {
public static uint GetVolumeComponentValue(DependencyObject d) => (uint)d.GetValue(VolumeComponentValueProperty);
public static void SetVolumeComponentValue(DependencyObject d, uint value) => d.SetValue(VolumeComponentValueProperty, value);
}
class LadderSettingsPanelTemplateKeys {
public static string VisibilityItem = nameof(VisibilityItem);
public static string PricePoint = nameof(PricePoint);
public static string RelativePricePoint = nameof(RelativePricePoint);
}
}
@@ -346,59 +346,101 @@
<ColumnDefinition Width="Auto"/>
</Grid.ColumnDefinitions>
<!-- Day -->
<TextBlock Grid.Column="0" Grid.Row="0"
Text="{Binding left_panel_width, Converter={StaticResource DayTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_day, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="0" FontWeight="Bold"
Margin="0,0,0,4"
Foreground="{Binding change, Converter={StaticResource NumericSignBrushConverter}}"
Visibility="{Binding show_day, Converter={StaticResource BooleanToVisibilityConverter}}">
<TextBlock
Grid.Column="0"
Grid.Row="0"
Text="{Binding left_panel_width, Converter={StaticResource DayTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding day_change_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
/>
<TextBlock
Grid.Column="2"
Grid.Row="0"
Margin="0,0,0,4"
Background="{Binding day_change_background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
FontFamily="{Binding day_change_style.font_family}"
FontSize="{Binding day_change_style.font_size}"
FontWeight="{Binding day_change_style.font_weight}"
Foreground="{Binding day_change_font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Visibility="{Binding show_day_change, Converter={StaticResource BooleanToVisibilityConverter}}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="change"/>
<Binding Path="day_change"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<!-- High -->
<TextBlock Grid.Column="0" Grid.Row="1"
Text="{Binding left_panel_width, Converter={StaticResource HighTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_high, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="1" Foreground="{mbts:BTSColor UI.default_text}" FontWeight="Bold"
Margin="0,0,0,4"
Visibility="{Binding show_high, Converter={StaticResource BooleanToVisibilityConverter}}">
<TextBlock
Grid.Column="0" Grid.Row="1"
Text="{Binding left_panel_width, Converter={StaticResource HighTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding session_high_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
/>
<TextBlock
Grid.Column="2"
Grid.Row="1"
Background="{Binding session_high_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
FontFamily="{Binding session_high_style.font_family}"
FontSize="{Binding session_high_style.font_size}"
FontWeight="{Binding session_high_style.font_weight}"
Foreground="{Binding session_high_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Margin="0,0,0,4"
Visibility="{Binding show_session_high, Converter={StaticResource BooleanToVisibilityConverter}}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="high"/>
<Binding Path="session_high"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<!-- Low -->
<TextBlock Grid.Column="0" Grid.Row="2"
Text="{Binding left_panel_width, Converter={StaticResource LowTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_low, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="2" Foreground="{mbts:BTSColor UI.default_text}" FontWeight="Bold"
Margin="0,0,0,4"
Visibility="{Binding show_low, Converter={StaticResource BooleanToVisibilityConverter}}">
<TextBlock
Grid.Column="0"
Grid.Row="2"
Text="{Binding left_panel_width, Converter={StaticResource LowTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding session_low_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
/>
<TextBlock
Grid.Column="2"
Grid.Row="2"
Background="{Binding session_low_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
FontFamily="{Binding session_low_style.font_family}"
FontSize="{Binding session_low_style.font_size}"
FontWeight="{Binding session_low_style.font_weight}"
Foreground="{Binding session_low_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Margin="0,0,0,4"
Visibility="{Binding show_session_low, Converter={StaticResource BooleanToVisibilityConverter}}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="low"/>
<Binding Path="session_low"/>
<Binding Path="security.ContractSpec"/>
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<!-- Open -->
<TextBlock Grid.Column="0" Grid.Row="3"
Text="{Binding left_panel_width, Converter={StaticResource OpenTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_open, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="3" FontWeight="Bold"
Margin="0,0,0,4"
Visibility="{Binding show_open, Converter={StaticResource BooleanToVisibilityConverter}}">
<TextBlock
Grid.Column="0"
Grid.Row="3"
Text="{Binding left_panel_width, Converter={StaticResource OpenTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding open_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
/>
<TextBlock
Grid.Column="2"
Grid.Row="3"
Background="{Binding open_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
FontFamily="{Binding open_style.font_family}"
FontSize="{Binding open_style.font_size}"
FontWeight="{Binding open_style.font_weight}"
Foreground="{Binding open_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Margin="0,0,0,4"
Visibility="{Binding show_open, Converter={StaticResource BooleanToVisibilityConverter}}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="open"/>
@@ -406,14 +448,25 @@
</MultiBinding>
</TextBlock.Text>
</TextBlock>
<!-- Settle -->
<TextBlock Grid.Column="0" Grid.Row="4"
Text="{Binding left_panel_width, Converter={StaticResource SettleTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_settle, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock Grid.Column="2" Grid.Row="4" FontWeight="Bold"
Margin="0,0,0,4"
Visibility="{Binding show_settle, Converter={StaticResource BooleanToVisibilityConverter}}">
<!-- Settlement -->
<TextBlock
Grid.Column="0"
Grid.Row="4"
Text="{Binding left_panel_width, Converter={StaticResource OpenTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding settlement_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
/>
<TextBlock
Grid.Column="2"
Grid.Row="4"
Margin="0,0,0,4"
Background="{Binding settlement_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
FontFamily="{Binding settlement_style.font_family}"
FontSize="{Binding settlement_style.font_size}"
FontWeight="{Binding settlement_style.font_weight}"
Foreground="{Binding settlement_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Visibility="{Binding show_settlement, Converter={StaticResource BooleanToVisibilityConverter}}"
>
<TextBlock.Text>
<MultiBinding Converter="{StaticResource TickDisplayConverter}" Mode="OneWay">
<Binding Path="settlement"/>
@@ -422,15 +475,22 @@
</TextBlock.Text>
</TextBlock>
<!-- Volume -->
<TextBlock Grid.Column="0" Grid.Row="5"
Text="{Binding left_panel_width, Converter={StaticResource VolumeTextConverter}}"
Margin="0,0,0,4"
Visibility="{Binding show_volume, Converter={StaticResource BooleanToVisibilityConverter}}"/>
<TextBlock
Grid.Column="0"
Grid.Row="5"
Margin="0,0,0,4"
Text="{Binding left_panel_width, Converter={StaticResource VolumeTextConverter}}"
Visibility="{Binding volume_style.actual_show_label, Converter={StaticResource BooleanToVisibilityConverter}}"
/>
<TextBlock
Grid.Column="2"
Grid.Row="5"
FontWeight="Bold"
Margin="0,0,0,4"
Background="{Binding volume_style.background_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
FontFamily="{Binding volume_style.font_family}"
FontSize="{Binding volume_style.font_size}"
FontWeight="{Binding volume_style.font_weight}"
Foreground="{Binding volume_style.font_color, Converter={x:Static converters:ColorToBrushConverter.Instance}}"
Visibility="{Binding show_volume, Converter={StaticResource BooleanToVisibilityConverter}}"
>
<TextBlock.Text>
@@ -26,7 +26,7 @@ namespace bts.shell.manual_fills {
readonly Property<bool> _is_dirty;
readonly Property<EditableItemState> _editable_item_state;
readonly DelegateProperty<bool> _is_valid;
readonly DisplayQuantityMultiplier _size = new DisplayQuantityMultiplier();
readonly DisplayQuantityMultiplier<uint> _size = DisplayQuantityMultiplier.create_uint();
readonly Func<SecurityImmutable?, uint> _get_display_qty_divisor;
SecurityImmutable? _security;
AccountTuple? _account;
@@ -29,7 +29,7 @@ namespace mbts.spark {
int _depth_level;
SecurityImmutable? _security => order_tuple.order.security;
// for mini-ob
DisplayQuantityMultiplier _prospective_qty_translator_backing;
DisplayQuantityMultiplier<uint> _prospective_qty_translator_backing;
uint _display_qty_divisor_backing;
bool _display_qty_divisor_dirty = true;
double _prospective_price;
@@ -239,10 +239,9 @@ namespace mbts.spark {
IDisplayTranslator<uint> _prospective_qty_translator {
get {
if (_prospective_qty_translator_backing == null) {
_prospective_qty_translator_backing = new DisplayQuantityMultiplier {
conversion_data = new QuantityConversionData(_display_qty_divisor, QuantityConversionData.OpType.DivideActual),
actual_value = quantity
};
_prospective_qty_translator_backing = DisplayQuantityMultiplier.create_uint();
_prospective_qty_translator_backing.conversion_data = new QuantityConversionData(_display_qty_divisor, QuantityConversionData.OpType.DivideActual);
_prospective_qty_translator_backing.actual_value = quantity;
_prospective_qty_translator.value_changed += () =>
RaisePropertyChanged(nameof(is_qty_dirty));
} else {
@@ -86,7 +86,7 @@ namespace mbts.spark {
_model = model;
_selected_params_mon = new OrderParamsAggregator(model.dynamic_helper, _selection_change_throttle, k => _cached_orders.TryGetValue(k, out var o) ? o.order : (OrderSecurityAlgo?)null);
ladder_vm = new LadderVMContainer(bus, model);
order_mod_vm = new OrderParamsVM(this, AlgoFormats.Exchange, AlgoEditingPermissions.AllowEditValues);
order_mod_vm = new OrderParamsVM(this, AlgoEditingPermissions.AllowEditValues);
order_mod_vm.algo_vm.editing_permissions_mask = AlgoEditingPermissions.None;
order_mod_vm.algo_vm.algo_root = null;
_show_order_params = backing(nameof(show_order_params), () => (_right_panel.visible_components & OrderBookRightPanelSettings.Components.Params) != 0);
@@ -99,7 +99,7 @@ namespace mbts.spark {
};
_can_attach_selected_orders = backing(nameof(can_attach_selected_orders), () => _attachable_selected_orders.Count == selected_rows.Count && selected_rows.Count > 0);
_can_detach_selected_orders = backing(nameof(can_detach_selected_orders), () => _detachable_selected_orders.Count == selected_rows.Count && selected_rows.Count > 0);
attach_vm = new OrderParamsVM(this, AlgoFormats.Attachable, AlgoEditingPermissions.AllowEditStructure | AlgoEditingPermissions.AllowEditValues);
attach_vm = new OrderParamsVM(this, AlgoEditingPermissions.AllowEditStructure | AlgoEditingPermissions.AllowEditValues);
_settings_manager = settings_manager;
_columns = new OrderBookColumnCollection(bus, model, model.on_order_securities.Select(x => (x.added.Values, x.removed.Values)));
// we use an ObservableAppendCollection b/c the mini-ob needs a cancel column at the front
@@ -244,7 +244,22 @@ namespace mbts.spark {
}),
grid_settings_manager,
order_mod_vm.algo_vm.connect_data(Observable.Return(model)),
order_mod_vm.algo_vm.connect_data(_selected_params_mon.subscribe_spreader_security()),
order_mod_vm.algo_vm.connect_data(
/// This is not the same security source used to populate <see cref="OrderParamsVM.security_md"/>.
/// The latter is always synced with the root of the selected row(s),
/// while this source is synced with that row with one exception:
/// If the root row's algo has a spreader algo (possibly nested),
/// the synthetic security is taken instead of the root security.
/// This has the affect of passing the synthetic security to the spreader algo viewmodel,
/// which then uses the security to populate the synthetic params ui.
/// TODO (maybe): clean this design up; the different security sources make it precarious.
/// One idea is to pass a special data type to the algo vm (which contains the spreader
/// security and execution strategy), which is only observed by the spreader algo vm.
_selected_params_mon.subscribe_security().StartWith((SecurityImmutable?)null).CombineLatest(
_selected_params_mon.subscribe_spreader_security().StartWith((SecurityImmutable?)null),
(root_sec, spreader_sec) => (root_sec, spreader_sec))
.Select(tup => tup.spreader_sec ?? tup.root_sec)
.OnDispatcher()),
order_mod_vm,
attach_vm,
_show_fills.observe_current(true)
@@ -329,32 +344,32 @@ namespace mbts.spark {
}
void on_begin_attaching() {
Disposable.replace(ref attach_vm_hooks,
Disposable.Create(
connect_common_selected_params(attach_vm),
attach_vm.algo_vm.observe_algo_root().Subscribe(algo_root => {
bool show_price, show_size;
if (algo_root == null) {
show_price = false;
show_size = false;
} else {
show_price = AttachConf.show_price(algo_root.order_type);
show_size = AttachConf.show_size(algo_root.order_type);
}
attach_vm.price_permissions = bool_to_perm(show_price);
attach_vm.size_permissions = bool_to_perm(show_size);
AlgoParamPermissions bool_to_perm(bool b) =>
b ? AlgoParamPermissions.ReadWrite : AlgoParamPermissions.None;
}),
// custom templates (created by user)
_model.algo_model.definitions.OnDispatcher().Subscribe(u =>
AlgoCollectionHelper.update_persisted_definition_wrappers(attach_vm.algo_vm.algo_roots_index, u, mk_algo_def_vm))));
// vm factory
AlgoDefinitionVM mk_algo_def_vm(AlgoData fd) {
var vm = AlgoDefinitionVM.create(_model, fd, OrderDataHelper.get_algo_format(_selected_params_mon.security?.ContractCase), AlgoEditingPermissions.AllowEditValues);
vm.selected_format = OrderDataHelper.get_algo_format(_selected_params_mon.security?.ContractCase);
return vm;
}
Disposable.dispose(ref attach_vm_hooks);
attach_vm_hooks = Disposable.Create(
_selected_security_mon.SubscribeThrottled(_selection_change_throttle).to_security_md(bus).OnDispatcher().SubscribeEach(newval => {
attach_vm.security_md = newval;
if (newval.HasValue) {
return _model.subscribe_algos(newval.Value.security, true)
.OnDispatcher()
.Subscribe(t => ((IAlgoSelector)attach_vm.algo_vm).load_algo_data(t.state, null));
}
return null;
}),
connect_common_selected_params(attach_vm),
attach_vm.algo_vm.observe_algo_root().Subscribe(algo_root => {
bool show_price, show_size;
if (algo_root == null) {
show_price = false;
show_size = false;
} else {
show_price = AttachConf.show_price(algo_root.order_type);
show_size = AttachConf.show_size(algo_root.order_type);
}
attach_vm.price_permissions = bool_to_perm(show_price);
attach_vm.size_permissions = bool_to_perm(show_size);
AlgoParamPermissions bool_to_perm(bool b) =>
b ? AlgoParamPermissions.ReadWrite : AlgoParamPermissions.None;
}));
}
void on_end_attaching() => Disposable.dispose(ref attach_vm_hooks);
@@ -365,11 +380,11 @@ namespace mbts.spark {
modify_selected_orders_async_cmd.RaiseCanExecuteChanged();
revert_selected_orders_cmd.RaiseCanExecuteChanged();
}),
_selected_params_mon.subscribe_security().to_security_md(bus).OnDispatcher().Subscribe(newval => order_mod_vm.security_md = newval),
connect_common_selected_params(order_mod_vm));
IDisposable connect_common_selected_params(OrderParamsVM vm) =>
Disposable.Create(
_selected_params_mon.subscribe_security().OnDispatcher().to_security_md(bus).OnDispatcher().Subscribe(newval => vm.security_md = newval),
_selected_params_mon.subscribe_price().OnDispatcher().Subscribe(vm.on_common_price),
_selected_params_mon.subscribe_size().OnDispatcher().Subscribe(vm.on_common_size),
_selected_params_mon.subscribe_account().OnDispatcher().Subscribe(newval => vm.selected_account = newval));
@@ -807,12 +822,11 @@ namespace mbts.spark {
_size_permissions = AlgoParamPermissions.ReadOnly | AlgoParamPermissions.Write;
SecurityMD? _security_md;
public OrderParamsVM(OrderBookVM owner, AlgoFormats init_format, AlgoEditingPermissions init_permissions) {
public OrderParamsVM(OrderBookVM owner, AlgoEditingPermissions init_permissions) {
_owner = owner;
algo_vm = AlgoDefinitionVM.create(
owner._model,
AlgoData.create_unpersisted(OrderDataHelper.Defaults.CustomOrderDefinitionImmutable(CustomOrderDefinition.CustomOneofCase.Iceberg), CustomOrderDefinition.CustomOneofCase.Iceberg.display_name()),
init_format: init_format,
editing_permissions: init_permissions);
_accounts = backing(
nameof(selected_account),
@@ -879,6 +893,7 @@ namespace mbts.spark {
public ReadOnlyObservableCollection<AccountTuple> accounts => _accounts.items;
public AccountTuple? selected_account { get => _accounts.selected_item; set => _accounts.selected_item = value; }
public SecurityImmutable? security => _owner._selected_params_mon.security;
/// <see cref="security_md"/> should be synced with the root of the selected row(s),
public SecurityMD? security_md {
get => _security_md;
set {
@@ -622,9 +622,7 @@ namespace bts.shell.pnl {
static class PNLDataExtensions {
public static string pnl_symbol(this SecurityImmutable security) {
if(security.HasIce)
return PNLICEHelper.get_symbol(security);
return security.Symbol;
return bts.api.ExchangeSpecificUitlities.get_pnl_symbol(security);
}
// while override_cpp could use double.NaN to indicate the lack of an override,
@@ -636,8 +634,8 @@ namespace bts.shell.pnl {
public static (double default_cpp, double? override_cpp) pnl_cpp_tuple(this PNLUnitImmutable pnl_unit, SecurityImmutable security) {
// TODO: actual impl
double calced_pnl = PNLICEHelper.get_cpp(pnl_unit,security);
return (calced_pnl, /*pnl_unit.HasCppOverride ? pnl_unit.CppOverride.Value : */(double?)null);
double calced_pnl = bts.api.ExchangeSpecificUitlities.get_cpp(pnl_unit,security);
return (calced_pnl, pnl_unit.HasCppOverride ? pnl_unit.CppOverride.Value : (double?)null);
}
}
}
@@ -1,77 +0,0 @@
using bts.api;
using bts.api.orderman;
using bts.api.position;
using bts.utils;
using mbts;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
namespace bts.shell.pnl {
static class PNLICEHelper{
public static bool is_spread(SecurityImmutable sec){
return sec.HasSpread && sec.Ice.StripName.Contains("/");
}
public static bool is_strip(SecurityImmutable sec){
return sec.HasSpread && !is_spread(sec);
}
public static bool is_ice_lots(SecurityImmutable sec){
return sec.Ice.MarketDescription.Contains("ICE Lots");
}
public static double get_future_cpp (SecurityImmutable sec){
if(sec.Symbol == "HHD")
return 1;
if(is_ice_lots(sec))
return 2500;
else{
var days_in_month = DateTime.DaysInMonth(Convert.ToInt32(sec.Future.ExpirationYear),
Convert.ToInt32(sec.Future.ExpirationMonth));
return days_in_month; // because the size is multiplied by 2500 already
}
}
public static double get_spread_cpp(SecurityImmutable sec){
return 0;
}
public static double get_strip_cpp(PNLUnitImmutable pnl,
SecurityImmutable sec){
double rv = 0;
foreach (var l in sec.Spread.Legs)
if(l.Security.HasFuture)
rv += get_cpp(pnl,l.Security);
return rv;
}
public static string get_symbol (SecurityImmutable sec){
var rv = String.Format("{0}{1}{2}",
sec.Symbol,
is_ice_lots(sec)? " ICE LOTS" : String.Empty,
is_spread(sec)? " Spread" : String.Empty);
return rv;
}
public static double get_cpp (PNLUnitImmutable pnl,
SecurityImmutable sec){
if(sec.Symbol == "HHD")
Console.WriteLine("yes!");
if (sec.HasGlbx)
return pnl.CashValue;
else if (sec.HasIce){
if(sec.HasFuture)
return get_future_cpp(sec);
else if(is_spread(sec))
return get_spread_cpp(sec);
else if(is_strip(sec))
return get_strip_cpp(pnl,sec);
}
return Double.NaN;
}
}}
@@ -633,7 +633,7 @@ namespace bts.shell.pnl {
case ColumnKeys.Exchange: filter.exchange = new[] { (Venue)group.Name }; break;
case ColumnKeys.Security:
if (group.Name is SecurityImmutable sec)
filter.security = new SecurityCriteria(sec);
filter.security = SecurityCriteria.from_securities(sec);
break;
default: throw new NotImplementedException();
}
@@ -696,7 +696,7 @@ namespace bts.shell.pnl {
case ColumnKeys.Exchange: filter.exchanges = new[] { (Venue)g.Name }; break;
case ColumnKeys.Security:
if (g.Name is SecurityImmutable sec)
filter.security_criteria = new SecurityCriteria(sec);
filter.security_criteria = SecurityCriteria.from_securities(sec);
break;
default: throw new NotImplementedException();
}
@@ -0,0 +1,105 @@
using bts.admin.risk;
using bts.api.core;
using bts.collections;
using mbts;
using mbts.ui;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reactive.Linq;
using Component = bts.shell.risk_management.RiskLimitsImportConflictsView.RiskLimitsComponent;
namespace bts.shell.risk_management {
static class RiskLimitsImporter {
/// <summary>
/// Parses the specified file and passes the results to the <paramref name="on_parsed"/> delegate.
/// If the parser encounters improperly formatted values, a dialog is automatically opened
/// </summary>
/// <returns>An IDisposable that will close the import-conflicts-dialog (if it was launched).</returns>
public static IDisposable import_limits(string file_name, IReadOnlyDictionary<uint, SecurityMD> security_map, IReadOnlyDictionary<uint, string> account_map, Action<IEnumerable<ParsedRiskLimits>> on_parsed) {
if (string.IsNullOrEmpty(file_name))
throw new ArgumentException("File name is null or empty.", nameof(file_name));
if (security_map is null)
throw new ArgumentNullException(nameof(security_map));
if (account_map is null)
throw new ArgumentNullException(nameof(account_map));
if (on_parsed is null)
throw new ArgumentNullException(nameof(on_parsed));
IReadOnlyList<ParsedRiskLimits> parsed_limit_items;
try {
parsed_limit_items = RiskLimitsParser.parse_rows(
File.ReadAllLines(file_name),
MappedDictionary.create(security_map, sec_md => sec_md.security),
account_map)
.ToList();
} catch (Exception ex) {
BTSMessageBox.Error($"Error importing limits: {ex}.", RiskManagementWindow.window_type_display_name);
return null;
}
var conflicts = RiskLimitsParser.get_conflicts(parsed_limit_items);
if (conflicts.Count > 0) {
// init vm
var vm = new RiskLimitsImportVM(parsed_limit_items.Count) {
security_map = security_map
};
// add rows
foreach (var kv in conflicts) {
var resolve_del = RiskLimitsParser.assign_component(kv.Key);
foreach (var text_groups in kv.Value) {
var eval = get_error_value(kv.Key);
var row = new RiskLimitsImportVM.Row(kv.Key, text_groups.Key, text_groups.Value, eval, eval);
vm.rows.Add(row);
vm.import_request += () => {
foreach (var pmf in text_groups.Value) {
if (resolve_del(pmf.result, row.value) is AccountSecurityRiskLimits resolved)
pmf.result = resolved;
}
};
}
}
var win = new RiskLimitsImportConflictsDialog {
DataContext = vm,
Title = RiskManagementWindow.window_type_display_name,
Topmost = true
};
IDisposable dispose = null;
vm.RequestClose += (s, e) => Disposable.dispose(ref dispose);
vm.import_request += () => {
on_parsed(parsed_limit_items);
Disposable.dispose(ref dispose);
};
Disposable.dispose(ref dispose);
vm.accounts.SetItems(account_map.Select(kv => new AccountTuple(kv.Key, kv.Value)).Cast<AccountTuple?>());
dispose = Disposable.Create(
vm,
Disposable.Create(close));
win.move_to_mouse(-200, -75);
win.Show();
return dispose;
void close() => WindowUtilities.force_close(win);
object get_error_value(Component component) {
switch (component) {
case Component.MaxNetLongPosition:
case Component.MaxNetShortPosition:
case Component.ClipLimit:
return 0;
case Component.MinPrice:
case Component.MaxPrice:
return double.NaN;
case Component.IsPositionLimitEnabled:
case Component.IsClipLimitEnabled:
case Component.IsPriceLimitEnabled:
return false;
default: return null;
}
}
} else {
on_parsed(parsed_limit_items);
}
return null;
}
}
}
@@ -0,0 +1,250 @@
using bts.admin.risk;
using bts.api;
using bts.collections;
using bts.utils;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using RiskLimitsComponent = bts.shell.risk_management.RiskLimitsImportConflictsView.RiskLimitsComponent;
namespace bts.shell.risk_management {
class ParsedRiskLimits {
public readonly Guid unpersisted_id = Guid.NewGuid();
public AccountSecurityRiskLimits result { get; set; }
public (string text, bool success) security { get; set; }
public (string text, bool success) account { get; set; }
public (string text, bool success) max_long_position { get; set; }
public (string text, bool success) max_short_position { get; set; }
public (string text, bool success) is_position_limit_enabled { get; set; }
public (string text, bool success) clip_limit { get; set; }
public (string text, bool success) is_clip_limit_enabled { get; set; }
public (string text, bool success) min_price { get; set; }
public (string text, bool success) max_price { get; set; }
public (string text, bool success) is_price_limit_enabled { get; set; }
public bool Equals(ParsedRiskLimits other) => other != null && unpersisted_id == other.unpersisted_id;
public override bool Equals(object obj) => Equals(obj as ParsedRiskLimits);
public override int GetHashCode() => unpersisted_id.GetHashCode();
}
static class RiskLimitsParser {
public const string file_extension = "csv";
public static Func<AccountSecurityRiskLimits, object, object> assign_component(RiskLimitsComponent component) {
switch (component) {
case RiskLimitsComponent.Security: return (mf, val) => mf.with(key: new AccountSecurityKey(mf.account_key, ConvertUtils.try_convert<SecurityImmutable?>(val)?.Id ?? 0));
case RiskLimitsComponent.Account: return (mf, val) => mf.with(key: new AccountSecurityKey(ConvertUtils.try_convert<AccountTuple?>(val)?.id ?? 0, mf.key.security));
case RiskLimitsComponent.MaxNetLongPosition: return (mf, val) => mf.with(mf.limits.with(max_long_position: ConvertUtils.try_convert<uint>(val)));
case RiskLimitsComponent.MaxNetShortPosition: return (mf, val) => mf.with(mf.limits.with(max_short_position: ConvertUtils.try_convert<uint>(val)));
case RiskLimitsComponent.IsPositionLimitEnabled: return (mf, val) => mf.with(mf.limits.with(is_price_limit_enabled: ConvertUtils.try_convert<bool>(val)));
case RiskLimitsComponent.ClipLimit: return (mf, val) => mf.with(mf.limits.with(clip_limit: ConvertUtils.try_convert<uint>(val)));
case RiskLimitsComponent.IsClipLimitEnabled: return (mf, val) => mf.with(mf.limits.with(is_price_limit_enabled: ConvertUtils.try_convert<bool>(val)));
case RiskLimitsComponent.MinPrice: return (mf, val) => mf.with(mf.limits.with(min_price: ConvertUtils.try_convert(val, double.NaN)));
case RiskLimitsComponent.MaxPrice: return (mf, val) => mf.with(mf.limits.with(max_price: ConvertUtils.try_convert(val, double.NaN)));
case RiskLimitsComponent.IsPriceLimitEnabled: return (mf, val) => mf.with(mf.limits.with(is_price_limit_enabled: ConvertUtils.try_convert<bool>(val)));
default: throw new NotImplementedException();
}
}
public static ImmutableDictionary<RiskLimitsComponent, ImmutableDictionary<string, ImmutableList<ParsedRiskLimits>>> get_conflicts(IEnumerable<ParsedRiskLimits> parsed_limits) {
// Add all the components up front (a simple optimizatino since there aren't many),
// so there is no need to check for there existence as various conflicts are added.
// After all conflicts have been added, remove the empty entries.
var missing_components = EnumHelper.get_values<RiskLimitsComponent>()
.ToImmutableDictionary(c => c, c => ImmutableDictionary<string, ImmutableList<ParsedRiskLimits>>.Empty)
.ToBuilder();
foreach (var pmf in parsed_limits) {
if (!pmf.security.success) {
add_missing(RiskLimitsComponent.Security, pmf.security.text, pmf);
}
if (!pmf.account.success) {
add_missing(RiskLimitsComponent.Account, pmf.account.text, pmf);
}
if (!pmf.max_long_position.success) {
add_missing(RiskLimitsComponent.MaxNetLongPosition, pmf.max_long_position.text, pmf);
}
if (!pmf.max_short_position.success) {
add_missing(RiskLimitsComponent.MaxNetShortPosition, pmf.max_short_position.text, pmf);
}
if (!pmf.is_position_limit_enabled.success) {
add_missing(RiskLimitsComponent.IsPositionLimitEnabled, pmf.is_position_limit_enabled.text, pmf);
}
if (!pmf.clip_limit.success) {
add_missing(RiskLimitsComponent.ClipLimit, pmf.clip_limit.text, pmf);
}
if (!pmf.is_clip_limit_enabled.success) {
add_missing(RiskLimitsComponent.IsClipLimitEnabled, pmf.is_clip_limit_enabled.text, pmf);
}
if (!pmf.min_price.success) {
add_missing(RiskLimitsComponent.MinPrice, pmf.min_price.text, pmf);
}
if (!pmf.max_price.success) {
add_missing(RiskLimitsComponent.MaxPrice, pmf.max_price.text, pmf);
}
if (!pmf.is_price_limit_enabled.success) {
add_missing(RiskLimitsComponent.IsPriceLimitEnabled, pmf.is_price_limit_enabled.text, pmf);
}
}
// remove empty component conflicts
var empty_keys = missing_components.Where(kv => kv.Value.Count == 0).Select(kv => kv.Key).ToList();
missing_components.RemoveRange(empty_keys);
return missing_components.ToImmutable();
// local methods
void add_missing(RiskLimitsComponent component, string text, ParsedRiskLimits prl) {
if (!missing_components.TryGetValue(component, out var conflicts)) {
conflicts = ImmutableDictionary<string, ImmutableList<ParsedRiskLimits>>.Empty;
}
if (!conflicts.TryGetValue(text, out var affected)) {
affected = ImmutableList<ParsedRiskLimits>.Empty;
}
missing_components[component] = conflicts.SetItem(text, affected.Add(prl));
}
}
// This implementation prioritizes simplicity over speed.
// The security desc lookup could be better optimized, but the speed at which limits are imported is probably not a paramount concern.
public static IEnumerable<ParsedRiskLimits> parse_rows(IEnumerable<string> rows, IReadOnlyDictionary<uint, SecurityImmutable> security_map, IReadOnlyDictionary<uint, string> account_map) =>
parse_rows(rows,
reverse_lookup(MappedDictionary.create(security_map, s => s.ToString())),
reverse_lookup(account_map));
public static IEnumerable<ParsedRiskLimits> parse_rows(IEnumerable<string> rows, Func<string, uint> security_id_lookup, Func<string, uint> account_id_lookup) {
var columns = new[] {
(Headers.Security, Cells.security(security_id_lookup)),
(Headers.Account, Cells.account(account_id_lookup)),
(Headers.MaxNetLongPosition, Cells.max_long_position),
(Headers.MaxNetShortPosition, Cells.max_short_position),
(Headers.IsPositionLimitEnabled, Cells.is_position_limit_enabled),
(Headers.ClipLimit, Cells.clip_limit),
(Headers.IsClipLimitEnabled, Cells.is_clip_limit_enabled),
(Headers.MinPrice, Cells.min_price),
(Headers.MaxPrice, Cells.max_price),
(Headers.IsPriceLimitEnabled, Cells.is_price_limit_enabled)
}.ToDictionary(col => col.Item1, col => col.Item2.with_null_check());
return RowParser.parse_rows(rows, columns, Cells.delimiter);
}
public static Func<string, TKey> reverse_lookup<TKey>(IReadOnlyDictionary<TKey, string> map) {
var lookup = map.ToLookup(kv => kv.Value, kv => kv.Key);
return cell_text => lookup.Contains(cell_text) ? lookup[cell_text].First() : default;
}
static class Headers {
public const string
Security = "Security",
Account = "Account",
MaxNetLongPosition = "Max Long",
MaxNetShortPosition = "Max Short",
IsPositionLimitEnabled = "Enforce Position",
ClipLimit = "Clip",
IsClipLimitEnabled = "Enforce Clip",
MinPrice = "Min Price",
MaxPrice = "Max Price",
IsPriceLimitEnabled = "Enforce Price";
}
static class Cells {
public const char delimiter = ',';
public static RowParser.AssignColumnValue<ParsedRiskLimits> security(Func<string, uint> reverse_id_lookup) {
return impl;
void impl(ref ParsedRiskLimits pmf, string text) {
pmf.result = pmf.result.with(key: new AccountSecurityKey(pmf.result.key.account, reverse_id_lookup(text)));
pmf.security = (text, pmf.result.key.security != 0);
}
}
public static RowParser.AssignColumnValue<ParsedRiskLimits> account(Func<string, uint> reverse_id_lookup) {
return impl;
void impl(ref ParsedRiskLimits pmf, string text) {
pmf.result = pmf.result.with(key: new AccountSecurityKey(reverse_id_lookup(text), pmf.result.key.security));
pmf.account = (text, pmf.result.key.account != 0);
}
}
public static void max_long_position(ref ParsedRiskLimits pmf, string cell_text) {
if (uint.TryParse(cell_text, out uint v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(max_long_position: v));
pmf.max_long_position = (cell_text, true);
} else {
pmf.max_long_position = (cell_text, false);
}
}
public static void max_short_position(ref ParsedRiskLimits pmf, string cell_text) {
if (uint.TryParse(cell_text, out uint v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(max_short_position: v));
pmf.max_short_position = (cell_text, true);
} else {
pmf.max_short_position = (cell_text, false);
}
}
public static void is_position_limit_enabled(ref ParsedRiskLimits pmf, string cell_text) {
if (_try_parse_yes_no(cell_text, out var result)) {
pmf.result = pmf.result.with(pmf.result.limits.with(is_position_limit_enabled: result));
pmf.is_position_limit_enabled = (cell_text, true);
} else {
pmf.is_position_limit_enabled = (cell_text, false);
}
}
public static void clip_limit(ref ParsedRiskLimits pmf, string cell_text) {
if (uint.TryParse(cell_text, out uint v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(clip_limit: v));
pmf.clip_limit = (cell_text, true);
} else {
pmf.clip_limit = (cell_text, false);
}
}
public static void is_clip_limit_enabled(ref ParsedRiskLimits pmf, string cell_text) {
if (_try_parse_yes_no(cell_text, out var result)) {
pmf.result = pmf.result.with(pmf.result.limits.with(is_clip_limit_enabled: result));
pmf.is_clip_limit_enabled = (cell_text, true);
} else {
pmf.is_clip_limit_enabled = (cell_text, false);
}
}
static bool _try_parse_yes_no(string text, out bool result) {
switch (text?.Trim()?.ToLower()) {
case "y": result = true; break;
case "n": result = false; break;
default: result = default; return false;
}
return true;
}
public static void min_price(ref ParsedRiskLimits pmf, string cell_text) {
if (double.TryParse(cell_text, out var v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(min_price: v));
pmf.min_price = (cell_text, true);
} else {
pmf.min_price = (cell_text, false);
}
}
public static void max_price(ref ParsedRiskLimits pmf, string cell_text) {
if (double.TryParse(cell_text, out var v)) {
pmf.result = pmf.result.with(pmf.result.limits.with(max_price: v));
pmf.max_price = (cell_text, true);
} else {
pmf.max_price = (cell_text, false);
}
}
public static void is_price_limit_enabled(ref ParsedRiskLimits pmf, string cell_text) {
if (_try_parse_yes_no(cell_text, out var result)) {
pmf.result = pmf.result.with(pmf.result.limits.with(is_price_limit_enabled: result));
pmf.is_price_limit_enabled = (cell_text, true);
} else {
pmf.is_price_limit_enabled = (cell_text, false);
}
}
}
}
}
@@ -0,0 +1,230 @@
using bts.admin.risk;
using bts.api;
using bts.collections;
using bts.spark;
using bts.view;
using mbts;
using mbts.persist;
using mbts.spark;
using mbts.ui;
using mbts.ui.settings;
using mbts.ui.spark;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reactive.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
namespace bts.shell.risk_management {
class RiskManagementWindow : SparkWindow<RiskManagementSettings>, ISharedWindow {
public const string
window_type_id = "RiskManagement",
window_type_display_name = "Risk Management";
readonly IWindowSettingsManager<GridSettings> _settings_manager;
readonly AdminModel _model;
FrameworkElement _view;
IReadOnlyList<SparkCommand> _commands;
IDisposable _settings_sub, _securities_sub, _cmd_subscriptions;
RiskManagementSettings _settings;
RiskManagementVM _vm;
SimpleGridSettingsManagerVM<RiskManagementControl.Columns> _grid_settings_manager => _vm.grid_settings_manager;
SparkMenuDisplayVM _menu_display_vm;
IReadOnlyDictionary<uint, SecurityMD> _security_map = DictionaryHelper.empty<uint, SecurityMD>();
public RiskManagementWindow(
IBus bus,
AdminModel model,
IWindowSettingsManager<GridSettings> settings_manager,
ISaveWindow<RiskManagementSettings> isw,
RiskManagementSettings settings)
: base(window_type_display_name, bus, isw, Icons.Risk) {
//
_settings_manager = settings_manager;
_settings = settings;
_model = model;
thread_id = mbts.config.Configuration.get<bts.config.MultiThreadedWindows>().risk_management ? window_type_id : null;
_securities_sub = bus.subscribe(SparkTags.SecuritiesTag).Subscribe(sec_map => _security_map = sec_map);
}
public override IEnumerable<SparkCommand> Commands => _commands;
public override string window_type => window_type_id;
public override RiskManagementSettings SaveState =>
(_vm?.create() ?? RiskManagementSettings.Default).with(menu_display: _menu_display_vm.safe_create());
public override UIElement Content => _view;
public override double MinWidth =>
RiskManagementSettings.DefaultGrid.columns.Where(c => c.is_visible).Sum(gcs => gcs.width)
+ SPARK_MENU_COLLAPSED_WIDTH
+ LAUNCHER_BUTTON_BORDER_WIDTH
+ EXTRA_FOR_NO_HORIZONTAL_SCROLLBAR_WIDTH;
public string thread_id { get; }
public override void Dispose() {
Disposable.dispose(ref _cmd_subscriptions);
_commands.empty_if_null().OfType<IDisposable>().DisposeAll();
Disposable.dispose(ref _securities_sub);
Disposable.dispose(ref _settings_sub);
Disposable.dispose(ref _vm);
}
public void thread_init() {
// assert nothing has been initialized yet
Log.assert(_menu_display_vm == null, "MenuDisplay viewmodel has already been initialized.");
Log.assert(_vm == null, "Viewmodel has already been initialized.");
Log.assert(_settings != null, "Settings is null.");
Log.assert(_settings_sub == null, "Grid settings subscription has already been initialized.");
// initialize everything: menu_display_vm, vm, settings subscription, and view
_menu_display_vm = _init_menu_display_vm(_settings.menu_display);
_vm = _init_vm(_bus.subscribe(SparkTags.SecuritiesTag), _model, _settings);
_settings_sub = _settings_manager.subscribe_current()
.OnDispatcher()
.Subscribe(gs => _vm.load_from(gs));
(_commands, _cmd_subscriptions) = _mk_commands();
_view = new RiskManagementControl { DataContext = _vm };
}
protected override void OnParentViewCreated(SparkWindowView parent_view) =>
_menu_display_vm.safe_bind_to_view(parent_view);
static SparkMenuDisplayVM _init_menu_display_vm(SparkMenuDisplaySettings settings) {
var vm = new SparkMenuDisplayVM();
vm.load_from(settings);
return vm;
}
static RiskManagementVM _init_vm(IObservable<IReadOnlyDictionary<uint, SecurityMD>> securities_source, AdminModel model, RiskManagementSettings settings) {
var vm = new RiskManagementVM(model.account_security_risk_limits, model.on_account_tuples);
vm.request_update_limit += update_limit;
vm.load_from(settings);
var vm_sec_sub = securities_source.OnDispatcher().Subscribe(sec_map => vm.security_map = sec_map);
vm.OnDisposed += _ => Disposable.dispose(ref vm_sec_sub);
return vm;
void update_limit(AccountSecurityRiskLimits lim) {
model.set_risk_limits(
MappedDictionary.create(
vm.build_account_limits_map(), acc_sec_lims => acc_sec_lims.Select(asl => (asl.security_key, asl.limits))))
.ignore();
}
}
(List<SparkCommand> cmds, IDisposable subscriptions) _mk_commands() {
var subs = new List<IDisposable>();
var cmds = new List<SparkCommand>();
cmds.Add(new SparkCommandCommand("Add New Limits", Icons.AddBoxes, new DialogCommand(() => {
if (_vm is null)
return null;
var account_id = _vm.selected_account?.id ?? 0;
var init_state = new RiskLimitsModification(
is_position_limit_enabled: true,
is_clip_limit_enabled: true,
is_price_limit_enabled: true);
return mk_row_editor_dialog(init_state, commit, true);
void commit(RiskLimitsModification result) {
impl();
async void impl() {
var target_secs = await result.security_criteria.securities(_bus, TimeSpan.FromSeconds(5));
if (target_secs.Count > 0) {
var new_limits = result.apply(new RiskLimits());
await _model.add_or_update_risk_limits(account_id, target_secs.Keys.Select(k => (k, new_limits)));
}
}
}
})));
var edit_cmd = new DialogCommand(() => {
if (!(_vm?.selected_account).HasValue)
return null;
var account_id = _vm.selected_account.Value.id;
var targets = _vm.selected_rows.Select(r => r.data).ToList();
var init_state = RiskLimitsModification.aggregate_common_props(targets);
return mk_row_editor_dialog(init_state, commit, false);
void commit(RiskLimitsModification mod) =>
_vm.modify_rows(targets.WrapSelector(t => t.key, null), mod);
}, () => _vm.selected_rows.Count > 0, true, off_x: -300, off_y: -60);
_vm.selected_rows_changed += edit_cmd.RaiseCanExecuteChanged;
cmds.Add(new SparkCommandCommand("Edit Selected Rows", Icons.ModifyOrder, edit_cmd));
var revert_selected_rows_cmd = ObservantCommand.create(() => _vm?.revert(_vm.selected_rows), out var revert_selected_rows_observer);
subs.Add(_vm.subscribe_selected_rows()
.Select(srs => srs.Count > 0)
.And(_vm.subscribe_has_dirty_rows())
.OnDispatcher()
.Subscribe(revert_selected_rows_observer));
cmds.Add(new SparkCommandCommand("Revert Selected Rows", Icons.UndoCircular, revert_selected_rows_cmd));
cmds.Add(new SparkCommandCommand("Import Limits", Icons.Import,
FileDialogCommand.open_file(file => _vm?.import_limits(file), extensions: RiskLimitsParser.file_extension)));
var save_cmd = new SparkCommandCommand("Save", Icons.Disk, ObservantCommand.create(() => {
//_vm.selected_account.Value.id, _vm.rows.Where(r => r.)
var lims = _vm.build_account_limits_map();
var mlims = MappedDictionary.create(lims, l => l.Select(lim => (lim.security_key, lim.limits)));
_model.set_risk_limits(mlims).ignore();
}, out var save_observer));
cmds.Add(save_cmd);
subs.Add(_vm.subscribe_has_dirty_rows().OnDispatcher().Subscribe(save_observer));
var delete_cmd = new DelegateCommand(() => {
if (!(_vm?.selected_account).HasValue)
return;
var to_remove = _vm.selected_rows;
var account_id = _vm.selected_account.Value.id;
if (BTSMessageBox.Confirm($"Are you sure you want to delete the selected limits ({to_remove.Count})?", "Delete Limits")) {
// remove unpersisted limits first (i.e., imports), then delete the persisted ones.
foreach (var r in to_remove) {
if (!r.is_persisted) {
_vm.rows.RemoveSorted(r, _vm.row_comparer);
to_remove = to_remove.Remove(r);
}
}
_model.delete_risk_limits(account_id, to_remove.Select(r => r.security_key)).ignore();
}
}, () => _vm.selected_rows.Count > 0);
_vm.selected_rows_changed += delete_cmd.RaiseCanExecuteChanged;
cmds.Add(new SparkCommandCommand("Delete", Icons.Trash, delete_cmd));
// wrap the grid settings view factory in a dialogCommand here since the vm is destroyed/recreated when the security criteria changes
cmds.Add(SparkCommands.window_settings_command(new DialogCommand(() => {
if (_vm is null)
return null;
_settings_manager.instance_settings = _vm.create().grid;
var settings_vm = new ShellSettingsDialogVM<GridSettings, SimpleGridSettingsVM>(
_settings_manager,
us => us.risk_management_grid,
UserSettings.FileExtensions.GRID,
_grid_settings_manager.create_vm
);
settings_vm.SubscribeDisposed(literal_title_source.OnDispatcher().Subscribe(t => settings_vm.title = t));
var dialog = new ShellSettingsDialog { DataContext = settings_vm };
settings_vm.RequestClose += (s, e) => WindowUtilities.force_close(dialog);
return dialog;
})));
cmds.Add(_menu_display_vm.spark_cmd);
return (cmds, Disposable.wrap_collection(subs));
// although only the api only requires security keys,
// the actual securities are used in this method so the user can see them in the view
Window mk_row_editor_dialog(RiskLimitsModification init_state, Action<RiskLimitsModification> commit, bool is_add) {
var limits_vm = new RiskLimitsModificationVM(is_add) {
security_map = _security_map
};
limits_vm.load_from(init_state);
limits_vm.request_commit += () => commit(limits_vm.create());
var (title, icon) = is_add ? ("New Limits", Icons.AddBoxes) : ("Edit Limits", Icons.ModifyOrder);
var dialog = new RiskLimitParametersDialog {
DataContext = limits_vm,
Icon = icon,
Title = title
};
dialog.SetBinding(ContentControl.ContentProperty, new Binding());
WindowUtilities.listen_for_close_requests(dialog);
return dialog;
}
}
}
}
@@ -0,0 +1,34 @@
using bts.api;
using mbts.persist;
using mbts.spark;
using mbts.ui;
using System;
using System.Reactive.Linq;
using System.Threading.Tasks;
namespace bts.shell.risk_management {
class RiskManagementWindowFactory : ShellWindowFactory<RiskManagementSettings> {
readonly IBus _bus;
readonly AdminModel _model;
readonly UserSettingsHub _settings_hub;
public RiskManagementWindowFactory(IShellModule owner, IBus bus, UserSettingsHub settings_hub, AdminModel model) : base(owner, "RiskManagement") {
_bus = bus;
_model = model;
_settings_hub = settings_hub;
_dispose = bus.subscribe(SparkTags.ShowRiskManagement)
.OnDispatcher()
.Subscribe(show);
async void show(RiskManagementSettings settings) {
var win = await load(settings);
bus.post(SparkTags.ShowWindow, win);
}
}
public override Task<IShellWindow> load(RiskManagementSettings state) =>
state is null ?
throw new ArgumentNullException(nameof(state)) :
Task.FromResult<IShellWindow>(new RiskManagementWindow(_bus, _model, _settings_hub.create_risk_management_settings_manager(state.grid), this, state));
}
}
@@ -0,0 +1,138 @@
using bts.admin.risk;
using bts.utils;
using mbts.spark.filters;
using ProtoBuf;
using System;
using System.Collections.Generic;
using System.Linq;
namespace bts.shell.risk_management {
[ProtoContract]
class RiskManagementFilterSettings : IEquatable<RiskManagementFilterSettings> {
static readonly IEqualityComparer<RiskManagementFilterSettings> _comparer =
ObjectSnapshot.property_equality_comparer<RiskManagementFilterSettings>();
public RiskManagementFilterSettings() { }
public RiskManagementFilterSettings(
string security_regex,
string security_key_regex,
UIntMinMaxState max_long_position,
UIntMinMaxState max_short_position,
bool? is_position_limit_enabled,
UIntMinMaxState clip_limit,
bool? is_clip_limit_enabled,
DoubleMinMaxState min_price,
DoubleMinMaxState max_price,
bool? is_price_limit_enabled) {
// security
this.security_regex = security_regex;
this.security_key_regex = security_key_regex;
// position
this.max_long_position = max_long_position;
this.max_short_position = max_short_position;
this.is_position_limit_enabled = is_position_limit_enabled;
// clip
this.clip_limit = clip_limit;
this.is_clip_limit_enabled = is_clip_limit_enabled;
// price
this.min_price = min_price;
this.max_price = max_price;
this.is_price_limit_enabled = is_price_limit_enabled;
}
// security
[ProtoMember(1)]
public string security_regex { get; }
[ProtoMember(2)]
public string security_key_regex { get; }
// position
[ProtoMember(3)]
public UIntMinMaxState max_long_position { get; }
[ProtoMember(4)]
public UIntMinMaxState max_short_position { get; }
[ProtoMember(5)]
public bool? is_position_limit_enabled { get; }
// clip
[ProtoMember(6)]
public UIntMinMaxState clip_limit { get; }
[ProtoMember(7)]
public bool? is_clip_limit_enabled { get; }
// price
[ProtoMember(8)]
public DoubleMinMaxState min_price { get; }
[ProtoMember(9)]
public DoubleMinMaxState max_price { get; }
[ProtoMember(10)]
public bool? is_price_limit_enabled { get; }
// 'is limit enabled' items (for filter dropdown)
public bool[] is_position_limit_enabled_items => yes_no_filter_items(is_position_limit_enabled);
public bool[] is_clip_limit_enabled_items => yes_no_filter_items(is_clip_limit_enabled);
public bool[] is_price_limit_enabled_items => yes_no_filter_items(is_price_limit_enabled);
public static bool[] yes_no_filter_items(bool? state) =>
state.HasValue ? new[] { state.Value } : Array.Empty<bool>();
public static bool? yes_no_filter_state(IEnumerable<bool> selected_items) {
var set = new HashSet<bool>(selected_items);
return set.Count == 1 ? set.First() : (bool?)null;
}
public Func<AccountSecurityRiskLimits, bool> build_predicate() {
var pb = new ColumnPredicateBuilder<AccountSecurityRiskLimits>();
// security
pb.add_regex(security_regex, l => l.security.ToString());
pb.add_regex(security_key_regex, l => l.security_key.ToString());
// position
pb.add_numeric(max_long_position, l => l.limits.max_long_position);
pb.add_numeric(max_short_position, l => l.limits.max_short_position);
pb.add_discrete_values(is_position_limit_enabled_items, l => l.limits.is_position_limit_enabled);
// clip
pb.add_numeric(clip_limit, l => l.limits.clip_limit);
pb.add_discrete_values(is_clip_limit_enabled_items, l => l.limits.is_clip_limit_enabled);
// price
pb.add_numeric(min_price, l => l.limits.min_price);
pb.add_numeric(max_price, l => l.limits.max_price);
pb.add_discrete_values(is_price_limit_enabled_items, l => l.limits.is_price_limit_enabled);
return pb.to_predicate();
}
public RiskManagementFilterSettings with(
string security_regex = null,
string security_key_regex = null,
UIntMinMaxState max_long_position = null,
UIntMinMaxState max_short_position = null,
OptionalNullable<bool>? is_position_limit_enabled = null,
UIntMinMaxState clip_limit = null,
OptionalNullable<bool>? is_clip_limit_enabled = null,
DoubleMinMaxState min_price = null,
DoubleMinMaxState max_price = null,
OptionalNullable<bool>? is_price_limit_enabled = null) =>
//
new RiskManagementFilterSettings(
// security
security_regex ?? this.security_regex,
security_key_regex ?? this.security_key_regex,
// position
max_long_position ?? this.max_long_position,
max_short_position ?? this.max_short_position,
is_position_limit_enabled.HasValue ? is_position_limit_enabled.Value.value : this.is_position_limit_enabled,
// clip
clip_limit ?? this.clip_limit,
is_clip_limit_enabled.HasValue ? is_clip_limit_enabled.Value.value : this.is_clip_limit_enabled,
// price
min_price ?? this.min_price,
max_price ?? this.max_price,
is_price_limit_enabled.HasValue ? is_price_limit_enabled.Value.value : this.is_price_limit_enabled);
public bool Equals(RiskManagementFilterSettings other) =>
_comparer.Equals(this, other);
public override bool Equals(object obj) =>
obj is RiskManagementFilterSettings other && Equals(other);
public override int GetHashCode() =>
_comparer.GetHashCode(this);
}
}
@@ -0,0 +1,93 @@
using mbts.ui;
using mbts.ui.settings;
using ProtoBuf;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows;
using Columns = bts.shell.risk_management.RiskManagementControl.Columns;
using ColumnWidths = mbts.ui.controls.DIYGrid.DefaultColumnWidths;
using ColumnHeaders = mbts.ui.controls.DIYGrid.DefaultColumnHeaders;
namespace bts.shell.risk_management {
[ProtoContract]
class RiskManagementSettings {
[ProtoMember(3)]
SortingCriteria[] _sorting_criteria;
public RiskManagementSettings() { }
public RiskManagementSettings(
GridSettings grid = null,
RiskManagementFilterSettings filters = default,
IEnumerable<SortingCriteria> sorting_criteria = null,
uint account_id = 0,
SparkMenuDisplaySettings? menu_display = null) {
//
this.grid = grid;
this.filters = filters ?? new RiskManagementFilterSettings();
_sorting_criteria = sorting_criteria?.ToArray();
this.account_id = account_id;
this.menu_display = menu_display ?? SparkMenuDisplaySettings.Default;
}
public static RiskManagementSettings Default => new RiskManagementSettings(grid: DefaultGrid);
public static GridSettings DefaultGrid => new GridSettings(columns: DefaultColumns.all);
[ProtoMember(1)]
public GridSettings grid { get; }
[ProtoMember(2)]
public RiskManagementFilterSettings filters { get; }
[ProtoMember(4)]
public uint account_id { get; }
[ProtoMember(5)]
public SparkMenuDisplaySettings menu_display { get; }
public IReadOnlyList<SortingCriteria> sorting_criteria =>
_sorting_criteria ?? Array.Empty<SortingCriteria>();
public RiskManagementSettings with(
GridSettings grid = null,
RiskManagementFilterSettings filters = default,
IEnumerable<SortingCriteria> sorting_criteria = null,
uint? account_id = null,
SparkMenuDisplaySettings? menu_display = null) =>
//
new RiskManagementSettings(
grid ?? this.grid,
filters ?? this.filters,
sorting_criteria ?? this.sorting_criteria,
account_id ?? this.account_id,
menu_display ?? this.menu_display);
public static class DefaultColumns {
public static GridColumnSettings security => new GridColumnSettings(Columns.Security.ToString(), ColumnHeaders.Security, width: ColumnWidths.SecurityKey);
public static GridColumnSettings security_key => new GridColumnSettings(Columns.SecurityKey.ToString(), ColumnHeaders.SecurityKey, width: ColumnWidths.SecurityKey, is_visible: false);
// position
public static GridColumnSettings max_long => new GridColumnSettings(Columns.MaxNetLongPosition.ToString(), "Max Long", width: 60, horizontal_alignment: HorizontalAlignment.Right);
public static GridColumnSettings max_short => new GridColumnSettings(Columns.MaxNetShortPosition.ToString(), "Max Short", width: 60, horizontal_alignment: HorizontalAlignment.Right);
public static GridColumnSettings is_position_limit_enabled => new GridColumnSettings(Columns.IsPositionLimitEnabled.ToString(), "Enforce Pos", width: 70, horizontal_alignment: HorizontalAlignment.Center);
// clip
public static GridColumnSettings clip_limit => new GridColumnSettings(Columns.ClipLimit.ToString(), "Clip Limit", horizontal_alignment: HorizontalAlignment.Right);
public static GridColumnSettings is_clip_limit_enabled => new GridColumnSettings(Columns.IsClipLimitEnabled.ToString(), "Enforce Clip", width: 70, horizontal_alignment: HorizontalAlignment.Center);
// price
public static GridColumnSettings min_price => new GridColumnSettings(Columns.MinPrice.ToString(), "Min Price", horizontal_alignment: HorizontalAlignment.Right);
public static GridColumnSettings max_price => new GridColumnSettings(Columns.MaxPrice.ToString(), "Max Price", horizontal_alignment: HorizontalAlignment.Right);
public static GridColumnSettings is_price_limit_enabled => new GridColumnSettings(Columns.IsPriceLimitEnabled.ToString(), "Enforce Price", width: 75, horizontal_alignment: HorizontalAlignment.Center);
public static IEnumerable<GridColumnSettings> all {
get {
yield return security;
yield return max_long;
yield return max_short;
yield return is_position_limit_enabled;
yield return clip_limit;
yield return is_clip_limit_enabled;
yield return min_price;
yield return max_price;
yield return is_price_limit_enabled;
yield return security_key;
}
}
}
}
}
@@ -0,0 +1,105 @@
using bts.api;
using bts.collections;
using mbts;
using mbts.collections;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Data;
using System.Windows.Input;
using Component = bts.shell.risk_management.RiskLimitsImportConflictsView.RiskLimitsComponent;
namespace bts.shell.risk_management {
class RiskLimitsImportVM : DisposableViewModelBase, IRequestViewClose {
readonly RefCountMap<ParsedRiskLimits> _conflicts = new RefCountMap<ParsedRiskLimits>();
IReadOnlyDictionary<uint, SecurityMD> _security_map = DictionaryHelper.empty<uint, SecurityMD>();
public RiskLimitsImportVM(int num_limits) {
rows_view = CollectionViewSource.GetDefaultView(rows);
ok_cmd = new DelegateCommand(() => import_request?.Invoke());
cancel_cmd = new DelegateCommand(() => RequestClose?.Invoke(this, new EventArgs()));
this.num_limits = num_limits;
_dispose = ObservableAutoWrapper.connect_item_hooks(rows, r =>
r.subscribe_has_error().Subscribe(has_error => {
if (has_error) {
if (r.affected_limits.Count(_conflicts.increment_adds_key) == 0)
return;
} else if (r.affected_limits.Count(_conflicts.decrement_removes_key) == 0)
return;
RaisePropertyChanged(nameof(num_successfully_parsed_limits));
}));
}
public event Action import_request;
public event EventHandler RequestClose;
public ObservableCollection<Row> rows { get; } = new ObservableCollection<Row>();
public ICollectionView rows_view { get; }
public int num_limits { get; }
public int num_successfully_parsed_limits => num_limits - _conflicts.Count;
// misc items sources
public IEnumerable<Side> sides => new[] { Side.Buy, Side.Sell };
public ObservableCollection<AccountTuple?> accounts { get; } = new ObservableCollection<AccountTuple?>();
public IReadOnlyDictionary<uint, SecurityMD> security_map {
get => _security_map;
set {
if (!ReferenceEquals(_security_map, value)) {
_security_map = value;
_resolve_securities();
RaisePropertyChanged();
}
}
}
// commands
public ICommand ok_cmd { get; }
public ICommand cancel_cmd { get; }
void _resolve_securities() {
if (_security_map == null)
return;
var reverse_lookup = RiskLimitsParser.reverse_lookup(MappedDictionary.create(_security_map, v => v.security.ToString()));
foreach (var r in rows) {
if (r.component == Component.Security && r.has_error) {
var id = reverse_lookup(r.text);
if (id != 0 && _security_map.TryGetValue(id, out var smd))
r.value = smd.security;
}
}
}
public class Row : ViewModelBase, ITemplateSelectorKey {
readonly DelegateProperty<bool> _has_error;
object _value;
string _text;
public Row(Component component, string text, IReadOnlyCollection<ParsedRiskLimits> affected_limits, object error_value, object value) {
this.component = component;
this.text = text;
this.affected_limits = affected_limits;
_value = value;
_has_error = backing(nameof(has_error), () => Equals(this.value, error_value));
}
public Component component { get; }
public string text { get => _text; set => Set(ref _text, value); }
public IReadOnlyCollection<ParsedRiskLimits> affected_limits { get; }
public object value {
get => _value;
set {
if (Set(ref _value, value))
_has_error.refresh();
}
}
public bool has_error => _has_error.Value;
string ITemplateSelectorKey.key => component.ToString();
public IObservable<bool> subscribe_has_error() => _has_error.observe_current(true);
}
}
}
@@ -0,0 +1,201 @@
using bts.admin.risk;
using bts.api;
using bts.utils;
using mbts;
using mbts.spark;
using mbts.ui;
using mbts.ui.shell;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Windows.Input;
namespace bts.shell.risk_management {
class RiskLimitsModificationVM : ViewModelBase, IValueFactory<RiskLimitsModification>, IRequestViewClose {
readonly DeferrableActionWrapper _result_changed;
RiskLimitsModification _modifications;
IReadOnlyDictionary<uint, SecurityMD> _security_map = DictionaryHelper.empty<uint, SecurityMD>();
public RiskLimitsModificationVM(bool can_edit_security) {
_result_changed = new DeferrableActionWrapper(() => result_changed?.Invoke());
this.can_edit_security = can_edit_security;
commit_cmd = new DelegateCommand(commit);
cancel_cmd = new DelegateCommand(close);
//
void commit() {
request_commit?.Invoke();
close();
}
void close() =>
RequestClose?.Invoke(this, EventArgs.Empty);
}
public event Action result_changed, request_commit;
public event EventHandler RequestClose;
public SecurityImmutable? security { get => _modifications.security; set => _set_limits(_modifications.with(security: value)); }
public SecurityCriteria security_criteria {
get => _modifications.security_criteria ?? (security.HasValue ? SecurityCriteria.from_securities(security.Value) : null);
set => _set_limits(_modifications.with(security_criteria: value));
}
public IReadOnlyDictionary<uint, SecurityMD> security_map {
get => _security_map;
set {
_security_map = value;
RaisePropertyChanged();
}
}
public bool can_edit_security { get; }
// position
public uint? max_long_position { get => _modifications.max_long_position; set => _set_limits(_modifications.with(max_long_position: value)); }
public uint? max_short_position { get => _modifications.max_short_position; set => _set_limits(_modifications.with(max_short_position: value)); }
public bool? is_position_limit_enabled { get => _modifications.is_position_limit_enabled; set => _set_limits(_modifications.with(is_position_limit_enabled: value)); }
// clip
public bool? is_clip_limit_enabled { get => _modifications.is_clip_limit_enabled; set => _set_limits(_modifications.with(is_clip_limit_enabled: value)); }
public uint? clip_limit { get => _modifications.clip_limit; set => _set_limits(_modifications.with(clip_limit: value)); }
// price
public double? max_price { get => _modifications.max_price; set => _set_limits(_modifications.with(max_price: value)); }
public double? min_price { get => _modifications.min_price; set => _set_limits(_modifications.with(min_price: value)); }
public bool? is_price_limit_enabled { get => _modifications.is_price_limit_enabled; set => _set_limits(_modifications.with(is_price_limit_enabled: value)); }
public ICommand commit_cmd { get; }
public ICommand cancel_cmd { get; }
public RiskLimitsModification create() =>
_modifications;
public void load_from(RiskLimitsModification value) {
using (_result_changed.defer_execution())
using (detect_property_changes())
_modifications = value;
}
void _set_limits(RiskLimitsModification new_modifications, [CallerMemberName] string prop = "") =>
_set_limits(new_modifications, new[] { prop });
void _set_limits(RiskLimitsModification new_modifications, params string[] invalidate_props) {
if (!_modifications.Equals(new_modifications)) {
_modifications = new_modifications;
RaisePropertyChanged(invalidate_props);
_result_changed.execute();
}
}
}
readonly struct RiskLimitsModification {
public RiskLimitsModification(
SecurityImmutable? security = null,
SecurityCriteria security_criteria = null,
AccountTuple? account = null,
uint? max_long_position = null,
uint? max_short_position = null,
bool? is_position_limit_enabled = null,
uint? clip_limit = null,
bool? is_clip_limit_enabled = null,
double? min_price = null,
double? max_price = null,
bool? is_price_limit_enabled = null) {
//
this.security = security;
this.security_criteria = security_criteria;
this.account = account;
this.max_long_position = max_long_position;
this.max_short_position = max_short_position;
this.is_position_limit_enabled = is_position_limit_enabled;
this.clip_limit = clip_limit;
this.is_clip_limit_enabled = is_clip_limit_enabled;
this.min_price = min_price;
this.max_price = max_price;
this.is_price_limit_enabled = is_price_limit_enabled;
}
public SecurityImmutable? security { get; }
public SecurityCriteria security_criteria { get; }
public AccountTuple? account { get; }
// position
public uint? max_long_position { get; }
public uint? max_short_position { get; }
public bool? is_position_limit_enabled { get; }
// clip
public uint? clip_limit { get; }
public bool? is_clip_limit_enabled { get; }
// price
public double? min_price { get; }
public double? max_price { get; }
public bool? is_price_limit_enabled { get; }
public static RiskLimitsModification aggregate_common_props(IEnumerable<AccountSecurityRiskLimits> limit_items) =>
new RiskLimitsModification(
_common_value(limit_items, l => l.security, s => s),
null,
_common_value(limit_items, l => new AccountTuple(l.account_key, l.account_name)),
_common_value(limit_items, l => l.limits.max_long_position),
_common_value(limit_items, l => l.limits.max_short_position),
_common_value(limit_items, l => l.limits.is_position_limit_enabled),
_common_value(limit_items, l => l.limits.clip_limit),
_common_value(limit_items, l => l.limits.is_clip_limit_enabled),
_common_value(limit_items, l => l.limits.min_price),
_common_value(limit_items, l => l.limits.max_price),
_common_value(limit_items, l => l.limits.is_price_limit_enabled));
public RiskLimits apply(RiskLimits target) =>
new RiskLimits(
is_position_limit_enabled: is_position_limit_enabled ?? target.is_position_limit_enabled,
max_long_position: max_long_position ?? target.max_long_position,
max_short_position: max_short_position ?? target.max_short_position,
is_clip_limit_enabled: is_clip_limit_enabled ?? target.is_clip_limit_enabled,
clip_limit: clip_limit ?? target.clip_limit,
is_price_limit_enabled: is_price_limit_enabled ?? target.is_price_limit_enabled,
min_price: min_price ?? target.min_price,
max_price: max_price ?? target.max_price);
public RiskLimitsModification with(RiskLimitsModification other_mod) =>
with(
other_mod.security.HasValue ? other_mod.security.Value : security,
other_mod.account.HasValue ? other_mod.account.Value : account,
security_criteria: other_mod.security_criteria ?? security_criteria,
max_long_position: other_mod.max_long_position ?? max_long_position,
max_short_position: other_mod.max_short_position ?? max_short_position,
is_position_limit_enabled: other_mod.is_position_limit_enabled ?? is_position_limit_enabled,
clip_limit: other_mod.clip_limit ?? clip_limit,
is_clip_limit_enabled: other_mod.is_clip_limit_enabled ?? is_clip_limit_enabled,
min_price: other_mod.min_price ?? min_price,
max_price: other_mod.max_price ?? max_price,
is_price_limit_enabled: other_mod.is_price_limit_enabled ?? is_price_limit_enabled);
//new RiskLimitsModification(security: other_mod.security ?? security,
// security_criteria: other_mod.security ?? security);
public RiskLimitsModification with(
OptionalNullable<SecurityImmutable>? security = null,
OptionalNullable<AccountTuple>? account = null,
SecurityCriteria security_criteria = null,
OptionalNullable<uint>? max_long_position = null,
OptionalNullable<uint>? max_short_position = null,
OptionalNullable<bool>? is_position_limit_enabled = null,
OptionalNullable<uint>? clip_limit = null,
OptionalNullable<bool>? is_clip_limit_enabled = null,
OptionalNullable<double>? min_price = null,
OptionalNullable<double>? max_price = null,
OptionalNullable<bool>? is_price_limit_enabled = null) =>
//
new RiskLimitsModification(
security.HasValue ? security.Value.value : this.security,
security_criteria ?? this.security_criteria,
account.HasValue ? account.Value.value : this.account,
max_long_position.HasValue ? max_long_position.Value.value : this.max_long_position,
max_short_position.HasValue ? max_short_position.Value.value : this.max_short_position,
is_position_limit_enabled.HasValue ? is_position_limit_enabled.Value.value : this.is_position_limit_enabled,
clip_limit.HasValue ? clip_limit.Value.value : this.clip_limit,
is_clip_limit_enabled.HasValue ? is_clip_limit_enabled.Value.value : this.is_clip_limit_enabled,
min_price.HasValue ? min_price.Value.value : this.min_price,
max_price.HasValue ? max_price.Value.value : this.max_price,
is_price_limit_enabled.HasValue ? is_price_limit_enabled.Value.value : this.is_price_limit_enabled);
static T? _common_value<T>(IEnumerable<AccountSecurityRiskLimits> source, Func<AccountSecurityRiskLimits, T> get) where T : struct =>
_common_value(source, get, common => new T?(common));
static TResult _common_value<T, TResult>(IEnumerable<AccountSecurityRiskLimits> source, Func<AccountSecurityRiskLimits, T> get, Func<T, TResult> convert_common, TResult default_value = default) =>
source.Select(get).Distinct().TryGetSingle(out var common) ? convert_common(common) : default_value;
}
}
@@ -0,0 +1,115 @@
using bts.admin.risk;
using bts.api;
using bts.utils;
using mbts.ui;
using mbts.ui.shell;
using System;
namespace bts.shell.risk_management {
class RiskLimitsVM : ViewModelBase, IEquatable<RiskLimitsVM> {
RiskLimitsVM(AccountSecurityKey id) =>
this.id = id;
public event Action request_commit;
/// The user can modify some props directly in the grid,
/// which may or may not give the row a new sort-position.
/// For this reason, the owner-viewmodel (<see cref="RiskManagementVM"/>)
/// is notified both immediately before, and after the changes are reflected in <see cref="data"/>.
/// By responding to those events, the owner-viewmodel can safely process any
/// sorting-changes without breaking binary search functionality.
/// <see cref="value_changing"/>, <see cref="value_changed"/>
/// <summary>
/// This event is raised just before a new value is assigned to <see cref="data"/>.
/// </summary>
public event Action<(AccountSecurityRiskLimits old_value, AccountSecurityRiskLimits new_value)> value_changing;
/// <summary>
/// This event is raised immediately after a new value is assigned to <see cref="data"/>.
/// </summary>
public event Action<(AccountSecurityRiskLimits old_value, AccountSecurityRiskLimits new_value)> value_changed;
public event Action is_dirty_changed;
public AccountSecurityKey id { get; }
public SecurityImmutable? security => data.security;
public string security_text => is_persisted ? security.ToString() : $"*{security}";
public uint security_key => data.security_key;
public string account_name => data.account_name;
public uint account_key => data.key.account;
// position limit
public bool is_position_limit_enabled { get => _limits.is_position_limit_enabled; set => _modify(new RiskLimitsModification(is_position_limit_enabled: value)); }
public uint max_long_position { get => _limits.max_long_position; set => _modify(new RiskLimitsModification(max_long_position: value)); }
public uint max_short_position { get => _limits.max_short_position; set => _modify(new RiskLimitsModification(max_short_position: value)); }
// clip limit
public bool is_clip_limit_enabled { get => _limits.is_clip_limit_enabled; set => _modify(new RiskLimitsModification(is_clip_limit_enabled: value)); }
public uint clip_limit { get => _limits.clip_limit; set => _modify(new RiskLimitsModification(clip_limit: value)); }
// price limit
public bool is_price_limit_enabled { get => _limits.is_price_limit_enabled; set => _modify(new RiskLimitsModification(is_price_limit_enabled: value)); }
public double min_price { get => _limits.min_price; set => _modify(new RiskLimitsModification(min_price: value)); }
public double max_price { get => _limits.max_price; set => _modify(new RiskLimitsModification(max_price: value)); }
public bool is_persisted => committed_data.HasValue;
public bool is_dirty => !committed_data.HasValue || !committed_data.Value.Equals(data);
public AccountSecurityRiskLimits data { get; private set; }
public AccountSecurityRiskLimits? committed_data { get; private set; }
RiskLimits _limits => data.limits;
public static RiskLimitsVM create_placeholder(AccountSecurityRiskLimits state) {
var vm = new RiskLimitsVM(state.key);
vm.load(state, false);
return vm;
}
public static RiskLimitsVM create_persisted(AccountSecurityRiskLimits state) {
var vm = new RiskLimitsVM(state.key);
vm.load(state, true);
return vm;
}
public void load(AccountSecurityRiskLimits new_state, bool is_committed) {
using (detect_property_changes()) {
bool was_dirty = is_dirty;
if (is_committed)
committed_data = new_state;
if (!data.Equals(new_state)) {
value_changing?.Invoke((data, new_state));
var orig_state = data;
data = new_state;
value_changed?.Invoke((orig_state, new_state));
}
if (is_dirty != was_dirty)
is_dirty_changed?.Invoke();
}
}
public bool Equals(RiskLimitsVM other) =>
other != null && id == other.id;
public override bool Equals(object obj) =>
Equals(obj as RiskLimitsVM);
public override int GetHashCode() =>
id.GetHashCode();
void _modify(RiskLimitsModification mod) {
var new_value = data.with(limits: mod.apply(data.limits));
if (committed_data.HasValue) {
// if the user just toggled one of the limits on/off, request an immediate update to persist the change
// (the on/off toggles are the only props that can be edited directly in the grid,
// the user might find it annoying if they have to click 'Save' just to turn the limits on/off.
var clims = committed_data.Value.limits;
load(new_value, false);
var revert_mod = new RiskLimitsModification(is_position_limit_enabled: clims.is_position_limit_enabled, is_clip_limit_enabled: clims.is_clip_limit_enabled, is_price_limit_enabled: clims.is_price_limit_enabled);
var reverted_lims = new_value = new_value.with(limits: revert_mod.apply(new_value.limits));
if (reverted_lims.limits.Equals(clims)) {
// since only the limit toggle props were reverted,
// the above equality indicates that only the limit toggle props were modified.
request_commit?.Invoke();
}
} else {
load(new_value, false);
}
}
}
}
@@ -0,0 +1,478 @@
using bts.admin.risk;
using bts.api.core;
using bts.collections;
using bts.utils;
using mbts;
using mbts.spark;
using mbts.spark.filters;
using mbts.ui;
using mbts.ui.controls;
using mbts.ui.settings;
using mbts.ui.shell;
using mbts.ui.utility;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Controls;
using Columns = bts.shell.risk_management.RiskManagementControl.Columns;
namespace bts.shell.risk_management {
class RiskManagementColumnModel : DIYGridColumnModel<Columns, AccountSecurityRiskLimits, RiskManagementFilterSettings> {
public RiskManagementColumnModel(Columns id, IComparer<AccountSecurityRiskLimits> data_comparer, IDataGridColumnFilter<AccountSecurityRiskLimits> filter, string filter_template, Func<RiskManagementFilterSettings, object> get_column_filter_settings, Func<RiskManagementFilterSettings, object, RiskManagementFilterSettings> set_column_filter_settings)
: base(id, data_comparer, filter, filter_template, get_column_filter_settings, set_column_filter_settings) {
}
}
class RiskManagementVM : DisposableViewModelBase, IHandleGridSorting, IHandleRowSelection, IValueFactory<RiskManagementSettings> {
static readonly IComparer<AccountSecurityRiskLimits> _data_row_id_comparer =
new ComparerBuilder<AccountSecurityKey>(new[] {
Comparer<uint>.Default.wrap<uint, AccountSecurityKey>(ask => ask.account),
Comparer<uint>.Default.wrap<uint, AccountSecurityKey>(ask => ask.security)
}).to_comparer()
.wrap<AccountSecurityKey, AccountSecurityRiskLimits>(r => r.key);
static IComparer<RiskLimitsVM> _row_id_comparer =>
_data_row_id_comparer.wrap<AccountSecurityRiskLimits, RiskLimitsVM>(r => r.data);
readonly DeferrableActionWrapper _refresh_filter_changed, _selected_rows_changed, _dirty_rows_changed;
readonly ColumnSortManager _sort_manager;
readonly ObservableCollection<RiskManagementColumnModel> _columns = new ObservableCollection<RiskManagementColumnModel>();
readonly Dictionary<Columns, RiskManagementColumnModel> _column_map = new Dictionary<Columns, RiskManagementColumnModel>();
readonly SelectorVM<AccountTuple?, uint> _accounts_vm = new SelectorVM<AccountTuple?, uint>(acc => acc?.id ?? 0) { comparer = Comparer<AccountTuple>.Default.to_nullable() };
IList<AccountSecurityRiskLimits> _data_rows;
ImmutableSortedSet<RiskLimitsVM> _selected_rows = ImmutableSortedSet.Create(_row_id_comparer);
IComparer<AccountSecurityRiskLimits> _data_comparer = _data_row_id_comparer;
IComparer<RiskLimitsVM> _row_comparer;
IDisposable _import_limits_op;
ImmutableDictionary<AccountSecurityKey, RiskLimitsVM> _dirty_rows = ImmutableDictionary<AccountSecurityKey, RiskLimitsVM>.Empty;
Dictionary<AccountSecurityKey, RiskLimitsVM> _imported_row_map = new Dictionary<AccountSecurityKey, RiskLimitsVM>();
Dictionary<AccountSecurityKey, RiskLimitsVM> _row_cache = new Dictionary<AccountSecurityKey, RiskLimitsVM>();
public RiskManagementVM(IObservable<TableUpdate<AccountSecurityRiskLimits, AccountSecurityKey>> data_source, IObservable<IReadOnlyList<AccountTuple>> accounts_source) {
_selected_rows_changed = new DeferrableActionWrapper(() => selected_rows_changed?.Invoke());
_refresh_filter_changed = new DeferrableActionWrapper(() => _filter_changed?.Invoke(_mk_filter()));
_dirty_rows_changed = new DeferrableActionWrapper(() => dirty_rows_changed?.Invoke(dirty_rows));
_sort_manager = new ColumnSortManager(_columns.OfType<ISortableDIYGridColumn>(), null);
_sort_manager.active_sorting_changed += () =>
data_comparer = _sort_manager.BuildComparer(id => _find_column(id)?.row_comparer, _data_comparer);
_data_rows = rows.WrapSelector(r => r.data, null);
_accounts_vm.selected_item_changed += () => {
RaisePropertyChanged(nameof(selected_account));
_refresh_filter_changed.execute();
};
column_map = FunctionalIndex.create<string, RiskManagementColumnModel>(_find_column);
grid_settings_manager = new SimpleGridSettingsManagerVM<Columns>(
_columns, null, ordered_cols => {
CollectionHelper.sync_with_never_duplicate(_columns, ordered_cols, cs => {
throw new InvalidOperationException();
}, c => c.id.ToString(), cs => cs.id);
}, null);
/////////////////
// Columns
/////////////////
// security
mk_column_model(
Columns.Security,
wrap_comp(r => r.security),
new RegexFilterVM<AccountSecurityRiskLimits>(r => r.security.ToString(), null),
DataGridFilterKnownTemplates.Regex,
fs => fs.security_regex,
(fs, v) => fs.with(security_regex: v));
// security key
mk_column_model(
Columns.SecurityKey,
wrap_comp(r => r.security_key),
new RegexFilterVM<AccountSecurityRiskLimits>(r => r.security_key.ToString(), null),
DataGridFilterKnownTemplates.Regex,
fs => fs.security_key_regex,
(fs, v) => fs.with(security_key_regex: v));
// max long
mk_column_model(
Columns.MaxNetLongPosition,
wrap_comp(r => r.limits.max_long_position),
new UIntMinMax<AccountSecurityRiskLimits>(
r => r.limits.max_long_position,
null),
DataGridFilterKnownTemplates.UIntMinMax,
fs => fs.max_long_position,
(fs, v) => fs.with(max_long_position: v));
// max short
mk_column_model(
Columns.MaxNetShortPosition,
wrap_comp(r => r.limits.max_short_position),
new UIntMinMax<AccountSecurityRiskLimits>(
r => r.limits.max_short_position,
null),
DataGridFilterKnownTemplates.UIntMinMax,
fs => fs.max_short_position,
(fs, v) => fs.with(max_short_position: v));
// is position limit enabled
mk_is_enabled_column(
Columns.IsPositionLimitEnabled,
r => r.limits.is_position_limit_enabled,
(fs, yes_no_items) => fs.with(is_position_limit_enabled: RiskManagementFilterSettings.yes_no_filter_state(yes_no_items)),
nameof(RiskLimitsVM.is_position_limit_enabled));
// clip size
mk_column_model(
Columns.ClipLimit,
wrap_comp(r => r.limits.clip_limit),
new UIntMinMax<AccountSecurityRiskLimits>(r => r.limits.clip_limit, null),
DataGridFilterKnownTemplates.UIntMinMax,
fs => fs.clip_limit,
(fs, v) => fs.with(clip_limit: v));
// is clip limit enabled
mk_is_enabled_column(
Columns.IsClipLimitEnabled,
r => r.limits.is_clip_limit_enabled,
(fs, yes_no_items) => fs.with(is_clip_limit_enabled: RiskManagementFilterSettings.yes_no_filter_state(yes_no_items)),
nameof(RiskLimitsVM.is_clip_limit_enabled));
// min price
mk_column_model(
Columns.MinPrice,
wrap_comp(r => r.limits.min_price),
new DoubleMinMax<AccountSecurityRiskLimits>(r => r.limits.min_price, nameof(RiskLimitsVM.min_price)),
DataGridFilterKnownTemplates.DoubleMinMax,
fs => fs.min_price,
(fs, v) => fs.with(min_price: v));
// max price
mk_column_model(
Columns.MaxPrice,
wrap_comp(r => r.limits.max_price),
new DoubleMinMax<AccountSecurityRiskLimits>(r => r.limits.max_price, nameof(RiskLimitsVM.max_price)),
DataGridFilterKnownTemplates.DoubleMinMax,
fs => fs.max_price,
(fs, v) => fs.with(max_price: v));
// is price limit enabled
mk_is_enabled_column(
Columns.IsPriceLimitEnabled,
r => r.limits.is_price_limit_enabled,
(fs, yes_no_items) => fs.with(is_price_limit_enabled: RiskManagementFilterSettings.yes_no_filter_state(yes_no_items)),
nameof(RiskLimitsVM.is_price_limit_enabled));
data_comparer = new ComparerBuilder<AccountSecurityRiskLimits>(new[] {
wrap_comp(r => r.security),
_data_row_id_comparer
}).to_comparer();
_column_map = _columns.ToDictionary(c => c.id);
columns = ObservableAutoWrapper.SelectObservable(_columns, c => c);
var filter_source =
Observable.FromEvent<Func<AccountSecurityRiskLimits, bool>>(cb => _filter_changed += cb, cb => _filter_changed -= cb)
.StartWith(_mk_filter);
var filtered_data_source =
data_source.Filter(filter_source, AccountSecurityRiskLimitsDataHelper.key_fn);
var filter_hooks = _columns.Select(c => {
var f = c.filter;
f.filter_changed += _refresh_filter_changed.execute;
return Disposable.Create(() => f.filter_changed -= _refresh_filter_changed.execute);
}).ToList();
_accounts_vm.selected_item_changed += on_selected_account_changed;
_dispose = Disposable.Create(
ObservableAutoWrapper.connect_item_hooks(rows, subscribe_row_changes),
accounts_source.OnDispatcher().Subscribe(on_accounts),
Disposable.wrap_collection(filter_hooks),
filtered_data_source.OnDispatcher().Subscribe(on_data));
//////////////////
// local methods
//////////////////
IComparer<AccountSecurityRiskLimits> wrap_comp<T>(Func<AccountSecurityRiskLimits, T> get_value) =>
Comparer<T>.Default.wrap<T, AccountSecurityRiskLimits>(get_value);
RiskManagementColumnModel mk_column_model<T>(
Columns id,
IComparer<AccountSecurityRiskLimits> row_comp,
IDataGridColumnPersistentFilter<AccountSecurityRiskLimits, T> filter,
string filter_template,
Func<RiskManagementFilterSettings, T> get_filter_settings,
Func<RiskManagementFilterSettings, T, RiskManagementFilterSettings> set_filter_settings) {
//
var col = new RiskManagementColumnModel(id, row_comp,
filter,
filter_template,
fs => get_filter_settings(fs),
(fs, val) => val is T cfs ? set_filter_settings(fs, cfs) : fs);
_columns.Add(col);
return col;
}
// the 'is enabled' columns are special cases, bc their filters produces an array of bools
// (cheap way to reuse the discrete values filter template for true/false items),
// but the filter protobuf has a nullable<bool>, so an extra conversion must be done explicitly (hence the get_row_val param).
RiskManagementColumnModel mk_is_enabled_column(Columns id, Func<AccountSecurityRiskLimits, bool> get_row_val, Func<RiskManagementFilterSettings, IEnumerable<bool>, RiskManagementFilterSettings> set_filter_prop, string prop) {
var col = new RiskManagementColumnModel(
id,
wrap_comp(get_row_val),
DiscreteValuesFilterVM.Create(new[] { true, false }, get_row_val, prop),
DataGridFilterKnownTemplates.YesNo,
fs => RiskManagementFilterSettings.yes_no_filter_items(fs.is_position_limit_enabled),
(fs, fstate) => set_filter_prop(fs, fstate as IEnumerable<bool>));
_columns.Add(col);
return col;
}
IDisposable subscribe_row_changes(RiskLimitsVM row) {
row.value_changing += on_value_changing;
row.value_changed += on_value_changed;
row.request_commit += on_request_commit;
check_dirty();
return Disposable.Create(() => {
row.value_changing -= on_value_changing;
row.value_changed -= on_value_changed;
row.request_commit -= on_request_commit;
});
void on_value_changing((AccountSecurityRiskLimits old_value, AccountSecurityRiskLimits new_value) change) =>
on_row_data_changed(new Change<AccountSecurityRiskLimits>(change.old_value, change.new_value), false);
void on_value_changed((AccountSecurityRiskLimits old_value, AccountSecurityRiskLimits new_value) change) =>
check_dirty();
void on_request_commit() =>
request_update_limit?.Invoke(row.data);
void check_dirty() {
int dr_count = _dirty_rows.Count;
_dirty_rows = row.is_dirty ? _dirty_rows.Add(row.id, row) : _dirty_rows.Remove(row.id);
if (dr_count != _dirty_rows.Count)
_dirty_rows_changed.execute();
}
}
void on_accounts(IReadOnlyList<AccountTuple> new_accounts) =>
_accounts_vm.update_items(new_accounts.Cast<AccountTuple?>());
void on_data(TableUpdate<AccountSecurityRiskLimits, AccountSecurityKey> table) {
using (_dirty_rows_changed.defer_execution())
using (_selected_rows_changed.defer_execution()) {
foreach (var lim in table.removed) {
if (_row_cache.TryGetValue(lim.key, out var row)) {
_data_rows.RemoveSorted(row.data, data_comparer);
if (row.committed_data.HasValue)
_row_cache.Remove(lim.key);
}
}
foreach (var ch in table.changes) {
on_row_data_changed(ch, true);
}
foreach (var lim in table.added) {
if (_row_cache.TryGetValue(lim.key, out var row)) {
// if row is already here, it must be an import
// overwrite the import with the persisted row (this probably won't happen in practice)
rows.RemoveSorted(row, row_comparer);
_imported_row_map.Remove(lim.key);
}
var new_row = RiskLimitsVM.create_persisted(lim);
_row_cache[lim.key] = new_row;
rows.InsertSorted(new_row, row_comparer);
}
}
}
void on_row_data_changed(Change<AccountSecurityRiskLimits> change, bool is_persisted) {
Log.assert(_row_cache.TryGetValue(change.Old.key, out var row));
int old_index = CollectionHelper.binary_search(rows, row, row_comparer);
Log.assert(old_index >= 0);
int new_index = CollectionHelper.binary_search(_data_rows, change.New, _data_comparer);
// if the change came from the server (i.e., a persisted change that the row-vm doesn't already know about),
// load the new data (current modifications will be overwritten).
// Otherwise, the change is presumably the result of an uncommitted user-edit, which the row must already know about.
if (is_persisted) {
row.load(change.New, true);
if (_dirty_rows.Remove(row.id, out _dirty_rows))
_dirty_rows_changed.execute();
}
if (new_index < 0)
new_index = ~new_index;
if (Math.Abs(new_index - old_index) > 1) {
if (new_index > old_index)
new_index--;
rows.Move(old_index, new_index);
}
}
void on_selected_account_changed() {
foreach (var ir in _imported_row_map.Values) {
if (ir.account_key == selected_account?.id) {
rows.InsertOrReplaceSorted(ir, row_comparer);
} else {
rows.RemoveSorted(ir, row_comparer);
}
}
}
}
public event Action selected_rows_changed;
public event Action<AccountSecurityRiskLimits> request_update_limit;
public event Action<ImmutableDictionary<AccountSecurityKey, RiskLimitsVM>> dirty_rows_changed;
event Action<Func<AccountSecurityRiskLimits, bool>> _filter_changed;
public IReadOnlyIndex<string, RiskManagementColumnModel> column_map { get; }
public bool has_unpersisted_limits => false;
// this collection is needed to control the column order
public IReadOnlyObservableCollection<IDIYGridColumn> columns { get; }
public ObservableCollection<RiskLimitsVM> rows { get; } = new ObservableCollection<RiskLimitsVM>();
/// <summary>
/// The selected rows are provided as an <see cref="ImmutableSortedSet{T}"/> so they can be observed/accessed on different threads.
/// <see cref="RiskManagementVMExtensions.subscribe_selected_rows(RiskManagementVM)"/>.
/// </summary>
public ImmutableSortedSet<RiskLimitsVM> selected_rows => _selected_rows;
/// <summary>
/// The dirty rows are provided as an <see cref="ImmutableDictionary{TKey, TValue}"/> so they can be observed/accessed on different threads.
/// <see cref="RiskManagementVMExtensions.subscribe_has_dirty_rows(RiskManagementVM)(RiskManagementVM)"/>.
/// </summary>
public ImmutableDictionary<AccountSecurityKey, RiskLimitsVM> dirty_rows => _dirty_rows;
public IReadOnlyObservableCollection<AccountTuple?> accounts => _accounts_vm.items;
public AccountTuple? selected_account {
get => _accounts_vm.selected_item ?? default;
set => _accounts_vm.selected_item = value;
}
public SimpleGridSettingsManagerVM<Columns> grid_settings_manager { get; }
public IComparer<AccountSecurityRiskLimits> data_comparer {
get => _data_comparer;
private set {
if (value != null) {
_data_comparer = value;
_row_comparer = null;
rows.sync_with(rows.Ordered(row_comparer));
_selected_rows = _selected_rows.WithComparer(row_comparer);
}
}
}
public IComparer<RiskLimitsVM> row_comparer =>
_row_comparer ?? (_row_comparer = data_comparer?.wrap<AccountSecurityRiskLimits, RiskLimitsVM>(r => r.data));
public IReadOnlyDictionary<uint, SecurityMD> security_map { get; set; } = DictionaryHelper.empty<uint, SecurityMD>();
public IReadOnlyDictionary<uint, IEnumerable<AccountSecurityRiskLimits>> build_account_limits_map() =>
_data_rows.GroupBy(dr => dr.account_key)
.ToDictionary(g => g.Key, g => g.AsEnumerable());
public RiskManagementSettings create() {
var grid = grid_settings_manager.create();
var filters = _columns.Aggregate(new RiskManagementFilterSettings(), (fs, c) => c.assign_filter_settings(fs));
return new RiskManagementSettings(grid, filters, _sort_manager.SortingCriteria, selected_account?.id ?? 0);
}
public void load_from(RiskManagementSettings settings) {
if (settings is null)
throw new ArgumentNullException(nameof(settings));
if (settings.grid != null)
grid_settings_manager.load_from(settings.grid);
_sort_manager.SortingCriteria = settings.sorting_criteria;
using (_refresh_filter_changed.defer_execution()) {
foreach (var col in _columns)
col.load_from(null, settings.filters);
_accounts_vm.try_select(settings.account_id, true);
}
}
public void load_from(GridSettings grid) {
if (grid is null)
throw new ArgumentNullException(nameof(grid));
grid_settings_manager.load_from(grid);
}
public void modify_rows(IEnumerable<AccountSecurityKey> targets, RiskLimitsModification mod) {
foreach (var key in targets) {
if (_row_cache.TryGetValue(key, out var row)) {
var new_data = row.data.with(limits: mod.apply(row.data.limits));
row.load(new_data, false);
}
}
}
public void revert(IEnumerable<RiskLimitsVM> targets) {
foreach (var row in targets) {
if (row.committed_data.HasValue)
row.load(row.committed_data.Value, true);
}
}
public void import_limits(string file_name) {
Disposable.dispose(ref _import_limits_op);
_import_limits_op = RiskLimitsImporter.import_limits(file_name,
security_map,
accounts.Where(a => a.HasValue)
.ToDictionary(a => a.Value.id, a => a.Value.name),
add_imported_rows);
void add_imported_rows(IEnumerable<ParsedRiskLimits> imported_rows) {
foreach (var ir in imported_rows) {
var res = ir.result;
if (!res.security.HasValue && security_map.TryGetValue(res.security_key, out var sec_md))
res = res.with(security: sec_md.security);
if (string.IsNullOrEmpty(res.account_name) && accounts.TryGetFirst(a => a?.id == res.account_key, out var acc))
res = res.with(account: acc);
if (_row_cache.TryGetValue(res.key, out var old_row))
rows.RemoveSorted(old_row, row_comparer);
var new_row = RiskLimitsVM.create_placeholder(res);
_row_cache[res.key] = new_row;
_imported_row_map[res.key] = new_row;
if (new_row.account_key == selected_account?.id)
rows.InsertSorted(new_row, row_comparer);
}
}
}
void IHandleRowSelection.row_selection_changed(SelectionChangedEventArgs e) {
var bd = _selected_rows.ToBuilder();
RowSelectionHelper.apply_changes(bd, e);
_selected_rows = bd.ToImmutable();
_selected_rows_changed.execute();
}
void IHandleGridSorting.on_sorting(object sender, DIYGridSortingEventArgs e) {
_sort_manager.OnColumnClick(e.Column, KeyboardExtensions.IsShiftDown());
e.Handled = true;
}
RiskManagementColumnModel _find_column(string key_str) =>
Enum.TryParse(key_str, true, out Columns key) ? _find_column(key) : null;
RiskManagementColumnModel _find_column(Columns key) =>
_column_map.GetValueOrDefault(key);
Func<AccountSecurityRiskLimits, bool> _mk_filter() {
var col_filter_pred = create().filters.build_predicate();
if (!selected_account.HasValue)
return lim => false;
var acc_id = selected_account.Value.id;
return lim => lim.account_key == acc_id && (col_filter_pred is null || col_filter_pred(lim));
}
}
static class RiskManagementVMExtensions {
public static IObservable<ImmutableSortedSet<RiskLimitsVM>> subscribe_selected_rows(this RiskManagementVM vm) =>
vm is null ?
throw new ArgumentNullException(nameof(vm)) :
Observable.Create<ImmutableSortedSet<RiskLimitsVM>>(o => {
o.OnNext(vm.selected_rows);
vm.selected_rows_changed += on_selected_rows_changed;
return Disposable.Create(() => vm.selected_rows_changed -= on_selected_rows_changed);
void on_selected_rows_changed() =>
o.OnNext(vm.selected_rows);
})
.SubscribeOnDispatcher();
public static IObservable<bool> subscribe_has_dirty_rows(this RiskManagementVM vm) =>
vm is null ?
throw new ArgumentNullException(nameof(vm)) :
Observable.Create<bool>(o => {
bool last_fired = vm.dirty_rows.Count > 0;
o.OnNext(last_fired);
vm.dirty_rows_changed += on_dirty_rows_changed;
return Disposable.Create(() => vm.dirty_rows_changed -= on_dirty_rows_changed);
void on_dirty_rows_changed(ImmutableDictionary<AccountSecurityKey, RiskLimitsVM> drs) {
if (last_fired != drs.Count > 0)
o.OnNext(last_fired = !last_fired);
}
})
.SubscribeOnDispatcher();
}
}
@@ -0,0 +1,111 @@
<Window
x:Class="bts.shell.risk_management.RiskLimitParametersDialog"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
xmlns:risk="clr-namespace:bts.shell.risk_management"
xmlns:sys="clr-namespace:System;assembly=mscorlib"
u:WindowStyle.AllowResize="False"
u:WindowStyle.SizeToContent="WidthAndHeight"
FocusVisualStyle="{x:Null}"
Style="{StaticResource BTSDialog}"
>
<Window.Resources>
<sys:Double x:Key="HorizontalPush">4</sys:Double>
<sys:Double x:Key="VerticalPush3">8</sys:Double>
<Thickness x:Key="ParamMargin" Left="{StaticResource HorizontalPush}"/>
<Style x:Key="HeaderText" TargetType="TextBlock">
<Setter Property="HorizontalAlignment" Value="Center"/>
<Setter Property="VerticalAlignment" Value="Center"/>
<Setter Property="Foreground" Value="{x:Static u:BTSColors.header_text_brush}"/>
<Setter Property="Margin" Value="4"/>
</Style>
<Style x:Key="LimitToggle" TargetType="CheckBox">
<Setter Property="VerticalAlignment" Value="Center"/>
<Setter Property="HorizontalAlignment" Value="Center"/>
</Style>
</Window.Resources>
<Window.ContentTemplate>
<DataTemplate DataType="{x:Type risk:RiskLimitsModificationVM}">
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<Grid Margin="6">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="{Binding Source={StaticResource HorizontalPush}}"/>
<ColumnDefinition Width="Auto"/>
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="{Binding Source={StaticResource VerticalPush3}}"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<Rectangle Grid.ColumnSpan="17" HorizontalAlignment="Stretch" VerticalAlignment="Stretch" Fill="{x:Static u:BTSColors.header_brush}"/>
<TextBlock Grid.Column="0" Text="Security" Visibility="{Binding can_edit_security, Converter={StaticResource BooleanToVisibilityConverter}}" Style="{StaticResource HeaderText}"/>
<TextBlock Grid.Column="2" Text="Max Long" Style="{StaticResource HeaderText}"/>
<TextBlock Grid.Column="4" Text="Max Short" Style="{StaticResource HeaderText}"/>
<TextBlock Grid.Column="6" Text="Clip Limit" Style="{StaticResource HeaderText}"/>
<TextBlock Grid.Column="8" Text="Min Price" Style="{StaticResource HeaderText}"/>
<TextBlock Grid.Column="10" Text="Max Price" Style="{StaticResource HeaderText}"/>
<TextBlock Grid.Column="12" Text="Position Limit Enabled" Style="{StaticResource HeaderText}"/>
<TextBlock Grid.Column="14" Text="Clip Limit Enabled" Style="{StaticResource HeaderText}"/>
<TextBlock Grid.Column="16" Text="Price Limit Enabled" Style="{StaticResource HeaderText}"/>
<c:ContractPickerPopup
Grid.Row="2"
HorizontalAlignment="Stretch"
VerticalAlignment="Stretch"
CloseOnCancel="True"
CloseOnOK="True"
Header="{Binding security_criteria, Converter={x:Static c:ContractPickerPopup.SecurityCriteriaTextConverter}}"
Visibility="{Binding can_edit_security, Converter={StaticResource BooleanToVisibilityConverter}}"
IsEditMode="True"
IsLazy="True"
SecurityMap="{Binding security_map}"
SelectedCriteria="{Binding security_criteria}"
ShowDialogSkirt="True"
ToolTip="{Binding security_criteria, Converter={x:Static c:ContractPickerPopup.SecurityCriteriaTextConverter}}"
OKClick="{x:Static c:ContractPickerPopup.FlushSelectedSecurityHandler}"
/>
<c:TickUpDownNullableUInt Grid.Row="2" Grid.Column="2" Value="{Binding max_long_position}"/>
<c:TickUpDownNullableUInt Grid.Row="2" Grid.Column="4" Value="{Binding max_short_position}"/>
<c:TickUpDownNullableUInt Grid.Row="2" Grid.Column="6" Value="{Binding clip_limit}"/>
<c:TickUpDownNullableDouble Grid.Row="2" Grid.Column="8" Value="{Binding min_price}"/>
<c:TickUpDownNullableDouble Grid.Row="2" Grid.Column="10" Value="{Binding max_price}"/>
<CheckBox Grid.Row="2" Grid.Column="12" IsChecked="{Binding is_position_limit_enabled}" Style="{StaticResource LimitToggle}"/>
<CheckBox Grid.Row="2" Grid.Column="14" IsChecked="{Binding is_clip_limit_enabled}" Style="{StaticResource LimitToggle}"/>
<CheckBox Grid.Row="2" Grid.Column="16" IsChecked="{Binding is_price_limit_enabled}" Style="{StaticResource LimitToggle}"/>
</Grid>
<c:DialogSkirt Grid.Row="1" Margin="0,6,0,0">
<c:DialogSkirt.RightItems>
<x:Array Type="{x:Type Button}">
<Button Content="OK" Command="{Binding commit_cmd}" IsDefault="True"/>
<Button Content="Cancel" Command="{Binding cancel_cmd}" IsCancel="True"/>
</x:Array>
</c:DialogSkirt.RightItems>
</c:DialogSkirt>
</Grid>
</DataTemplate>
</Window.ContentTemplate>
</Window>
@@ -0,0 +1,11 @@
using System.Windows;
namespace bts.shell.risk_management {
/// <summary>
/// Interaction logic for RiskLimitParametersDialog.xaml
/// </summary>
partial class RiskLimitParametersDialog : Window {
public RiskLimitParametersDialog() =>
InitializeComponent();
}
}
@@ -0,0 +1,39 @@
<Window
x:Class="bts.shell.risk_management.RiskLimitsImportConflictsDialog"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:risk="clr-namespace:bts.shell.risk_management"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
u:WindowStyle.AllowResize="True"
u:WindowStyle.SizeToContent="WidthAndHeight"
u:WindowStyle.TitleContent="Import Limits Conflicts"
Style="{StaticResource BTSDialogTitleTemplate}"
>
<u:WindowStyle.TitleContentTemplate>
<DataTemplate>
<StackPanel Orientation="Horizontal" HorizontalAlignment="Left">
<Image Height="12" Margin="5,2" Source="{x:Static u:Icons.Import}"/>
<TextBlock Margin="4,0,0,0" Text="{Binding}"/>
</StackPanel>
</DataTemplate>
</u:WindowStyle.TitleContentTemplate>
<Window.Content>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="*"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<risk:RiskLimitsImportConflictsView Margin="12,10,12,8"/>
<c:DialogSkirt Grid.Row="1">
<c:DialogSkirt.RightItems>
<x:Array Type="{x:Type Button}">
<Button Command="{Binding ok_cmd}">Continue</Button>
<Button Command="{Binding cancel_cmd}" IsCancel="True">Cancel</Button>
</x:Array>
</c:DialogSkirt.RightItems>
</c:DialogSkirt>
</Grid>
</Window.Content>
</Window>
@@ -0,0 +1,11 @@
using System.Windows;
namespace bts.shell.risk_management {
/// <summary>
/// Interaction logic for RiskLimitsImportConflictsDialog.xaml
/// </summary>
partial class RiskLimitsImportConflictsDialog : Window {
public RiskLimitsImportConflictsDialog() =>
InitializeComponent();
}
}
@@ -0,0 +1,141 @@
<UserControl
x:Class="bts.shell.risk_management.RiskLimitsImportConflictsView"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:risk="clr-namespace:bts.shell.risk_management"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
xmlns:cv="clr-namespace:mbts.ui.converters"
MinWidth="400"
>
<UserControl.Resources>
<Style x:Key="VerticallyCenteredText" TargetType="TextBlock">
<Setter Property="VerticalAlignment" Value="Center"/>
</Style>
<DataTemplate x:Key="UIntTemplate">
<c:TickUpDownUInt Value="{Binding value, UpdateSourceTrigger=PropertyChanged}"/>
</DataTemplate>
<DataTemplate x:Key="DoubleTemplate">
<c:TickUpDownDouble Value="{Binding value, UpdateSourceTrigger=PropertyChanged}"/>
</DataTemplate>
<DataTemplate x:Key="BooleanTemplate">
<CheckBox IsChecked="{Binding value}"/>
</DataTemplate>
<DataTemplate x:Key="PriceReadTemplate">
<TextBlock Text="{Binding value, Converter={StaticResource DoubleTextConverter}}" VerticalAlignment="Center"/>
</DataTemplate>
<!--Value Cell Template Selector-->
<u:KeyedTemplateSelector x:Key="ValueCellTemplateSelector">
<u:KeyedTemplateSelector.Default>
<DataTemplate>
<TextBlock Text="{Binding value}" VerticalAlignment="Center"/>
</DataTemplate>
</u:KeyedTemplateSelector.Default>
<u:TemplateSelectorKeyValue Key="{x:Static MinPrice, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource PriceReadTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static MaxPrice, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource PriceReadTemplate}"/>
</u:KeyedTemplateSelector>
<!--Value Cell Editing Template Selector-->
<u:KeyedTemplateSelector x:Key="ValueCellEditingTemplateSelector">
<u:TemplateSelectorKeyValue Key="{x:Static Security, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}">
<DataTemplate>
<c:ContractPickerPopup
HorizontalAlignment="Stretch"
VerticalAlignment="Stretch"
CloseOnCancel="True"
CloseOnOK="True"
Header="{Binding value}"
IsEditMode="False"
IsLazy="True"
SecurityMap="{Binding DataContext.security_map, RelativeSource={RelativeSource AncestorType=DataGrid}, Mode=OneWay}"
SelectedSecurity="{Binding value, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
ShowDialogSkirt="True"
/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="{x:Static Account, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}">
<DataTemplate>
<ComboBox ItemsSource="{Binding DataContext.accounts, RelativeSource={RelativeSource AncestorType=DataGrid}}" SelectedItem="{Binding value, UpdateSourceTrigger=PropertyChanged}"/>
</DataTemplate>
</u:TemplateSelectorKeyValue>
<u:TemplateSelectorKeyValue Key="{x:Static MaxNetLongPosition, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource UIntTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static MaxNetShortPosition, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource UIntTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static IsPositionLimitEnabled, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource BooleanTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static ClipLimit, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource UIntTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static IsClipLimitEnabled, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource BooleanTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static MinPrice, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource DoubleTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static MaxPrice, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource DoubleTemplate}"/>
<u:TemplateSelectorKeyValue Key="{x:Static IsPriceLimitEnabled, MemberType={u:Nested risk:RiskLimitsImportConflictsView.RiskLimitsComponentNames}}" Value="{StaticResource BooleanTemplate}"/>
</u:KeyedTemplateSelector>
</UserControl.Resources>
<!--Content-->
<Grid x:Name="content_root">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<Image VerticalAlignment="Center" Margin="0,0,8,0">
<Image.Source>
<Binding Source="{x:Static MessageBoxImage.Exclamation}">
<Binding.Converter>
<cv:SystemIconConverter/>
</Binding.Converter>
</Binding>
</Image.Source>
</Image>
<Canvas x:Name="text_canvas" Grid.Column="1" HorizontalAlignment="Stretch"/>
<TextBlock Grid.Column="1" TextWrapping="Wrap" Width="{Binding ActualWidth, ElementName=text_canvas}">
<Run Text="{Binding num_successfully_parsed_limits, Mode=OneWay}"/>
<Run Text="/"/>
<Run Text="{Binding num_limits, Mode=OneWay}"/>
<Run Text=" limit items have been successfully converted."/>
<Run Text="Resolve conflicts below by selecting a value to assign each affected limit item,"/>
<Run Text="or modify individual limit items in the main window."/>
<LineBreak/>
<LineBreak/>
<Run Text="Click 'Continue' to proceed to the main window."/>
</TextBlock>
<DataGrid
x:Name="data_grid"
u:DataGridBehavior.SingleClickEdit="True"
Grid.Row="1"
Grid.ColumnSpan="2"
AutoGenerateColumns="False"
CanUserAddRows="False"
CanUserDeleteRows="False"
CanUserReorderColumns="False"
CanUserSortColumns="True"
HeadersVisibility="All"
ItemsSource="{Binding rows_view}"
Margin="0,8,0,0"
MinRowHeight="17"
RowHeaderWidth="22"
>
<DataGrid.CellStyle>
<Style TargetType="DataGridCell" BasedOn="{StaticResource DataGridCellBaseStyle}">
<Setter Property="VerticalContentAlignment" Value="Stretch"/>
</Style>
</DataGrid.CellStyle>
<DataGrid.RowStyle>
<Style TargetType="DataGridRow">
<Setter Property="IsSelected" Value="{Binding is_selected, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"/>
<Style.Triggers>
<DataTrigger Binding="{Binding IsSelected, RelativeSource={RelativeSource Self}}" Value="True">
<Setter Property="Background" Value="{StaticResource SelectedRowBackground}"/>
</DataTrigger>
</Style.Triggers>
</Style>
</DataGrid.RowStyle>
<DataGrid.Columns>
<DataGridTextColumn Header="Component" Binding="{Binding component}" ElementStyle="{StaticResource VerticallyCenteredText}" IsReadOnly="True"/>
<DataGridTextColumn Header="Text" Binding="{Binding text}" ElementStyle="{StaticResource VerticallyCenteredText}" IsReadOnly="True"/>
<DataGridTextColumn Header="Affected Limit Items" Binding="{Binding affected_limits.Count}" ElementStyle="{StaticResource VerticallyCenteredText}" IsReadOnly="True"/>
<DataGridTemplateColumn Header="Value" CellTemplateSelector="{StaticResource ValueCellTemplateSelector}" CellEditingTemplateSelector="{StaticResource ValueCellEditingTemplateSelector}"/>
</DataGrid.Columns>
</DataGrid>
</Grid>
</UserControl>
@@ -0,0 +1,38 @@
using System.Windows.Controls;
namespace bts.shell.risk_management {
/// <summary>
/// Interaction logic for RiskLimitsImportConflictsView.xaml
/// </summary>
partial class RiskLimitsImportConflictsView : UserControl {
public RiskLimitsImportConflictsView() =>
InitializeComponent();
public enum RiskLimitsComponent {
Security,
Account,
MaxNetLongPosition,
MaxNetShortPosition,
IsPositionLimitEnabled,
ClipLimit,
IsClipLimitEnabled,
MinPrice,
MaxPrice,
IsPriceLimitEnabled
}
public static class RiskLimitsComponentNames {
public static readonly string
Security = RiskLimitsComponent.Security.ToString(),
Account = RiskLimitsComponent.Account.ToString(),
MaxNetLongPosition = RiskLimitsComponent.MaxNetLongPosition.ToString(),
MaxNetShortPosition = RiskLimitsComponent.MaxNetShortPosition.ToString(),
IsPositionLimitEnabled = RiskLimitsComponent.IsPositionLimitEnabled.ToString(),
ClipLimit = RiskLimitsComponent.ClipLimit.ToString(),
IsClipLimitEnabled = RiskLimitsComponent.IsClipLimitEnabled.ToString(),
MinPrice = RiskLimitsComponent.MinPrice.ToString(),
MaxPrice = RiskLimitsComponent.MaxPrice.ToString(),
IsPriceLimitEnabled = RiskLimitsComponent.IsPriceLimitEnabled.ToString();
}
}
}
@@ -0,0 +1,181 @@
<UserControl
x:Class="bts.shell.risk_management.RiskManagementControl"
x:ClassModifier="internal"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:u="clr-namespace:mbts.ui"
xmlns:c="clr-namespace:mbts.ui.controls"
xmlns:cv="clr-namespace:mbts.ui.converters"
xmlns:risk="clr-namespace:bts.shell.risk_management"
xmlns:sys="clr-namespace:System;assembly=mscorlib"
mc:Ignorable="d"
d:DataContext="{d:DesignInstance risk:RiskManagementVM, IsDesignTimeCreatable=True}"
Background="{StaticResource CommonBackground}"
>
<UserControl.Resources>
<cv:BooleanToObjectConverter x:Key="IsDirtyOpacityConverter">
<cv:BooleanToObjectConverter.ValueForFalse>
<sys:Double>1.0</sys:Double>
</cv:BooleanToObjectConverter.ValueForFalse>
<cv:BooleanToObjectConverter.ValueForTrue>
<sys:Double>0.6</sys:Double>
</cv:BooleanToObjectConverter.ValueForTrue>
</cv:BooleanToObjectConverter>
<Style x:Key="TextCell" TargetType="c:TextCell">
<Setter Property="VerticalAlignment" Value="Center"/>
<Setter Property="Padding" Value="2,0"/>
<Setter Property="HorizontalAlignment" Value="Stretch"/>
<Setter Property="HorizontalContentAlignment" Value="{Binding Path='(c:DIYGrid.Column).horizontal_alignment', RelativeSource={RelativeSource Self}}"/>
<Setter Property="VerticalContentAlignment" Value="Center"/>
<Setter Property="VerticalAlignment" Value="Stretch"/>
<Setter Property="Background" Value="{Binding Path='(c:DIYGrid.Column).background_color', RelativeSource={RelativeSource Self}, Converter={x:Static cv:ColorToBrushConverter.Instance}}"/>
<Setter Property="Foreground" Value="{Binding Path='(c:DIYGrid.Column).font_color', RelativeSource={RelativeSource Self}, Converter={x:Static cv:ColorToBrushConverter.Instance}}"/>
<Setter Property="FontFamily" Value="{Binding Path='(c:DIYGrid.Column).font_family', RelativeSource={RelativeSource Self}}"/>
<Setter Property="FontWeight" Value="{Binding Path='(c:DIYGrid.Column).font_weight', RelativeSource={RelativeSource Self}}"/>
<Setter Property="FontSize" Value="{Binding Path='(c:DIYGrid.Column).font_size', RelativeSource={RelativeSource Self}}"/>
<Setter Property="Opacity" Value="{Binding is_dirty, Converter={StaticResource IsDirtyOpacityConverter}}"/>
</Style>
<Style x:Key="CellBorder" TargetType="Border">
<Setter Property="HorizontalAlignment" Value="Stretch"/>
<Setter Property="VerticalAlignment" Value="Stretch"/>
<Setter Property="Background" Value="{Binding Path='(c:DIYGrid.Column).background_color', RelativeSource={RelativeSource Self}, Converter={x:Static cv:ColorToBrushConverter.Instance}}"/>
<Setter Property="Padding" Value="2,0"/>
</Style>
<Style x:Key="LimitToggleSwitch" TargetType="CheckBox" BasedOn="{StaticResource {x:Type CheckBox}}">
<Setter Property="Foreground" Value="{Binding Path='(c:DIYGrid.Column).font_color', RelativeSource={RelativeSource AncestorType=Border}, Converter={x:Static cv:ColorToBrushConverter.Instance}}"/>
<Setter Property="HorizontalAlignment" Value="{Binding Path='(c:DIYGrid.Column).horizontal_alignment', RelativeSource={RelativeSource AncestorType=Border}}"/>
<Setter Property="VerticalAlignment" Value="Center"/>
</Style>
</UserControl.Resources>
<AdornerDecorator>
<Grid>
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<Grid Margin="4,6">
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="*"/>
</Grid.ColumnDefinitions>
<TextBlock VerticalAlignment="Center">Account:</TextBlock>
<ComboBox Grid.Column="1" Margin="8,0" ItemsSource="{Binding accounts}" SelectedItem="{Binding selected_account}"/>
</Grid>
<c:DIYGrid
Grid.Row="1"
c:DIYGrid.ColumnModels="{Binding columns}"
c:DIYGrid.SyncWithColumnGeometry="True"
Rows="{Binding rows}"
RowHeight="{u:DPIDouble 21.6}"
>
<c:DIYGrid.Resources>
<ResourceDictionary Source="/view/Controls/DataGridEx/Filters/Views/FilterTemplates.xaml"/>
</c:DIYGrid.Resources>
<c:DIYGrid.Columns>
<c:DIYGridColumnCollection/>
</c:DIYGrid.Columns>
<c:DIYGrid.CachedColumnParams>
<x:Array Type="{x:Type sys:String}">
<sys:String>font_weight</sys:String>
<sys:String>font_size</sys:String>
<sys:String>font_brush</sys:String>
<sys:String>font_family</sys:String>
<sys:String>horizontal_alignment</sys:String>
</x:Array>
</c:DIYGrid.CachedColumnParams>
<c:DIYGrid.RowTemplate>
<DataTemplate DataType="{x:Type risk:RiskLimitsVM}">
<Grid c:DIYGrid.SyncWithColumnGeometry="True" Height="{Binding RowHeight, RelativeSource={RelativeSource AncestorType=c:DIYGrid}}">
<!--Security-->
<c:TextCell
c:DIYGrid.ColumnKey="Security"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[Security]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Text="{Binding security_text}"
Style="{StaticResource TextCell}"
/>
<c:TextCell
c:DIYGrid.ColumnKey="SecurityKey"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[SecurityKey]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Text="{Binding security_key}"
Style="{StaticResource TextCell}"
/>
<!--Position-->
<c:TextCell
c:DIYGrid.ColumnKey="MaxNetLongPosition"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[MaxNetLongPosition]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Text="{Binding max_long_position}"
Style="{StaticResource TextCell}"
/>
<c:TextCell
c:DIYGrid.ColumnKey="MaxNetShortPosition"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[MaxNetShortPosition]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Text="{Binding max_short_position}"
Style="{StaticResource TextCell}"
/>
<Border
c:DIYGrid.ColumnKey="IsPositionLimitEnabled"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[IsPositionLimitEnabled]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Style="{StaticResource CellBorder}"
>
<CheckBox
IsChecked="{Binding is_position_limit_enabled}"
Style="{StaticResource LimitToggleSwitch}"
/>
</Border>
<!--Clip-->
<c:TextCell
c:DIYGrid.ColumnKey="ClipLimit"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[ClipLimit]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Text="{Binding clip_limit}"
Style="{StaticResource TextCell}"
/>
<Border
c:DIYGrid.ColumnKey="IsClipLimitEnabled"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[IsClipLimitEnabled]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Style="{StaticResource CellBorder}"
>
<CheckBox
IsChecked="{Binding is_clip_limit_enabled}"
Style="{StaticResource LimitToggleSwitch}"
/>
</Border>
<!--Price-->
<c:TextCell
c:DIYGrid.ColumnKey="MinPrice"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[MinPrice]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Text="{Binding min_price, StringFormat='#,0.0000'}"
Style="{StaticResource TextCell}"
/>
<c:TextCell
c:DIYGrid.ColumnKey="MaxPrice"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[MaxPrice]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Text="{Binding max_price, StringFormat='#,0.0000'}"
Style="{StaticResource TextCell}"
/>
<Border
c:DIYGrid.ColumnKey="IsPriceLimitEnabled"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[IsPriceLimitEnabled]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Style="{StaticResource CellBorder}"
>
<CheckBox
IsChecked="{Binding is_price_limit_enabled}"
Style="{StaticResource LimitToggleSwitch}"
/>
</Border>
<!--<Border
c:DIYGrid.ColumnKey="IsDirty"
c:DIYGrid.Column="{Binding Path='DataContext.column_map[IsDirty]', RelativeSource={RelativeSource AncestorType=c:DIYGrid}}"
Style="{StaticResource CellBorder}"
>
<Image Source="{x:Static u:Icons.CheckMark}" Visibility="{Binding is_persisted, Converter={StaticResource BooleanToVisibilityConverter}}"/>
</Border>-->
</Grid>
</DataTemplate>
</c:DIYGrid.RowTemplate>
</c:DIYGrid>
</Grid>
</AdornerDecorator>
</UserControl>
@@ -0,0 +1,33 @@
using mbts.ui.controls;
using System.Windows.Controls;
namespace bts.shell.risk_management {
/// <summary>
/// Interaction logic for RiskManagementControl.xaml
/// </summary>
partial class RiskManagementControl : UserControl {
public RiskManagementControl() {
InitializeComponent();
}
public enum Columns {
None,
Security,
MaxNetLongPosition,
MaxNetShortPosition,
ClipLimit,
MinPrice,
MaxPrice,
IsPositionLimitEnabled,
IsClipLimitEnabled,
IsPriceLimitEnabled,
SecurityKey
}
}
class RiskManagementColumn : DIYGrid.ColumnBase<RiskManagementControl.Columns> {
protected override void on_key_initialized(RiskManagementControl.Columns key) {
id = key.ToString();
}
}
}
@@ -2,6 +2,7 @@
using bts.api.position;
using bts.shell.fills;
using bts.shell.manual_fills;
using bts.shell.risk_management;
using bts.spark;
using mbts.persist;
using mbts.spark;
@@ -27,6 +28,7 @@ namespace bts.shell {
readonly PNLWindowFactory _plwf;
readonly AlgoStudioWindowFactory _aswf;
readonly ManualFillsWindowFactory _mfwf;
readonly RiskManagementWindowFactory _rmwf;
//
List<SparkCommand> _actions;
@@ -54,6 +56,7 @@ namespace bts.shell {
_old_plwf = new PAndLWindowFactory(this, bus, settings_hub, orders_model);
_aswf = new AlgoStudioWindowFactory(this, bus, orders_model, error_reporter);
_mfwf = new ManualFillsWindowFactory(this, bus, orders_model);
_rmwf = new RiskManagementWindowFactory(this, bus, settings_hub, orders_model.admin_model);
}
public ImageSource icon => Icons.Trades;
@@ -77,7 +80,8 @@ namespace bts.shell {
SparkCommands.PickLadder,
SparkCommands.PickOrderTicket,
SparkCommands.ShowAlgoStudio.complete(() => new AlgoStudioWindowFactory.StartupData()),
SparkCommands.ShowManualFills().complete(() => ManualFillsSettings.Default)
SparkCommands.ShowManualFills().complete(() => ManualFillsSettings.Default),
SparkCommands.ShowRiskManagement.complete(() => RiskManagementSettings.Default)
});
}
return _actions;
@@ -95,6 +99,7 @@ namespace bts.shell {
yield return _old_plwf;
yield return _aswf;
yield return _mfwf;
yield return _rmwf;
}
}
+26 -273
View File
@@ -1,5 +1,6 @@
using bts;
using bts.api;
using bts.api.core;
using bts.api.orderman;
using bts.collections;
using bts.spark;
@@ -26,11 +27,13 @@ namespace mbts.spark.utilities {
public readonly Func<CustomOrderDefinition, CustomOrderDefinition> get_child;
public readonly Action<CustomOrderDefinition, CustomOrderDefinition> assign_child;
public ChildAlgoData(string name, Func<IMessage, CustomOrderDefinition> get_child_from_impl,
Action<IMessage, CustomOrderDefinition> assign_child_to_impl,
Func<CustomOrderDefinition, CustomOrderDefinition> get_child,
Action<CustomOrderDefinition, CustomOrderDefinition> assign_child)
{
public ChildAlgoData(
string name,
Func<IMessage, CustomOrderDefinition> get_child_from_impl,
Action<IMessage, CustomOrderDefinition> assign_child_to_impl,
Func<CustomOrderDefinition, CustomOrderDefinition> get_child,
Action<CustomOrderDefinition, CustomOrderDefinition> assign_child) {
//
this.name = name;
this.get_child = get_child;
this.assign_child = assign_child;
@@ -46,13 +49,19 @@ namespace mbts.spark.utilities {
static readonly OrderMetadata _default_order_metadata = new OrderMetadata { KeyBinding = "", Color = BTSColors.Orders.default_order };
readonly AdminModel _admin_model;
readonly DynamicOrderHelper _dynamic_helper;
readonly IAlgoProvider _security_algo_provider;
readonly IReadOnlyDictionary<OneOf<CustomOrderDefinition.CustomOneofCase, string>, string> _algo_abbreviation_index;
readonly IReadOnlyDictionary<string, DynamicOrderDescriptor> _dynamic_descriptors;
IDisposable _dispose;
[ImportingConstructor]
public OrderFactory(AdminModel admin_model, DynamicOrderHelper dynamic_helper) {
public OrderFactory(OrderService service, AdminModel admin_model, DynamicOrderHelper dynamic_helper, IAlgoProvider security_algo_provider) {
_admin_model = admin_model;
_dynamic_helper = dynamic_helper;
_dynamic_descriptors = service.get_registered_dynamic_order_types(new VoidMessage())
.DynamicOrderDesc
.ToDictionary(d => d.DynamicOrderType);
_security_algo_provider = security_algo_provider;
var algo_name_index = new HashSet<OneOf<CustomOrderDefinition.CustomOneofCase, string>>(OneOf<CustomOrderDefinition.CustomOneofCase, string>.ValueEqualityComparer);
// add standard types
algo_name_index.AddRange(
@@ -86,66 +95,13 @@ namespace mbts.spark.utilities {
public IEnumerable<CustomOrderDefinition.CustomOneofCase> default_order_types() =>
OrderDataHelper.exchange_order_types;
public IEnumerable<CustomOrderDefinition.CustomOneofCase> default_order_types(SecurityImmutable? security) =>
security.HasValue ? default_order_types(security.Value) : OrderDataHelper.exchange_order_types;
public IEnumerable<CustomOrderDefinition.CustomOneofCase> default_order_types(SecurityImmutable security) {
switch (security.ContractCase) {
case Security.ContractOneofCase.Synthetic: return OrderDataHelper.spreader_order_types;
default: return OrderDataHelper.exchange_order_types;
}
}
public IEnumerable<CustomOrderDefinition.CustomOneofCase> default_order_types(SecurityImmutable? security, bool is_child = false) =>
security.HasValue ? default_order_types(security.Value, is_child) : default_order_types();
public IEnumerable<TimeInForce> default_time_in_forces() =>
EnumHelper.get_values_except(TimeInForce.Undefined);
public IEnumerable<TimeInForce> default_time_in_forces(SecurityImmutable security, bool is_child = false) =>
default_time_in_forces();
public IEnumerable<TimeInForce> default_time_in_forces(SecurityImmutable security, CustomOrderDefinition.CustomOneofCase order_type, bool is_child = false) {
var tifs = default_time_in_forces(security, is_child);
var tifs = EnumHelper.get_values_except(TimeInForce.Undefined);
if (order_type != CustomOrderDefinition.CustomOneofCase.Limit) {
tifs = tifs.Except(new[] { TimeInForce.Ioc });
}
return tifs;
}
public IEnumerable<TimeInForce> default_time_in_forces(SecurityImmutable? security, bool is_child = false) =>
security.HasValue ? default_time_in_forces(security.Value, is_child) : default_time_in_forces();
public LadderSettings default_ladder_settings(SecurityImmutable security) {
var settings = LadderSettings.Default;
if (security.ContractCase == Security.ContractOneofCase.Synthetic)
settings.default_order_type = CustomOrderDefinition.CustomOneofCase.Spreader;
return settings;
}
public Dictionary<AlgoKey, AlgoData> default_algos() =>
default_algos((SecurityImmutable?)null);
public Dictionary<AlgoKey, AlgoData> default_algos(SecurityImmutable? security) =>
default_algos(default_order_types(security));
public Dictionary<AlgoKey, AlgoData> default_algos(AlgoFormats algo_format) =>
default_algos(OrderDataHelper.get_format_algo_types(algo_format));
public Dictionary<AlgoKey, AlgoData> default_algos(IEnumerable<CustomOrderDefinition.CustomOneofCase> types) {
var def_map = new Dictionary<AlgoKey, AlgoData>();
foreach (var ot in types.Except(new[] { CustomOrderDefinition.CustomOneofCase.Dynamic, CustomOrderDefinition.CustomOneofCase.Composite })) {
var data = AlgoData.from_custom_def(OrderDataHelper.Defaults.CustomOrderDefinitionImmutable(ot));
def_map[data.key] = data;
}
var dynamic_defs = new List<CustomOrderDefinitionImmutable>();
_dynamic_helper.add_dynamic_order_defs(dynamic_defs, custom_order);
foreach (var dd in dynamic_defs) {
var data = AlgoData.from_custom_def(dd);
def_map[data.key] = data;
}
return def_map;
}
#endregion
public OrderDefinitionImmutable order(SecurityImmutable security) =>
@@ -156,7 +112,7 @@ namespace mbts.spark.utilities {
SecurityKey = security.Id,
Side = Side.Buy,
TimeInForce = TimeInForce.Day,
CustomDef = custom_order(),
CustomDef = OrderDataHelper.Defaults.CustomOrderDefinition(),
CtiCode = CTICode.CtiCode1,
CustomerOrFirm = CustomerOrFirm.Firm,
// this will be the tag 50 on CME orders
@@ -173,9 +129,6 @@ namespace mbts.spark.utilities {
return rv;
}
public string abbreviate_algo(CustomOrderDefinitionImmutable defi) =>
abbreviate_algo(_simple_algo_id(defi));
public string abbreviate_algo(OneOf<CustomOrderDefinition.CustomOneofCase, string> id) {
if (id == null)
throw new ArgumentNullException(nameof(id));
@@ -187,26 +140,6 @@ namespace mbts.spark.utilities {
}
// mutable definitions
public CustomOrderDefinition custom_order() => OrderDataHelper.Defaults.CustomOrderDefinition();
public MarketOrderDefinition market_order() => OrderDataHelper.Defaults.MarketOrderDefinition();
public LimitOrderDefinition limit_order() => OrderDataHelper.Defaults.LimitOrderDefinition();
public StopOrderDefinition stop_order() => OrderDataHelper.Defaults.StopOrderDefinition();
public StopLimitOrderDefinition stop_limit_order() => OrderDataHelper.Defaults.StopLimitOrderDefinition();
public GLBXIcebergOrderDefinition glbx_iceberg_order() => OrderDataHelper.Defaults.GLBXIcebergOrderDefinition();
public IcebergOrderDefinition iceberg_order() => OrderDataHelper.Defaults.IcebergOrderDefinition();
public TimeBoxOrderDefinition time_box_order() => OrderDataHelper.Defaults.TimeBoxOrderDefinition();
public TickOrderDefinition tick_order() => OrderDataHelper.Defaults.TickOrderDefinition();
public LeanOrderDefinition lean_order() => OrderDataHelper.Defaults.LeanOrderDefinition();
public JoinOrderDefinition join_order() => OrderDataHelper.Defaults.JoinOrderDefinition();
public TopOrderDefinition top_order() => OrderDataHelper.Defaults.TopOrderDefinition();
public CoverOrderDefinition cover_order() => OrderDataHelper.Defaults.CoverOrderDefinition();
public OCOOrderDefinition oco_order() => OrderDataHelper.Defaults.OCOOrderDefinition();
public PricerOrderDefinition pricer_order() => OrderDataHelper.Defaults.PricerOrderDefinition();
public OffsetOrderDefinition offset_order() => OrderDataHelper.Defaults.OffsetOrderDefinition();
public TriggerOrderDefinition trigger_order() => OrderDataHelper.Defaults.TriggerOrderDefinition();
public DynamicOrderDefinition dynamic_order() => OrderDataHelper.Defaults.DynamicOrderDefinition();
public SpreaderOrderDefinition spreader_order() => OrderDataHelper.Defaults.SpreaderOrderDefinition();
public SplitterOrderDefinition splitter_order() => OrderDataHelper.Defaults.SplitterOrderDefinition();
public SpreaderOrderDefinition spreader_order(SecurityImmutable security, ExecutionStrategyImmutable strategy) =>
new SpreaderOrderDefinition {
Security = security.CloneToMutable(),
@@ -214,40 +147,8 @@ namespace mbts.spark.utilities {
};
// immutable definitions
public CustomOrderDefinitionImmutable custom_orderi(CustomOrderDefinition.CustomOneofCase order_type) => new CustomOrderDefinitionImmutable(custom_order(order_type));
public SpreaderOrderDefinitionImmutable spreader_orderi(SecurityImmutable security, ExecutionStrategyImmutable strategy) => new SpreaderOrderDefinitionImmutable(spreader_order(security, strategy));
public CustomOrderDefinition custom_order(CustomOrderDefinition.CustomOneofCase order_type) {
var rv = new CustomOrderDefinition();
switch (order_type) {
case CustomOrderDefinition.CustomOneofCase.Market: rv.Market = market_order(); break;
case CustomOrderDefinition.CustomOneofCase.Limit: rv.Limit = limit_order(); break;
case CustomOrderDefinition.CustomOneofCase.Stop: rv.Stop = stop_order(); break;
case CustomOrderDefinition.CustomOneofCase.StopLimit: rv.StopLimit = stop_limit_order(); break;
case CustomOrderDefinition.CustomOneofCase.GlbxIceberg: rv.GlbxIceberg = glbx_iceberg_order(); break;
case CustomOrderDefinition.CustomOneofCase.Iceberg: rv.Iceberg = iceberg_order(); break;
case CustomOrderDefinition.CustomOneofCase.TimeBox: rv.TimeBox = time_box_order(); break;
case CustomOrderDefinition.CustomOneofCase.Tick: rv.Tick = tick_order(); break;
case CustomOrderDefinition.CustomOneofCase.Lean: rv.Lean = lean_order(); break;
case CustomOrderDefinition.CustomOneofCase.Join: rv.Join = join_order(); break;
case CustomOrderDefinition.CustomOneofCase.Top: rv.Top = top_order(); break;
case CustomOrderDefinition.CustomOneofCase.Cover: rv.Cover = cover_order(); break;
case CustomOrderDefinition.CustomOneofCase.Oco: rv.Oco = oco_order(); break;
case CustomOrderDefinition.CustomOneofCase.Pricer: rv.Pricer = pricer_order(); break;
case CustomOrderDefinition.CustomOneofCase.Offset: rv.Offset = offset_order(); break;
case CustomOrderDefinition.CustomOneofCase.Trigger: rv.Trigger = trigger_order(); break;
case CustomOrderDefinition.CustomOneofCase.Spreader: rv.Spreader = spreader_order(); break;
case CustomOrderDefinition.CustomOneofCase.Splitter: rv.Splitter = splitter_order(); break;
case CustomOrderDefinition.CustomOneofCase.Dynamic: rv.Dynamic = dynamic_order(); break;
//case CustomOrderDefinition.CustomOneofCase.QueueHolder: rv.QueueHolder = queue_holder_order(); break;
default:
OrderTypeVMFactory.GenericOrderFactory.setup_generic_custom_order(rv, order_type);
break;
}
return rv;
}
public OrderMetadata get_metadata(IMessage order_type_def) => get_metadata(OrderDataHelper.get_order_type(order_type_def));
public OrderMetadata get_metadata(OrderRecordImmutable order) => get_metadata(order.Def.CustomDef.CustomCase);
public OrderMetadata get_metadata(CustomOrderDefinition.CustomOneofCase order_type) {
switch (order_type) {
@@ -278,14 +179,6 @@ namespace mbts.spark.utilities {
public void Dispose() =>
Disposable.dispose(ref _dispose);
static OneOf<CustomOrderDefinition.CustomOneofCase, string> _simple_algo_id(CustomOrderDefinitionImmutable defi) {
switch (defi.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Dynamic:
return new OneOf<CustomOrderDefinition.CustomOneofCase, string>(defi.Dynamic.DynamicOrderType);
default: return new OneOf<CustomOrderDefinition.CustomOneofCase, string>(defi.CustomCase);
}
}
}
static class OrderDataHelper {
@@ -301,8 +194,6 @@ namespace mbts.spark.utilities {
}
}
public static OneofDescriptor oneof_descriptor => _oneof_desc;
const double _price_error_margin = 0.0000001;
const decimal _price_error_margin_decimal = 0.0000001m;
@@ -320,10 +211,10 @@ namespace mbts.spark.utilities {
});
public static readonly IComparer<decimal> PriceComparerDecimal = Comparer<decimal>.Create((a, b) => {
decimal diff = a - b;
if (diff <= _price_error_margin_decimal && diff >= -_price_error_margin_decimal)
return 0;
return diff > 0 ? 1 : -1;
decimal diff = a - b;
if (diff <= _price_error_margin_decimal && diff >= -_price_error_margin_decimal)
return 0;
return diff > 0 ? 1 : -1;
});
const string _primary_child_field = "child";
@@ -378,7 +269,7 @@ namespace mbts.spark.utilities {
switch (cd.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Composite: studio = cd.Composite.AlgoTemplateKey; break;
case CustomOrderDefinition.CustomOneofCase.Dynamic: dyn = cd.Dynamic.DynamicOrderType; break;
case CustomOrderDefinition.CustomOneofCase.Spreader: spreader_sec = cd.Spreader.Security.Id; break;
case CustomOrderDefinition.CustomOneofCase.Spreader: spreader_sec = cd.Spreader.Security?.Id ?? 0; break;
}
yield return (cd.CustomCase, dyn, studio, spreader_sec);
}
@@ -466,22 +357,6 @@ namespace mbts.spark.utilities {
child_data.TryGetFirst(out best_match) ? best_match : (ChildAlgoData?)null;
}
public static CustomOrderDefinition create_algo(CustomOrderDefinition.CustomOneofCase algo_type) {
var algo = new CustomOrderDefinition();
if (_algo_type_case_descriptor_data.TryGetValue(algo_type, out AlgoTypeCaseDescriptorData desc))
desc.type_case_descriptor.Accessor.SetValue(algo, ProtoHelper.mutable_factory(ProtoHelper.get_field_type(desc.type_case_descriptor)));
return algo;
}
public static bool append_algo_node(CustomOrderDefinition target, CustomOrderDefinition.CustomOneofCase algo_type) {
if (_algo_type_case_descriptor_data.TryGetValue(algo_type, out var desc)) {
var node = ProtoHelper.mutable_factory(ProtoHelper.get_field_type(desc.type_case_descriptor));
desc.type_case_descriptor.Accessor.SetValue(target, node);
return true;
}
return false;
}
public static IReadOnlyList<ChildAlgoData> get_child_algo_data(CustomOrderDefinition.CustomOneofCase algo_type) =>
_algo_type_case_descriptor_data.TryGetValue(algo_type, out AlgoTypeCaseDescriptorData d) ? d.child_algo_data : Array.Empty<ChildAlgoData>();
#endregion
@@ -535,122 +410,10 @@ namespace mbts.spark.utilities {
}
}
public static AlgoFormats get_algo_format(Security.ContractOneofCase? security_type) =>
security_type.HasValue ? get_algo_format(security_type.Value) : AlgoFormats.Exchange;
public static AlgoFormats get_algo_format(Security.ContractOneofCase security_type) =>
security_type == Security.ContractOneofCase.Synthetic ? AlgoFormats.Spreader : AlgoFormats.Exchange;
public static HashSet<CustomOrderDefinition.CustomOneofCase> get_format_algo_types(AlgoFormats f) {
var rv = new HashSet<CustomOrderDefinition.CustomOneofCase>();
if ((f & AlgoFormats.Exchange) == AlgoFormats.Exchange) {
rv.AddRange(exchange_order_types);
if ((f & AlgoFormats.Spreader) == AlgoFormats.Spreader) {
rv.IntersectWith(spreader_order_types);
}
} else if ((f & AlgoFormats.Spreader) == AlgoFormats.Spreader) {
rv.AddRange(spreader_order_types);
}
if ((f & AlgoFormats.Attachable) == AlgoFormats.Attachable)
rv.AddRange(attachable_order_types);
if ((f & AlgoFormats.DefaultPlaceholder) == AlgoFormats.DefaultPlaceholder)
rv.Add(CustomOrderDefinition.CustomOneofCase.None);
return rv;
}
public static CustomOrderDefinition.CustomOneofCase get_default_algo(AlgoFormats f) {
switch (f) {
case AlgoFormats.Exchange: return CustomOrderDefinition.CustomOneofCase.Limit;
case AlgoFormats.Spreader: return CustomOrderDefinition.CustomOneofCase.Spreader;
default: return CustomOrderDefinition.CustomOneofCase.None;
}
}
public static IReadOnlyDictionary<AlgoKey, AlgoData> get_format_algo_data(AlgoFormats f) {
var algo_types = get_format_algo_types(f);
var algo_dict = algo_types.Select(at => AlgoData.from_custom_def(Defaults.CustomOrderDefinitionImmutable(at))).ToDictionaryCrushed(a => a.key);
return algo_dict;
}
public static HashSet<CustomOrderDefinition.CustomOneofCase> get_algo_types_present(CustomOrderDefinitionImmutable def) {
return new HashSet<CustomOrderDefinition.CustomOneofCase>(impl(def.CloneToMutable()));
// hide mutable-def implementation
IEnumerable<CustomOrderDefinition.CustomOneofCase> impl(CustomOrderDefinition mdef) {
yield return mdef.CustomCase;
foreach (var sd in get_child_algo_data(mdef)) {
var child = sd.get_child(mdef);
if (child != null) {
yield return child.CustomCase;
foreach (var t in impl(child))
yield return t;
}
}
}
}
public static CustomOrderDefinitionImmutable? fit_to_type(CustomOrderDefinitionImmutable defi, Security.ContractOneofCase security_type, bool fit_all_to_spreader = false) {
var mdef = defi.CloneToMutable();
public static CustomOrderDefinition.CustomOneofCase get_default_algo(Security.ContractOneofCase security_type) {
switch (security_type) {
case Security.ContractOneofCase.Synthetic:
mdef = spreader_impl(mdef);
break;
default:
mdef = outright_impl(mdef);
break;
}
if (mdef == null)
return null;
return new CustomOrderDefinitionImmutable(mdef);
// local methods
CustomOrderDefinition spreader_impl(CustomOrderDefinition def) {
if (def == null) {
def = new CustomOrderDefinition { Spreader = new SpreaderOrderDefinition() };
} else {
switch (def.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Limit:
case CustomOrderDefinition.CustomOneofCase.None:
def = new CustomOrderDefinition { Spreader = new SpreaderOrderDefinition() };
break;
case CustomOrderDefinition.CustomOneofCase.Stop:
case CustomOrderDefinition.CustomOneofCase.StopLimit:
case CustomOrderDefinition.CustomOneofCase.Market:
case CustomOrderDefinition.CustomOneofCase.GlbxIceberg:
def = fit_all_to_spreader ? new CustomOrderDefinition { Spreader = new SpreaderOrderDefinition() } : null;
break;
default:
var desc_data = _algo_type_case_descriptor_data[def.CustomCase];
foreach (var cad in desc_data.child_algo_data) {
var child = spreader_impl(cad.get_child(def));
if (child == null)
return null;
var type_def = (IMessage)desc_data.type_case_descriptor.Accessor.GetValue(def);
cad.assign_child_to_impl(type_def, child);
}
break;
}
}
return def;
}
CustomOrderDefinition outright_impl(CustomOrderDefinition def) {
if (def == null) {
def = new CustomOrderDefinition { Limit = new LimitOrderDefinition() };
} else {
switch (def.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Spreader:
case CustomOrderDefinition.CustomOneofCase.None:
def = new CustomOrderDefinition { Limit = new LimitOrderDefinition() };
break;
default:
foreach (var cad in get_child_algo_data(def)) {
var child = outright_impl(cad.get_child(def));
if (child == null)
return null;
cad.assign_child(def, child);
}
break;
}
}
return def;
case Security.ContractOneofCase.Synthetic: return CustomOrderDefinition.CustomOneofCase.Spreader;
default: return CustomOrderDefinition.CustomOneofCase.Limit;
}
}
@@ -678,7 +441,7 @@ namespace mbts.spark.utilities {
CustomOrderDefinition.CustomOneofCase.Iceberg,
CustomOrderDefinition.CustomOneofCase.Lean,
CustomOrderDefinition.CustomOneofCase.Join,
CustomOrderDefinition.CustomOneofCase.Cover,
CustomOrderDefinition.CustomOneofCase.Cover,
CustomOrderDefinition.CustomOneofCase.Top,
CustomOrderDefinition.CustomOneofCase.Splitter,
CustomOrderDefinition.CustomOneofCase.Scratch,
@@ -764,12 +527,6 @@ namespace mbts.spark.utilities {
public static bool equals(CustomOrderDefinitionImmutable a, CustomOrderDefinitionImmutable b) => custom_order_defi_comparer.Equals(a, b);
public static bool structure_equals(CustomOrderDefinitionImmutable a, CustomOrderDefinitionImmutable b) {
return impl(a.CloneToMutable(), b.CloneToMutable());
bool impl(CustomOrderDefinition ma, CustomOrderDefinition mb) =>
ma.CustomCase == mb.CustomCase && get_child_algo_data(ma).All(cad => impl(cad.get_child(ma), cad.get_child(mb)));
}
public static bool iceberg_equals(IcebergOrderDefinitionImmutable a, IcebergOrderDefinitionImmutable b) =>
a.ShowQuantity.Equals(b.ShowQuantity) && a.HasChild ? b.HasChild && equals(a.Child, b.Child) : !b.HasChild;
@@ -1031,7 +788,6 @@ namespace mbts.spark.utilities {
}
};
public static OrderDefinitionImmutable OrderDefinitionImmutable { get; } = new OrderDefinitionImmutable(OrderDefinition);
public static OrderRecordImmutable OrderRecordImmutable { get; } = new OrderRecordImmutable(OrderRecord);
public static CustomOrderDefinition CustomOrderDefinition() => new CustomOrderDefinition { Limit = LimitOrderDefinition() };
@@ -1084,9 +840,6 @@ namespace mbts.spark.utilities {
public static TriggerOrderDefinition TriggerOrderDefinition() => new TriggerOrderDefinition { Child = CustomOrderDefinition(), TriggerCondition = new TriggerCondition(), TriggerAction = new TriggerAction(), };
public static DynamicOrderDefinition DynamicOrderDefinition() => new DynamicOrderDefinition();
public static SpreaderOrderDefinition SpreaderOrderDefinition() => new SpreaderOrderDefinition { ExecutionStrategy = new ExecutionStrategy() };
public static SplitterOrderDefinition SplitterOrderDefinition() => new SplitterOrderDefinition();
}
}
}
@@ -82,13 +82,8 @@ namespace mbts.spark {
CustomSort = AlgoCollectionHelper.algo_definition_vm_comparer.to_non_generic(),
IsLiveSorting = true
};
algo_definitions_view.Filter = d => {
if (d.key.mode == AlgoKey.Mode.Persisted && _algo_metadata.TryGetValue(d.key, out AlgoDefinitionMetadata meta) && meta.is_hidden)
return false;
var sec_fmt = OrderDataHelper.get_algo_format(security.ContractCase);
return (d.selected_format & sec_fmt) == sec_fmt;
};
_algo_definitions_view.LiveFilteringProperties.Add(nameof(AlgoDefinitionVM.selected_format));
algo_definitions_view.Filter = d =>
!(d.key.mode == AlgoKey.Mode.Persisted && _algo_metadata.TryGetValue(d.key, out AlgoDefinitionMetadata meta) && meta.is_hidden);
_algo_definitions_view.LiveSortingProperties.Add(nameof(AlgoDefinitionVM.group));
_algo_definitions_view.LiveSortingProperties.Add(nameof(AlgoDefinitionVM.name));
algo_definitions_view.GroupDescriptions.Add(new PropertyGroupDescription(nameof(AlgoDefinitionVM.group)));
@@ -167,33 +162,27 @@ namespace mbts.spark {
undo_definition_observer,
redo_definition_observer,
revert_definition_observer),
security_md_source.Select(smd => model.factory.default_algos(smd.security)).Table(s => s.key).Subscribe(factory_defs => {
using (_selected_algo_definition.begin_update())
AlgoCollectionHelper.update_persisted_definitions(_algo_definitions, factory_defs, fd => {
var vm = AlgoDefinitionVM.create(_model, fd, init_format: OrderDataHelper.get_algo_format(security.ContractCase), editing_permissions: AlgoEditingPermissions.AllowEditValues);
vm.selected_format = OrderDataHelper.get_algo_format(security.ContractCase);
return vm;
});
}),
model.algo_model.definitions.Subscribe(_definitions_buffer),
_definitions_buffer.OnDispatcher().Subscribe(u => {
AlgoCollectionHelper.update_persisted_definitions(_algo_definitions, u, def_data => {
var def_vm = AlgoDefinitionVM.create(model, def_data, OrderDataHelper.get_algo_format(security.ContractCase), AlgoEditingPermissions.AllowEditValues);
def_vm.selected_format = OrderDataHelper.get_algo_format(security.ContractCase);
def_vm.favorite_index = _get_favorite_algo_index(def_vm.key);
return def_vm;
});
security_source.SelectManyInSeries(model.subscribe_algo_meta_tuples)
.OnDispatcher()
.Subscribe(table => {
using (_selected_algo_definition.begin_update()) {
foreach (var (algo, meta) in table.removed)
_algo_definitions.Remove(algo.key);
foreach (var (algo, meta) in table.changed) {
var vm = _algo_definitions[algo.key];
vm.load(algo);
vm.favorite_index = _get_favorite_algo_index(vm.key);
}
foreach (var (algo, meta) in table.added) {
var vm = AlgoDefinitionVM.create(_model, algo, AlgoEditingPermissions.AllowEditValues);
vm.favorite_index = _get_favorite_algo_index(vm.key);
_algo_definitions.Add(vm);
}
}
}),
model.algo_model.metadata_service.subscribe_metadata().OnDispatcher().Subscribe(_on_template_metadata),
ObservableAutoWrapper.connect_item_hooks(algo_definitions, vm =>
Disposable.Create(
vm.connect_data(nullable_security_md_source),
security_source.Subscribe(s => {
var fmt = OrderDataHelper.get_algo_format(s.ContractCase);
foreach (var d in algo_definitions)
d.selected_format = fmt;
}),
vm),
Disposable.Create(vm.connect_data(nullable_security_md_source), vm),
true)) {
() => Disposable.dispose(ref _algo_param_rows_hook)
};
@@ -325,13 +314,11 @@ namespace mbts.spark {
public bool open_algo_popup_on_select { get => _open_algo_popup_on_select; set => Set(ref _open_algo_popup_on_select, value); }
// commands
public ICommand save_definition_cmd { get; }
public ICommand save_template_cmd { get; }
public ICommand revert_definition_cmd { get; }
public ICommand set_default_algo_params_cmd { get; }
public ICommand revert_algo_params_cmd { get; }
public ICommand undo_definition_cmd { get; }
public ICommand redo_definition_cmd { get; }
public ICommand remove_template_cmd { get; }
public ICommand toggle_is_favorite_cmd { get; }
public IObservable<AccountTuple?> observe_account(bool start_immediately = false) =>
@@ -396,4 +383,4 @@ namespace mbts.spark {
algo_definitions_view.Refresh();
}
}
}
}
@@ -4,9 +4,7 @@ using mbts.ui;
using System;
using System.Collections.Specialized;
using System.Reactive.Linq;
using System.Threading.Tasks;
using AlgoDef = bts.api.orderman.CustomOrderDefinition;
using AlgoDefi = bts.api.orderman.CustomOrderDefinitionImmutable;
using CompositeDef = bts.api.orderman.CompositeOrderDefinition;
using CompositeDefi = bts.api.orderman.CompositeOrderDefinitionImmutable;
@@ -21,6 +19,7 @@ namespace mbts.spark {
: base(id, display_name, editing_permissions) { }
public override string abbreviation => _studio_meta?.abbreviation ?? base.abbreviation;
public override AlgoDisplayGroup group => AlgoDisplayGroup.Studio;
public override OrderMetadata meta {
get {
var m = new OrderMetadata { KeyBinding = string.Empty, NoProps = false };
@@ -66,4 +65,4 @@ namespace mbts.spark {
protected override void validate() => base.validate();
}
}
}
}
@@ -8,7 +8,6 @@ using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Threading.Tasks;
using System.Windows.Input;
using AlgoDef = bts.api.orderman.CustomOrderDefinition;
using AlgoDefi = bts.api.orderman.CustomOrderDefinitionImmutable;
@@ -19,7 +18,6 @@ namespace mbts.spark {
static readonly AlgoDefi _empty = new AlgoDefi(new AlgoDef());
readonly ObservableAggregateCollection<IAlgoParamVM> _algo_params = new ObservableAggregateCollection<IAlgoParamVM>();
readonly VersionContainer<AlgoDefi> _definition;
AlgoFormats _format;
AlgoEditingPermissions _editing_permissions;
SecurityMD? _security_md;
OrdersModel _model;
@@ -84,10 +82,8 @@ namespace mbts.spark {
void IObserver<SecurityMD?>.OnNext(SecurityMD? security_md) {
var orig_group = group;
_security_md = security_md;
if (security_md.HasValue)
_format = OrderDataHelper.get_algo_format(security_md.Value.security.ContractCase);
var orig_def = definition;
var fmt_type = OrderDataHelper.get_default_algo(_format);
var fmt_type = OrderDataHelper.get_default_algo(security_md.HasValue ? security_md.Value.security.ContractCase : bts.api.Security.ContractOneofCase.None);
switch (fmt_type) {
case AlgoType.None: _clear_impl(); break;
default:
@@ -2,7 +2,6 @@ using bts.api;
using bts.api.orderman;
using bts.utils;
using Google.Protobuf.Reflection;
using mbts.utils;
using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
@@ -15,13 +14,15 @@ namespace mbts.spark {
static readonly IReadOnlyDictionary<DynamicOrderParam.ValueOneofCase, (FieldDescriptor field_descriptor, Type field_type)> _descriptor_case_index =
ProtoHelper.get_oneof_descriptor_index<DynamicOrderParam, DynamicOrderParam.ValueOneofCase>(nameof(DynamicOrderParam.ValueCase));
readonly RegisteredDynamicOrderTypes _dynamic_types;
readonly Dictionary<string, DynamicOrderDescriptor> _dyn_types = new Dictionary<string, DynamicOrderDescriptor>(StringComparer.CurrentCultureIgnoreCase);
[ImportingConstructor]
DynamicOrderHelper(OrderService order_service) =>
_dynamic_types = order_service.get_registered_dynamic_order_types(new VoidMessage());
DynamicOrderHelper(OrderService order_service) {
foreach (var dt in order_service.get_registered_dynamic_order_types(new VoidMessage()).DynamicOrderDesc)
_dyn_types[dt.DynamicOrderType] = dt;
}
public IEnumerable<string> dynamic_types => _dynamic_types.DynamicOrderDesc.Select(d => d.DynamicOrderType);
public IEnumerable<string> dynamic_types => _dyn_types.Keys;
public static string fmt_param(DynamicOrderParam dyn_param) {
if (dyn_param == null)
@@ -50,7 +51,7 @@ namespace mbts.spark {
}
public void add_dynamic_order_defs(List<CustomOrderDefinitionImmutable> defs, Func<CustomOrderDefinition.CustomOneofCase, CustomOrderDefinition> factory) {
foreach (var d in _dynamic_types.DynamicOrderDesc) {
foreach (var d in _dyn_types.Values) {
var dorder = factory(CustomOrderDefinition.CustomOneofCase.Dynamic);
dorder.Dynamic.DynamicOrderType = d.DynamicOrderType;
var ddef = dorder.Dynamic;
@@ -60,8 +61,20 @@ namespace mbts.spark {
}
}
public bool try_parse(string str, out string dynamic_type) {
if (_dyn_types.TryGetValue(str, out var desc)) {
dynamic_type = desc.DynamicOrderType;
return true;
}
dynamic_type = null;
return false;
}
internal DynamicOrderDescriptor get_descriptor(string dynamic_type) =>
_dynamic_types.DynamicOrderDesc.FirstOrDefault(d => d.DynamicOrderType == dynamic_type) ?? new DynamicOrderDescriptor();
_dyn_types.TryGetValue(dynamic_type, out var desc) ? desc : new DynamicOrderDescriptor();
internal CustomOrderDefinitionImmutable create_custom_defi(string dynamic_type) =>
new CustomOrderDefinitionImmutable(new CustomOrderDefinition { Dynamic = create_def(dynamic_type) });
internal DynamicOrderDefinition create_def(string dynamic_type) {
var desc = get_descriptor(dynamic_type);
@@ -122,12 +122,6 @@ namespace mbts.spark {
public static Color safe_get_badge_color(this IAlgoVM vm) =>
vm == null ? default : vm.meta.Color.rgb_color();
public static IDisposable load_algo_data_recursive(this IAlgoSelector selector, IReadOnlyDictionary<AlgoKey, AlgoData> algo_data, AlgoKey? default_algo) {
selector.load_algo_data(algo_data, default_algo);
return ObservableAutoWrapper.connect_item_hooks(selector.algos, vm =>
ObservableAutoWrapper.connect_item_hooks(vm.child_algo_selectors, s => load_algo_data_recursive(s, algo_data, default_algo)));
}
public static IEnumerable<IAlgoParamVM> enumerate_all_params(this IAlgoVM vm) =>
vm == null ? Enumerable.Empty<IAlgoParamVM>() : vm.algo_params.Concat(vm.child_algo_selectors.SelectMany(s => enumerate_all_params(s.selected_algo)));
@@ -1,16 +1,82 @@
using bts.api.orderman;
using mbts.ui;
using System;
using System.Reactive;
using System.Reactive.Linq;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
class IcebergOrderVM : OrderTypeVMBase<IcebergOrderDefinition, IcebergOrderDefinitionImmutable> {
readonly Property<double> _show_quantity;
readonly DisplayQuantityMultiplier<double> _display_qty_translator = DisplayQuantityMultiplier.create_double();
new IDisposable _dispose;
public IcebergOrderVM(AlgoKey key, string display_name, AlgoEditingPermissions editing_permissions)
: base(key, display_name, editing_permissions) {
_show_quantity = add_property(nameof(show_quantity), IcebergOrderDefinition.ShowQuantityFieldNumber, double.NaN, double.NaN);
_show_quantity = add_property(
"show_quantity",
IcebergOrderDefinition.ShowQuantityFieldNumber,
double.NaN,
double.NaN,
to_display_value: v => _qty_conversion.to_display(v),
from_display_value: v => _qty_conversion.from_display(v),
refresh_display_value:
Observable.Create<Unit>(o => {
_request_refresh_display += refresh;
return Disposable.Create(() => _request_refresh_display -= refresh);
void refresh() =>
o.OnNext(Unit.Default);
}));
_show_quantity.Changed += on_show_quantity_changed;
_dispose = Disposable.Create(
_display_qty_translator.connect_owner(this, nameof(display_show_quantity)),
_display_qty_translator.subscribe_actual_value().Subscribe(v => _show_quantity.Value = v),
Disposable.Create(() => _show_quantity.Changed -= on_show_quantity_changed));
void on_show_quantity_changed(double oldval, double newval) =>
_display_qty_translator.actual_value = newval;
}
public double show_quantity { get => _show_quantity.Value; set => _show_quantity.set(value); }
event Action _request_refresh_display;
public double display_show_quantity {
get => _display_qty_translator.display_value;
set => _display_qty_translator.display_value = value;
}
QuantityConversionData _qty_conversion {
get => _display_qty_translator.conversion_data;
set {
if (_display_qty_translator.conversion_data != value) {
_display_qty_translator.conversion_data = value;
_request_refresh_display?.Invoke();
}
}
}
protected override void on_model_internal() =>
_refresh_display();
protected override void on_security_internal() =>
_refresh_display();
void _refresh_display() {
if (model == null) {
_qty_conversion = default;
} else {
var divisor = model.security_auxiliary_model.get_display_quantity_divisor(security);
if (divisor == 1 || divisor == 0) {
_qty_conversion = default;
} else {
_qty_conversion = new QuantityConversionData(divisor, QuantityConversionData.OpType.DivideActual);
}
}
}
protected override void Dispose(bool disposing) {
Disposable.dispose(ref _dispose);
base.Dispose(disposing);
}
}
}
}
}
@@ -18,6 +18,7 @@ using System.Collections.Specialized;
using System.ComponentModel;
using System.Dynamic;
using System.Linq;
using System.Reactive;
using System.Reactive.Disposables;
using System.Reactive.Linq;
using System.Runtime.CompilerServices;
@@ -61,7 +62,9 @@ namespace mbts.spark {
public static IAlgoVM composite(AlgoKey key, string display_name, AlgoEditingPermissions editing_permissions) => new CompositeAlgoVM(key, display_name, editing_permissions);
public static IAlgoVM create(AlgoData def_data, AlgoEditingPermissions editing_permissions = default_editing_permissions, bool is_expanded = false) {
var vm = create(def_data.key, def_data.name, def_data.value.CustomCase, editing_permissions, is_expanded);
var vm = def_data.key.is_persisted ?
new CompositeAlgoVM(def_data.key, def_data.name, editing_permissions) :
create(def_data.key, def_data.name, def_data.value.CustomCase, editing_permissions, is_expanded);
vm.load_from(def_data.value);
return vm;
}
@@ -79,7 +82,7 @@ namespace mbts.spark {
case AlgoType.Join: vm = join(key, name, editing_permissions); break;
case AlgoType.Top: vm = top(key, name, editing_permissions); break;
case AlgoType.Cover: vm = cover(key, name, editing_permissions); break;
case AlgoType.Oco : return oco(key, name, editing_permissions);
case AlgoType.Oco: return oco(key, name, editing_permissions);
case AlgoType.Pricer: return pricer(key, name, editing_permissions);
case AlgoType.Offset: vm = offset(key, name, editing_permissions); break;
case AlgoType.Trigger: vm = trigger(key, name, editing_permissions); break;
@@ -87,13 +90,10 @@ namespace mbts.spark {
case AlgoType.Iceberg: vm = iceberg(key, name, editing_permissions); break;
case AlgoType.Spreader: vm = spreader(key, name, editing_permissions); break;
case AlgoType.Dynamic: vm = dynamic(key, name, name, editing_permissions); break;
case AlgoType.Splitter: vm = splitter(key,name,editing_permissions); break;
case AlgoType.Splitter: vm = splitter(key, name, editing_permissions); break;
case AlgoType.Composite: vm = composite(key, name, editing_permissions); break;
case AlgoType.None: vm = new DefaultAlgoVM(); break;
default: vm = generic(key, name, algo_type, editing_permissions); break;
//default:
// Log.Ui.debug_fatal($"Failed to create {typeof(IAlgoVM)}: unknown algo type '{algo_type}.'");
// return new DefaultAlgoVM();
}
vm.is_expanded = is_expanded && vm.can_expand;
return vm;
@@ -269,12 +269,7 @@ namespace mbts.spark {
void selector_load_impl(AlgoSelectorData sd) {
var inner_def = sd.get_order(value);
if (inner_def.HasValue) {
if (security.HasValue) {
inner_def = OrderDataHelper.fit_to_type(inner_def.Value, security.Value.ContractCase);
if (!inner_def.HasValue)
return;
}
if (inner_def.HasValue && inner_def.Value.CustomCase != AlgoType.None) {
var ival = inner_def.Value;
var vm = sd.selector.algos.GetOrAdd(
AlgoKey.from_custom_def(ival),
@@ -317,18 +312,12 @@ namespace mbts.spark {
}
AlgoKey key;
if (security.HasValue) {
init = OrderDataHelper.fit_to_type(init.Value, security.Value.ContractCase);
if (!init.HasValue)
return;
key = AlgoKey.from_custom_def(init.Value);
child_list.Add(init.Value);
for (int i = 1; i < algos.Count; i++) {
var child = sd.get_from_impl(algos[i]);
if (!child.HasValue || key != AlgoKey.from_custom_def(child.Value))
return;
child = OrderDataHelper.fit_to_type(child.Value, security.Value.ContractCase);
if (!child.HasValue)
return;
child_list.Add(child.Value);
}
} else {
@@ -372,7 +361,6 @@ namespace mbts.spark {
}),
c.assign_child);
}
_populate_selectors();
}
// local methods
IDisposable reset() {
@@ -415,9 +403,19 @@ namespace mbts.spark {
#endregion
#region Auto-Properties (non-child-algo params)
protected Property<T> add_property<T>(string prop_name, int target_field_number, T init_value = default, T non_uniform_value = default, bool validate_on_changed = false, AlgoParamPermissions permissions = AlgoParamPermissions.ReadWrite) {
protected Property<T> add_property<T>(
string prop_name,
int target_field_number,
T init_value = default,
T non_uniform_value = default,
bool validate_on_changed = false,
AlgoParamPermissions permissions = AlgoParamPermissions.ReadWrite,
Func<T, T> to_display_value = null,
Func<T, T> from_display_value = null,
IObservable<Unit> refresh_display_value = null) {
//
var prop = backing(prop_name, init_value);
_on_property_added(prop_name, target_field_number, prop, prop.set, non_uniform_value, validate_on_changed, permissions);
_on_property_added(prop_name, target_field_number, prop, prop.set, non_uniform_value, validate_on_changed, permissions, to_display_value, from_display_value, refresh_display_value);
return prop;
}
@@ -592,17 +590,25 @@ namespace mbts.spark {
}
}
void _on_property_added<T>(string prop_name, int target_field_number, IProperty<T> prop, Action<T> assign_to_prop, T non_uniform_value, bool validate_on_changed, AlgoParamPermissions permissions) {
void _on_property_added<T>(string prop_name, int target_field_number, IProperty<T> prop, Action<T> assign_to_prop, T non_uniform_value, bool validate_on_changed, AlgoParamPermissions permissions, Func<T, T> to_display_value = null, Func<T, T> from_display_value = null, IObservable<Unit> refresh_display_value = null) {
var field_desc = new TMutable().Descriptor.FindFieldByNumber(target_field_number);
var param = new AlgoParamVM<T>(prop_name, DisplayNameHelper.snake_to_title_case(prop_name), prop.Value) { permissions = permissions };
var param = new AlgoParamVM<T>(prop_name, DisplayNameHelper.snake_to_title_case(prop_name), prop.Value, EqualityComparer<T>.Default, null, to_display_value, from_display_value) {
permissions = permissions
};
_algo_params.Add(param);
var prop_hook = _link_props(param, prop, assign_to_prop, non_uniform_value, validate_on_changed);
if (refresh_display_value != null) {
prop_hook = Disposable.Create(
refresh_display_value.Subscribe(_ => param.refresh_display_value()),
prop_hook);
}
_auto_props.Add(new AutoProp(prop_name, mval => {
if (mval != null && param.has_value)
field_desc.Accessor.SetValue(mval, prop.Value);
},
mval => assign_to_prop_and_commit(mval == null ? default : ConvertUtils.try_convert<T>(field_desc.Accessor.GetValue(mval))),
mvals => assign_to_prop_and_commit(mvals.Select(v => ConvertUtils.try_convert<T>(field_desc.Accessor.GetValue(v))).Distinct().SafeSingleOrDefault(non_uniform_value)),
_link_props(param, prop, assign_to_prop, non_uniform_value, validate_on_changed)));
prop_hook));
void assign_to_prop_and_commit(T value) {
assign_to_prop(value);
param.mark_committed();
@@ -814,8 +820,6 @@ namespace mbts.spark {
return Disposable.Create(() => {
if (security != old_sec) {
on_security_internal();
if (_editing_permissions.HasFlag(AlgoEditingPermissions.AllowEditStructure))
_populate_selectors();
_security_changed?.Invoke(security);
}
if (security_md != old_sec_md)
@@ -823,21 +827,6 @@ namespace mbts.spark {
});
}
IDisposable _selector_data_hooks;
void _populate_selectors() {
if (model != null && security.HasValue) {
var algo_data = model.factory.default_algos(security.Value);
var default_algo = AlgoKey.from_known_type(OrderDataHelper.get_default_algo(OrderDataHelper.get_algo_format(security.Value.ContractCase)));
foreach (var sd in _child_algo_selectors)
sd.load_algo_data_recursive(algo_data, default_algo);
Disposable.dispose(ref _selector_data_hooks);
_selector_data_hooks = ObservableAutoWrapper.connect_item_hooks(child_algo_selectors, s => {
s.load_algo_data_recursive(algo_data, default_algo);
return Disposable.empty;
});
}
}
class AutoProp : IDisposable {
public readonly string name;
public readonly Action<TMutable> assign, load;
@@ -924,6 +913,7 @@ namespace mbts.spark {
AlgoParamPermissions _permissions = AlgoParamPermissions.ReadWrite;
IReadOnlyDictionary<AlgoKey, AlgoData> _pending_data;
AlgoKey? _pending_default;
IDisposable _loaded_data_hook;
public AlgoSelector(string id, string display_name) {
this.id = id;
@@ -1020,8 +1010,11 @@ namespace mbts.spark {
void _sync_formats() {
if (initialized && _pending_data != null) {
var fmt_algos = _pending_data;
algos.SyncWithDictionary(fmt_algos, d => create(d, is_expanded: true));
Disposable.dispose(ref _loaded_data_hook);
var data = _pending_data;
algos.SyncWithDictionary(data, d => create(d, is_expanded: true));
_loaded_data_hook = ObservableAutoWrapper.connect_item_hooks(algos, vm =>
ObservableAutoWrapper.connect_item_actions(vm.child_algo_selectors, s => s.load_algo_data(data, null)));
if (_algo == null || !algos.ContainsKey(_algo.id)) {
if (_pending_default.HasValue && algos.TryGetValue(_pending_default.Value, out IAlgoVM match))
selected_algo = match;
@@ -138,7 +138,7 @@ namespace mbts.spark {
new DialogSkirtItem("Save Strategy", commit);
void _ensure_init() {
if (_vm == null && _model != null && _template.HasValue && _template.Value.HasSecurity) {
if (_vm == null && _model != null && _template.HasValue && _template.Value.HasSecurity && _template.Value.HasExecutionStrategy) {
Log.isnull(_save_strategy_item);
Log.isnull(_vm_strategy_sub);
var tmp = _template.Value;
+30 -8
View File
@@ -32,6 +32,7 @@ namespace mbts.spark {
public readonly ISecurityAuxiliaryDataModel security_auxiliary_model;
readonly IBus _bus;
readonly IAlgoProvider _algo_provider, _attachable_algo_provider;
readonly OrderFactory _factory;
readonly OrderService _service;
readonly PositionService _position_service;
@@ -57,6 +58,8 @@ namespace mbts.spark {
IAlgoStudioModel algo_model,
ISecurityAuxiliaryDataModel security_auxiliary_model,
MarketDataAuxiliaryModel md_auxiliary_model,
IAlgoProvider algo_provider,
IAttachableAlgoProvider attachable_algo_provider,
SecurityStore sstore,
ErrorReporter error) {
//
@@ -67,6 +70,8 @@ namespace mbts.spark {
_mbo_service = mbo_service;
_spreader = spreader;
_error = error;
_algo_provider = algo_provider;
_attachable_algo_provider = attachable_algo_provider;
_dynamic_helper = dynamic_helper;
this.admin_model = admin_model;
this.algo_model = algo_model;
@@ -314,6 +319,9 @@ namespace mbts.spark {
public MBOService mbo_service => _mbo_service;
public IAlgoStudioModel algo_model { get; }
public AlgoTypeSetImmutable get_permitted_algos(SecurityImmutable security) =>
_algo_provider.get_permitted_algos(security);
public IObservable<TableUpdate<OrderSecurity, uint>> on_security_working_orders_with_piq(uint security) =>
_security_working_orders_with_piq_demuxer.subscribe(security);
@@ -322,6 +330,15 @@ namespace mbts.spark {
public IObservable<TableUpdate<(SecurityImmutable?, PositionUnitImmutable), int>> on_security_positions(uint security) =>
_security_positions_demuxer.subscribe(security);
public IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_algos(bool attachable_only = false) =>
(attachable_only ? _attachable_algo_provider : _algo_provider).subscribe_algos();
public IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_algos(SecurityImmutable security, bool attachable_only = false) =>
(attachable_only ? _attachable_algo_provider : _algo_provider).subscribe_algos(security);
public IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_complete_algos(bool attachable_only = false, bool allow_undefined_child = false) =>
(attachable_only ? _attachable_algo_provider : _algo_provider).subscribe_complete_algos(allow_undefined_child);
#endregion
#region Input
@@ -634,14 +651,10 @@ namespace mbts.spark {
}).Select(r => r.last_update);
public static IObservable<TableUpdate<(AlgoData algo, AlgoDefinitionMetadata? meta), AlgoKey>> subscribe_all_algos(this OrdersModel orders_model) =>
orders_model.studio_algos_with_meta.MergeTable(Observable.Return(
new TableUpdate<(AlgoData algo, AlgoDefinitionMetadata? meta), AlgoKey>(
ImmutableDictionary<AlgoKey, (AlgoData algo, AlgoDefinitionMetadata? meta)>.Empty.AddRange(orders_model.factory.default_algos(OrderDataHelper.all_order_types).Select(kv => new KeyValuePair<AlgoKey, (AlgoData algo, AlgoDefinitionMetadata? meta)>(kv.Key, (kv.Value, null)))),
Array.Empty<(AlgoData, AlgoDefinitionMetadata?)>(),
Array.Empty<Change<(AlgoData, AlgoDefinitionMetadata?)>>(),
Array.Empty<(AlgoData, AlgoDefinitionMetadata?)>(),
d => d.algo.key
).as_snapshot()));
_subscribe_algo_meta_tuples(orders_model, orders_model.subscribe_algos());
public static IObservable<TableUpdate<(AlgoData algo, AlgoDefinitionMetadata? meta), AlgoKey>> subscribe_algo_meta_tuples(this OrdersModel orders_model, SecurityImmutable security) =>
_subscribe_algo_meta_tuples(orders_model, orders_model.subscribe_algos(security));
public static async Task<OrderRecordImmutable?> order_from_key(this OrdersModel orders_model, uint order_key) {
(var tu, var success) = await orders_model.on_orders.FirstAsyncTask(t => t.state.ContainsKey(order_key), TimeSpan.FromSeconds(3));
@@ -684,6 +697,15 @@ namespace mbts.spark {
return false;
}
static IObservable<TableUpdate<(AlgoData algo, AlgoDefinitionMetadata? meta), AlgoKey>> _subscribe_algo_meta_tuples(OrdersModel orders_model, IObservable<TableUpdate<AlgoData, AlgoKey>> algos) =>
algos.LeftJoin(
orders_model.algo_model.metadata_service.subscribe_metadata().Table(AlgoDefinitionMetadata.key_fn),
AlgoData.key_fn,
AlgoDefinitionMetadata.key_fn,
(algo, key, meta) => (algo, (AlgoDefinitionMetadata?)meta),
(algo, key) => (algo, (AlgoDefinitionMetadata?)null),
tup => tup.algo.key);
class RootOrderData {
public readonly SetMap<uint, uint> parent_to_children = new SetMap<uint, uint>();
public TableUpdateTransform<OrderRecordImmutable, uint> last_update { get; set; } = new TableUpdateTransform<OrderRecordImmutable, uint>();
+35 -12
View File
@@ -155,9 +155,32 @@ namespace bts {
Disposable.dispose(ref _dispose);
}
public IObservable<Update<(SecurityImmutable? sec, T val), TKey>> join<T,TKey>(
IObservable<Update<T, TKey>> source, Func<T,security_key> skeyfn) where TKey : IEquatable<TKey> {
return Observable.Create<Update<(SecurityImmutable?, T), TKey>>(observer => {
public IObservable<Update<(SecurityImmutable? sec, T val), TKey>> join<T, TKey>(
IObservable<Update<T, TKey>> source, Func<T, security_key> skeyfn) where TKey : IEquatable<TKey> {
return join(source, skeyfn, get_incremental_props, mk_update);
(IEnumerable<T> all, IEnumerable<T> added, IEnumerable<Change<T>> changes, IEnumerable<T> removed, Func<T, TKey> key_extractor) get_incremental_props(Update<T, TKey> upd_in) =>
(upd_in.all, upd_in.added, upd_in.changes, upd_in.removed, upd_in.key_extractor);
Update<(SecurityImmutable? sec, T val), TKey> mk_update(
IEnumerable<(SecurityImmutable? sec, T val)> all,
IEnumerable<(SecurityImmutable? sec, T val)> added,
IEnumerable<Change<(SecurityImmutable? sec, T val)>> changes,
IEnumerable<(SecurityImmutable? sec, T val)> removed,
Func<(SecurityImmutable?, T), TKey> key_extractor) =>
//
new Update<(SecurityImmutable? sec, T val), TKey>(
all, added, changes, removed, key_extractor);
}
public IObservable<TOut> join<TIn, T, TKey, TOut>(
IObservable<TIn> source,
Func<T,security_key> skeyfn,
Func<TIn, (IEnumerable<T> all, IEnumerable<T> added, IEnumerable<Change<T>> changes, IEnumerable<T> removed, Func<T, TKey> key_extractor)> get_incremental_props,
Func<IEnumerable<(SecurityImmutable? sec, T val)>, IEnumerable<(SecurityImmutable? sec, T val)>, IEnumerable<Change<(SecurityImmutable? sec, T val)>>, IEnumerable<(SecurityImmutable? sec, T val)>, Func<(SecurityImmutable?, T), TKey>, TOut> create_result_update)
where TKey : IEquatable<TKey> {
//
return Observable.Create<TOut>(observer => {
var state = ImmutableDictionary<TKey, (SecurityImmutable? s, T t)>.Empty;
var gate = new object();
// We get thie function from the first source update
@@ -186,11 +209,11 @@ namespace bts {
state = builder.ToImmutable();
// fire update
observer.OnNext(
new Update<(SecurityImmutable?, T), TKey>(
state.Values,
Enumerable.Empty<(SecurityImmutable?,T)>(),
changed,
Enumerable.Empty<(SecurityImmutable?,T)>(),
create_result_update(
state.Values,
Enumerable.Empty<(SecurityImmutable?, T)>(),
changed,
Enumerable.Empty<(SecurityImmutable?, T)>(),
rowkeyfn));
}
}
@@ -198,10 +221,11 @@ namespace bts {
return Disposable.Create(
// Fire update when source changes
source.Subscribe((update) => {
source.Subscribe((update_in) => {
var update = get_incremental_props(update_in);
lock (gate) {
rowkeyfn = rowkeyfn ?? (i => update.key_extractor(i.Item2));
var relevant_securities = get_and_ensure_securities(update.added.Concat(update.changed).Select(skeyfn));
var relevant_securities = get_and_ensure_securities(update.added.Concat(update.changes.New()).Select(skeyfn));
var added = new List<(SecurityImmutable?, T)>();
var changed = new List<Change<(SecurityImmutable? s, T t)>>();
@@ -238,8 +262,7 @@ namespace bts {
}
state = builder.ToImmutable();
observer.OnNext(new Update<(SecurityImmutable?, T t), TKey>(
state.Values, added, changed, removed, rowkeyfn));
observer.OnNext(create_result_update(state.Values, added, changed, removed, rowkeyfn));
}
}),
// Also fire update when securities change
@@ -28,6 +28,9 @@ namespace bts.spark {
public static PartialCommand<bts.shell.orderbook.OrderBookStartupData> ShowOrders =>
SparkCommand.create("Order Book", Icons.Book, SparkTags.ShowOrderBookTag);
public static PartialCommand<shell.risk_management.RiskManagementSettings> ShowRiskManagement =>
SparkCommand.create("Risk Management", Icons.Risk, SparkTags.ShowRiskManagement);
// Fills
public static PartialCommand<FillsSettings> ShowFills(KeyGesture key_gesture = null) =>
SparkCommand.create("Fills", Icons.Payment, SparkTags.ShowFillsTag, key_gesture);
+1
View File
@@ -63,6 +63,7 @@ namespace mbts.spark {
public static ITag<IObservable<SecurityMD>> ShowLinkedLadder { get; } = new SparkTag<IObservable<SecurityMD>>("Linked Ladder");
public static ITag<SecurityCriteria> ShowMarketViewTag { get; } = new SparkTag<SecurityCriteria>("Show MarketView");
public static ITag<bts.shell.orderbook.OrderBookStartupData> ShowOrderBookTag { get; } = new SparkTag<bts.shell.orderbook.OrderBookStartupData>(nameof(ShowOrderBookTag));
public static ITag<bts.shell.risk_management.RiskManagementSettings> ShowRiskManagement { get; } = new SparkTag<bts.shell.risk_management.RiskManagementSettings>(nameof(ShowRiskManagement));
public static ITag<PAndLWindowFactory.PAndLStartupData> ShowPAndLTag { get; } = new SparkTag<PAndLWindowFactory.PAndLStartupData>(nameof(ShowPAndLTag));
public static ITag<bts.shell.pnl.PNLSettings> ShowPNLTag { get; } = new SparkTag<bts.shell.pnl.PNLSettings>(nameof(ShowPNLTag));
public static ITag<(SecurityImmutable security, ExecutionStrategyImmutable strategy)> ShowSyntheticCloneTag { get; } = new SparkTag<(SecurityImmutable security, ExecutionStrategyImmutable strategy)>(nameof(ShowSyntheticCloneTag));
@@ -17,6 +17,7 @@ namespace bts.settings {
interface IMarketViewGridSettingsMigrationRule : ISettingsMigrationRule<GridSettings> { }
interface IPAndLGridSettingsMigrationRule : ISettingsMigrationRule<GridSettings> { }
interface IPNLSettingsMigrationRule : ISettingsMigrationRule<PNLSettings> { }
interface IRiskManagementMigrationRule : ISettingsMigrationRule<GridSettings> { }
interface ISyntheticManagementMigrationRule : ISettingsMigrationRule<GridSettings> { }
static class SettingsMigrationHelper {
@@ -61,6 +61,8 @@ namespace mbts.spark {
PNLSettings _pnl;
[ProtoMember(14)]
GlobalAlertSettings _alerts;
[ProtoMember(15)]
GridSettings _risk_management_grid;
public UserSettings() { }
@@ -74,6 +76,7 @@ namespace mbts.spark {
public GridSettings market_view_grid => _market_view_grid ?? (_market_view_grid = bts.shell.MarketViewWindowFactory.StartupData.DefaultGridSettings);
public GridSettings time_and_sales_grid => _time_and_sales_grid ?? (_time_and_sales_grid = GridSettings.Default.with(bts.shell.time_and_sales.TimeAndSalesSettings.DefaultColumns.all));
public GridSettings fills_grid => _fills_grid ?? (_fills_grid = bts.shell.fills.FillsSettings.DefaultGridSettings);
public GridSettings risk_management_grid => _risk_management_grid ?? (_risk_management_grid = bts.shell.risk_management.RiskManagementSettings.DefaultGrid);
public GridSettings synthetic_management_grid => _synthetic_management_grid ?? (_synthetic_management_grid = bts.shell.SyntheticManagementWindowFactory.StartupData.DefaultGridSettings);
public GridSettings pnl_grid => _pnl_grid ?? (_pnl_grid = bts.shell.PAndLWindowFactory.PAndLStartupData.DefaultGridSettings);
public PNLSettings pnl => _pnl ?? (_pnl = PNLSettings.Default);
@@ -91,7 +94,8 @@ namespace mbts.spark {
GridSettings provided_pnl_gridsettings = null,
PNLSettings pnl = null,
bts.shell.orderbook.OrderBookGridSettings order_book_grid = null,
GlobalAlertSettings alerts = null) {
GlobalAlertSettings alerts = null,
GridSettings risk_management_grid = null) {
var us = new UserSettings(ladder_profiles ?? _ladder_profiles) {
_ladder = ladder ?? _ladder,
_notification = notification ?? _notification,
@@ -102,7 +106,8 @@ namespace mbts.spark {
_pnl_grid = provided_pnl_gridsettings ?? _pnl_grid,
_pnl = pnl ?? _pnl,
_order_book_grid = order_book_grid ?? _order_book_grid,
_alerts = alerts ?? _alerts
_alerts = alerts ?? _alerts,
_risk_management_grid = risk_management_grid ?? _risk_management_grid
};
us._last_ladder_profile_id = Math.Max(_last_ladder_profile_id, us.ladder_profiles.Select(p => p.id).MaxOrDefault());
return us;
@@ -26,6 +26,7 @@ namespace mbts.persist {
_fills_propi = ImmutableProperty.create<UserSettings, GridSettings>(us => us.fills_grid, (us, gs) => us.with(provided_fills_gridsettings: gs)),
_mview_propi = ImmutableProperty.create<UserSettings, GridSettings>(us => us.market_view_grid, (us, gs) => us.with(provided_market_view_gridsettings: gs)),
_pandl_propi = ImmutableProperty.create<UserSettings, GridSettings>(us => us.pnl_grid, (us, gs) => us.with(provided_pnl_gridsettings: gs)),
_risk_propi = ImmutableProperty.create<UserSettings, GridSettings>(us => us.risk_management_grid, (us, gs) => us.with(risk_management_grid: gs)),
_synth_propi = ImmutableProperty.create<UserSettings, GridSettings>(us => us.synthetic_management_grid, (us, gs) => us.with(provided_synthetic_management_gridsettings: gs));
static readonly IImmutableProperty<UserSettings, PNLSettings>
@@ -37,6 +38,7 @@ namespace mbts.persist {
readonly IEnumerable<IMarketViewGridSettingsMigrationRule> _mview_migration_rules;
readonly IEnumerable<IPAndLGridSettingsMigrationRule> _pandl_migration_rules;
readonly IEnumerable<IPNLSettingsMigrationRule> _pnl_migration_rules;
readonly IEnumerable<IRiskManagementMigrationRule> _risk_migration_rules;
readonly IEnumerable<ISyntheticManagementMigrationRule> _synth_migration_rules;
readonly IUserPersist _persist;
@@ -49,6 +51,7 @@ namespace mbts.persist {
[ImportMany]IEnumerable<IMarketViewGridSettingsMigrationRule> mview_migration_rules,
[ImportMany]IEnumerable<IPAndLGridSettingsMigrationRule> pandl_migration_rules,
[ImportMany]IEnumerable<IPNLSettingsMigrationRule> pnl_migration_rules,
[ImportMany]IEnumerable<IRiskManagementMigrationRule> risk_migration_rules,
[ImportMany]IEnumerable<ISyntheticManagementMigrationRule> synth_migration_rules) {
//
_persist = persist;
@@ -56,6 +59,7 @@ namespace mbts.persist {
_mview_migration_rules = mview_migration_rules ?? Enumerable.Empty<IMarketViewGridSettingsMigrationRule>();
_pandl_migration_rules = pandl_migration_rules ?? Enumerable.Empty<IPAndLGridSettingsMigrationRule>();
_pnl_migration_rules = pnl_migration_rules ?? Enumerable.Empty<IPNLSettingsMigrationRule>();
_risk_migration_rules = risk_migration_rules ?? Enumerable.Empty<IRiskManagementMigrationRule>();
_synth_migration_rules = synth_migration_rules ?? Enumerable.Empty<ISyntheticManagementMigrationRule>();
init();
async void init() {
@@ -68,6 +72,7 @@ namespace mbts.persist {
_mview_migration_rules.merge().wrap(_mview_propi),
_pandl_migration_rules.merge().wrap(_pandl_propi),
_pnl_migration_rules.merge().wrap(_pnl_propi),
_risk_migration_rules.merge().wrap(_risk_propi),
_synth_migration_rules.merge().wrap(_synth_propi)
};
SettingsMigrationHelper.apply_quiet(ref s, wrapped_rules);
@@ -142,6 +147,12 @@ namespace mbts.persist {
_pnl_migration_rules,
_pnl_propi);
public IWindowSettingsManager<GridSettings> create_risk_management_settings_manager(GridSettings instance_settings) =>
_create_settings_manager(
instance_settings,
_risk_migration_rules,
_risk_propi);
public IWindowSettingsManager<GridSettings> create_synth_settings_manager(GridSettings instance_settings) =>
_create_settings_manager(
instance_settings,
@@ -170,4 +181,4 @@ namespace mbts.persist {
}
}
}
}
}
@@ -3,6 +3,7 @@ using mbts;
using mbts.ui.shell;
using mbts.utils;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
@@ -10,6 +11,13 @@ using System.Reactive.Linq;
using System.Reflection;
namespace bts.utils {
class PropertyEqualityComparerAttribute : Attribute {
public PropertyEqualityComparerAttribute(Type comparer_type) =>
this.comparer_type = comparer_type ?? throw new ArgumentNullException(nameof(comparer_type));
public Type comparer_type { get; }
}
interface IPropertyChangedDetector<T> where T : IRaiseNotifyPropertyChanged {
IDisposable detect_changes(T target);
}
@@ -68,6 +76,42 @@ namespace bts.utils {
public static IObservable<bool> dirty_monitor<T>(T instance, PropertyInfo[] props) where T : INotifyPropertyChanged =>
_dirty_monitor(instance, props.ToDictionary(p => p.Name, p => new PropNode(p, p.GetValue(instance))));
public static Func<T, int> property_hash_code_delegate<T>(string prop) =>
DelegateStore<T>.property_hash_code(prop);
public static Func<T, int> property_hash_code_delegate<T>(IEnumerable<string> props) {
var prop_hash_code_dels = props.Select(DelegateStore<T>.property_hash_code).ExceptNull().ToArray();
return impl;
int impl(T a) =>
EqualityComparer.auto_phase(prop_hash_code_dels.Select(peq => peq(a)));
}
public static Func<T, T, bool> property_equals_delegate<T>(string prop) =>
DelegateStore<T>.property_equals(prop);
public static Func<T, T, bool> property_equals_delegate<T>(IEnumerable<string> props) {
var prop_equals_dels = props.Select(DelegateStore<T>.property_equals).ExceptNull().ToArray();
return impl;
bool impl(T a, T b) =>
prop_equals_dels.All(peq => peq(a, b));
}
public static IEqualityComparer<T> property_equality_comparer<T>() {
var prop_infos = PropertyInfoStore<T>.all_props;
return property_equality_comparer<T>(
prop_infos.Select(p => p.Name),
// hash code should NEVER include mutable props
prop_infos.Where(pi => !pi.CanWrite).Select(p => p.Name));
}
public static IEqualityComparer<T> property_equality_comparer<T>(IEnumerable<string> props) =>
property_equality_comparer<T>(props, props);
public static IEqualityComparer<T> property_equality_comparer<T>(IEnumerable<string> equals_props, IEnumerable<string> hash_code_props) =>
EqualityComparer.Create(
property_equals_delegate<T>(equals_props),
property_hash_code_delegate<T>(hash_code_props));
static IObservable<bool> _dirty_monitor<T>(T instance, Dictionary<string, PropNode> prop_map) where T : INotifyPropertyChanged =>
Observable.Create<bool>(o => {
var dirty_props = new HashSet<string>();
@@ -106,6 +150,8 @@ namespace bts.utils {
PropertyInfo prop_info { get; }
Func<T, object> getter { get; }
Action<T, object> setter { get; }
Func<T, T, bool> property_equals { get; }
Func<T, int> property_hash_code { get; }
(Action<T> initialize, Func<T, bool> refresh) create_snapshot();
(Action initialize, Func<bool> refresh) create_snapshot(T source);
}
@@ -139,6 +185,15 @@ namespace bts.utils {
public static Action<T, object> setter(string prop_name) =>
accessor_data.TryGetValue(prop_name, out var dels) ? dels.setter : null;
public static Func<T, T, bool> property_equals(string prop_name) =>
accessor_data.TryGetValue(prop_name, out var dels) ? dels.property_equals : null;
public static Func<T, int> property_hash_code(string prop_name) =>
accessor_data.TryGetValue(prop_name, out var dels) ? dels.property_hash_code : null;
public static IPropertyAccessorData<T> get_accessor(string prop_name) =>
accessor_data.GetValueOrDefault(prop_name);
static DelegateStore() {
var prop_dels = new Dictionary<string, IPropertyAccessorData<T>>();
var accessor_type_cache = new Dictionary<Type, Type>();
@@ -185,6 +240,7 @@ namespace bts.utils {
class PropertyAccessorData<T, TValue> : IPropertyAccessorData<T, TValue> {
readonly Func<T, object> _ng_get;
readonly Action<T, object> _ng_set;
IEqualityComparer<TValue> _property_equals_comp;
public PropertyAccessorData(PropertyInfo prop_info) {
this.prop_info = prop_info;
@@ -200,11 +256,27 @@ namespace bts.utils {
setter = set_method.CreateDelegate(typeof(Action<T, TValue>)) as Action<T, TValue>;
_ng_set = (src, val) => setter(src, (TValue)val);
}
if (prop_info.GetCustomAttribute<PropertyEqualityComparerAttribute>()?.comparer_type is Type comp_type) {
_property_equals_comp = Activator.CreateInstance(comp_type) as IEqualityComparer<TValue>;
}
if (_property_equals_comp is null) {
_property_equals_comp = EqualityComparer<TValue>.Default;
}
}
public Func<T, TValue> getter { get; }
public Action<T, TValue> setter { get; }
public PropertyInfo prop_info { get; }
public Func<T, T, bool> property_equals {
get {
return impl;
bool impl(T a, T b) =>
_property_equals_comp.Equals(getter(a), getter(b));
}
}
public Func<T, int> property_hash_code =>
a => _property_equals_comp.GetHashCode(getter(a));
Func<T, object> IPropertyAccessorData<T>.getter => _ng_get;
Action<T, object> IPropertyAccessorData<T>.setter => _ng_set;
@@ -1,6 +1,11 @@
using System;
using bts.collections;
using bts.utils;
using mbts.ui.shell;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using System.Reactive.Linq;
namespace mbts.ui.utility {
@@ -153,6 +158,95 @@ namespace mbts.ui.utility {
_try_match_item(_item_to_value(item), out match);
}
class SelectorVM<T, TKey> {
readonly IEqualityComparer<T> _eq_comparer;
readonly IEqualityComparer<TKey> _key_comparer;
readonly Func<T, TKey> _key_fn;
readonly ObservableCollection<T> _items = new ObservableCollection<T>();
readonly Dictionary<TKey, T> _map;
/// not as noisy as <see cref="ObservableCollection{T}.CollectionChanged"/>,
/// this event is only raised after a batch collection change has been completed.
/// <see cref="update_items(IEnumerable{T})"/>.
IComparer<T> _comparer;
T _selected_item;
TKey _pending_selected_item_key;
bool _is_pending_selection;
public SelectorVM(Func<T, TKey> key_fn)
: this(key_fn, EqualityComparer<TKey>.Default) { }
public SelectorVM(Func<T, TKey> key_fn, IEqualityComparer<TKey> key_comparer) {
_key_fn = key_fn ?? throw new ArgumentNullException(nameof(key_fn));
_key_comparer = key_comparer ?? throw new ArgumentNullException(nameof(key_comparer));
_eq_comparer = EqualityComparer.Create(_key_fn, _key_comparer);
_map = new Dictionary<TKey, T>(key_comparer);
items = ObservableAutoWrapper.create_read_only_wrapper(_items);
}
public event Action selected_item_changed;
public IReadOnlyObservableCollection<T> items { get; }
public T selected_item {
get => _selected_item;
set {
if (!_eq_comparer.Equals(_selected_item, value)) {
_selected_item = value;
selected_item_changed?.Invoke();
}
}
}
public IComparer<T> comparer {
get => _comparer;
set {
_comparer = value;
if (value != null)
_update_items(items, false);
}
}
public bool try_select(T item, bool wait_for_item_to_arrive = false) =>
try_select(_key_fn(item), wait_for_item_to_arrive);
public bool try_select(TKey item_key, bool wait_for_item_to_arrive = false) {
if (_map.TryGetValue(item_key, out var item)) {
selected_item = item;
return true;
} else if (wait_for_item_to_arrive) {
_pending_selected_item_key = item_key;
_is_pending_selection = true;
}
return false;
}
public void update_items(IEnumerable<T> items) =>
_update_items(items, true);
void _update_items(IEnumerable<T> items, bool map_changed) {
// The currently selected item may be removed during this collection change.
// After the items have been changed, attempt to re-select the last selected item;
// if there is already a particular 'pending selection,' attempt to select that instead.
var target_key = _is_pending_selection ? _pending_selected_item_key : _key_fn(_selected_item);
if (map_changed)
_map.Clear();
if (items is null) {
_items.Clear();
} else {
if (_comparer != null) {
items = items.Ordered(_comparer);
}
_items.sync_with(items);
}
if (map_changed) {
foreach (var i in this.items)
_map[_key_fn(i)] = i;
}
if (_map.Count != this.items.Count)
throw new InvalidOperationException("Map and items are out of sync (different item counts).");
if (try_select(target_key, _is_pending_selection || _items.Count == 0) && _is_pending_selection)
_is_pending_selection = false;
}
}
static class SelectionModelExtensions {
public static IObservable<TValue> observe_selected_item<TItem, TValue>(this SelectionModel<TItem, TValue> selection_model, bool notify_on_subscribe = false) =>
Observable.Create<TValue>(o => {
@@ -166,4 +260,4 @@ namespace mbts.ui.utility {
return Disposable.Create(() => selection_model.Changed -= callback);
}
}
}
}
@@ -2,6 +2,7 @@
using mbts.spark.utilities;
using ProtoBuf;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Windows.Media;
@@ -119,4 +120,9 @@ namespace mbts.ui.controls.color_picker {
};
#endregion
}
static class ColorPaletteExtensions {
public static ObservableCollection<ColorPaletteVM> to_viewmodels(this IEnumerable<ColorPalette> source) =>
new ObservableCollection<ColorPaletteVM>(source.empty_if_null().Select(cp => new ColorPaletteVM(cp)));
}
}
@@ -229,7 +229,10 @@ namespace mbts.ui.controls {
public string Text { get => GetValue(TextProperty) as string; set => SetValue(TextProperty, value); }
#endregion
protected override Size ArrangeOverride(Size finalSize) => finalSize;
protected override Size ArrangeOverride(Size finalSize) {
_gcr.available_size = finalSize;
return finalSize;
}
protected override Size MeasureOverride(Size availableSize) {
_gcr.available_size = availableSize;
@@ -237,6 +237,15 @@ namespace mbts.ui.controls {
Color? _background_color_override;
object _header_copy;
bool _is_visible;
IDisposable _model_hooks;
static ColumnBase() {
WidthProperty.OverrideMetadata(typeof(ColumnBase),
new PropertyMetadata((d, e) => {
if (d is ColumnBase cb)
cb.width_changed?.Invoke((double)e.NewValue);
}));
}
protected ColumnBase() {
var gs = GridSettings.Default;
@@ -256,10 +265,25 @@ namespace mbts.ui.controls {
get => GetValue(SortDirectionProperty) as ListSortDirection?;
set => SetValue(SortDirectionProperty, value);
}
ListSortDirection? ISortableDIYGridColumn.SortDirection {
get => SortDirection;
set => SetCurrentValue(SortDirectionProperty, value);
}
#region IsVisible
public static readonly DependencyProperty IsVisibleProperty =
WPFHelper.create_dp<bool, ColumnBase>(nameof(IsVisible), (o, v) => o.is_visible = v);
public bool IsVisible {
get => (bool)GetValue(IsVisibleProperty);
set => SetValue(IsVisibleProperty, value);
}
#endregion
public event Action<ColumnBase, ListSortDirection?> sort_direction_changed;
public event Action font_params_changed;
public event Action<bool> is_visible_changed;
public event Action<double> width_changed;
public string id { get; set; }
public string sort_member_path { get; set; }
@@ -273,6 +297,7 @@ namespace mbts.ui.controls {
_is_visible = value;
is_visible_changed?.Invoke(value);
raise_prop_changed();
SetCurrentValue(IsVisibleProperty, value);
}
}
}
@@ -297,6 +322,29 @@ namespace mbts.ui.controls {
set => base.Header = (_header_copy = value);
}
public void set_model(IDIYGridColumnModel model) {
Disposable.dispose(ref _model_hooks);
model.width = Width;
width_changed += on_width_changed;
model.width_changed += on_model_width_changed;
model.result_changed += on_result_changed;
_model_hooks = Disposable.Create(() => {
width_changed -= on_width_changed;
model.width_changed -= on_model_width_changed;
});
void on_model_width_changed(double value) {
if (!DoubleUtil.AreClose(value, Width))
SetCurrentValue(WidthProperty, value);
}
void on_width_changed(double value) {
model.width_changed -= on_model_width_changed;
model.width = value;
model.width_changed += on_model_width_changed;
}
void on_result_changed() =>
load_from(model.create());
}
/// important: don't access any dependency props in here.
/// this may be called from a thread other than that of this dispatcher (i.e., when <see cref="IShellWindow.GetState(System.IO.Stream)"/> is called).
public GridColumnSettings create() =>
@@ -327,9 +375,8 @@ namespace mbts.ui.controls {
}
if (original_width != settings.width) {
original_width = settings.width;
Width = original_width;
SetCurrentValue(WidthProperty, original_width);
}
//
}
// 'fallback' font-params (aka 'grid-level' font-params)
@@ -9,10 +9,10 @@ using System.Reactive.Linq;
namespace mbts.ui {
class ColumnSortManager {
readonly List<ISortableDIYGridColumn> _visible_sorting = new List<ISortableDIYGridColumn>();
readonly IList<ISortableDIYGridColumn> _columns;
readonly IEnumerable<ISortableDIYGridColumn> _columns;
readonly string _primary_key;
public ColumnSortManager(IList<ISortableDIYGridColumn> columns, string primary_key) {
public ColumnSortManager(IEnumerable<ISortableDIYGridColumn> columns, string primary_key) {
_columns = columns;
_primary_key = primary_key;
}
@@ -1,4 +1,18 @@
namespace mbts.ui.controls {
using bts.utils;
using mbts.spark;
using mbts.spark.filters;
using mbts.ui.settings;
using mbts.ui.shell;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Windows;
using System.Windows.Media;
namespace mbts.ui.controls {
class DIYGridColumn : DIYGrid.ColumnBase<string> {
public DIYGridColumn()
: base() {
@@ -6,4 +20,194 @@
Width = 60;
}
}
interface IDIYGridColumnModel : DIYGrid.IFilterableColumn, IValueFactoryVM<GridColumnSettings> {
string id { get; }
string column_template { get; }
IComparer row_comparer { get; }
double width { get; set; }
event Action<double> width_changed;
event Action result_changed;
}
interface IDIYGridColumnFactory {
DIYGrid.ColumnBase create_view();
}
class DIYGridColumnModel<TKey> : ViewModelBase, IDIYGridColumnModel, ISortableDIYGridColumn<TKey>, ISortableDIYGridColumn, IValueFactoryVM<GridColumnSettings> where TKey : struct {
readonly DeferrableActionWrapper _result_changed;
FontWeight _fallback_font_weight;
Color _fallback_font_color;
Color _fallback_background_color;
double _fallback_font_size;
FontFamily _fallback_font_family;
double _width = 60;
bool _is_visible = true;
ListSortDirection? _sort_direction;
object _custom_header;
string _display_name;
HorizontalAlignment _horizontal_alignment = HorizontalAlignment.Left;
Color? _background_color_override, _font_color_override;
FontWeight? _font_weight_override;
public DIYGridColumnModel(TKey id, IComparer row_comparer, IDataGridColumnFilter filter, string filter_template = null, string column_template = null) {
this.id = id;
this.row_comparer = row_comparer;
this.filter = filter;
this.filter_template = filter_template;
this.column_template = column_template;
_result_changed = new DeferrableActionWrapper(() => result_changed?.Invoke());
}
public event Action result_changed;
public event Action<double> width_changed;
public TKey id { get; }
string IDIYGridColumnModel.id => id.ToString();
public IComparer row_comparer { get; }
public string display_name {
get => _display_name;
set {
if (value != _display_name) {
_display_name = value;
_result_changed.execute();
RaisePropertyChanged();
if (_custom_header is null) {
RaisePropertyChanged(nameof(header));
}
}
}
}
public object header => _custom_header ?? display_name;
public object custom_header { get => _custom_header;
set {
if (value != _custom_header) {
_custom_header = value;
RaisePropertyChanged(nameof(custom_header), nameof(header));
}
}
}
public double width {
get => _width;
set {
if (_set(ref _width, value, DoubleUtil.AreClose))
width_changed?.Invoke(value);
}
}
public bool is_visible { get => _is_visible; set => _set(ref _is_visible, value); }
public ListSortDirection? sort_direction { get => _sort_direction; set => Set(ref _sort_direction, value); }
public Color? background_color_override { get => _background_color_override; set => _set(ref _background_color_override, value); }
public Color? font_color_override { get => _font_color_override; set => _set(ref _font_color_override, value); }
public FontWeight? font_weight_override { get => _font_weight_override; set => _set(ref _font_weight_override, value); }
public FontFamily font_family => _fallback_font_family;
public FontWeight font_weight => _font_weight_override ?? _fallback_font_weight;
public Color font_color => font_color_override ?? _fallback_font_color;
public Color background_color => background_color_override ?? _fallback_background_color;
public double font_size => _fallback_font_size;
public HorizontalAlignment horizontal_alignment { get => _horizontal_alignment; set => _set(ref _horizontal_alignment, value); }
public IDataGridColumnFilter filter { get; }
public string column_template { get; }
public string filter_template { get; }
string IDIYGridColumn.id => id.ToString();
ListSortDirection? ISortableDIYGridColumn.SortDirection { get => sort_direction; set => sort_direction = value; }
public GridColumnSettings create() =>
new GridColumnSettings(
id: id.ToString(),
display_name: display_name,
is_visible: is_visible,
font_color_override: font_color_override,
font_weight_override: font_weight_override,
width: width,
background_color_override: background_color_override,
horizontal_alignment: horizontal_alignment);
public void set_fallback_font_params(FontFamily font_family, double font_size, Color font_color, FontWeight font_weight, Color background_color) {
using (ReflectionHelper.detect_property_changes(this, RaisePropertyChanged, nameof(font_family), nameof(font_size), nameof(font_color), nameof(font_weight), nameof(background_color))) {
_fallback_font_family = font_family;
_fallback_font_size = font_size;
_fallback_font_color = font_color;
_fallback_background_color = background_color;
_fallback_font_weight = font_weight;
}
}
public void load_from(GridColumnSettings value) {
if (!value.strong_id<TKey>().Equals(id))
throw new ArgumentException("Column id in settings object does not match the column model's id.", nameof(value));
using (_result_changed.defer_execution())
using (_detect_result_changed())
using (detect_property_changes(nameof(font_color), nameof(font_weight), nameof(background_color))) {
display_name = value.display_name;
is_visible = value.is_visible;
font_color_override = value.font_color_override;
font_weight_override = value.font_weight_override;
background_color_override = value.background_color_override;
width = value.width;
horizontal_alignment = value.horizontal_alignment;
}
}
IDisposable _detect_result_changed() {
var orig_state = create();
return Disposable.Create(() => {
var curr_state = create();
if (!orig_state.Equals(curr_state))
result_changed?.Invoke();
});
}
bool _set<T>(ref T backing, T new_value, [CallerMemberName]string prop = null) =>
_set(ref backing, new_value, EqualityComparer<T>.Default, prop);
bool _set<T>(ref T backing, T new_value, Func<T, T, bool> equals, [CallerMemberName] string prop = null) =>
// Technically, the GetHashCode impl could disagree with the equals delegate.
// However, this doesn't matter because the _set method only uses IEqualityComparer.Equals (not GetHashCode).
// It didn't seem worth the trouble of changing the method signature, as there is no conceivable reason why that method
// would ever be changed to use GetHashCode.
_set(ref backing, new_value, EqualityComparer.Create(equals, a => a.GetHashCode()), prop);
bool _set<T>(ref T backing, T new_value, IEqualityComparer<T> comparer, [CallerMemberName]string prop = null) {
if (Set(ref backing, new_value, comparer, prop)) {
_result_changed.execute();
return true;
}
return false;
}
}
class DIYGridColumnModel<TKey, TRow, TGridFilter> : DIYGridColumnModel<TKey> where TKey : struct {
readonly Func<TGridFilter, object> _get_column_filter_settings;
readonly Func<TGridFilter, object, TGridFilter> _set_column_filter_settings;
public DIYGridColumnModel(TKey id, IComparer<TRow> row_comparer, IDataGridColumnFilter<TRow> filter, string filter_template, Func<TGridFilter, object> get_column_filter_settings, Func<TGridFilter, object, TGridFilter> set_column_filter_settings)
: base(id, row_comparer.to_non_generic(), filter, filter_template) {
_get_column_filter_settings = get_column_filter_settings;
_set_column_filter_settings = set_column_filter_settings;
this.row_comparer = row_comparer;
this.filter = filter;
}
public new IComparer<TRow> row_comparer { get; }
public new IDataGridColumnFilter<TRow> filter { get; }
public void load_from(GridColumnSettings column_settings, TGridFilter grid_filter_settings) {
if (column_settings != null)
load_from(column_settings);
if (_get_column_filter_settings != null && grid_filter_settings != null)
filter?.load_state(_get_column_filter_settings(grid_filter_settings));
}
public TGridFilter assign_filter_settings(TGridFilter target) {
if (_set_column_filter_settings != null) {
var filter_settings = filter.get_state();
target = _set_column_filter_settings(target, filter_settings);
}
return target;
}
}
}
@@ -1,4 +1,5 @@
using bts;
using bts.collections;
using bts.utils;
using mbts.spark.filters;
using mbts.ui.controls.adorners;
@@ -867,6 +868,83 @@ namespace mbts.ui.controls {
public static void SetColumnKey(DependencyObject d, object value) => d.SetValue(ColumnKeyProperty, value);
#endregion
#region Column
public static readonly DependencyProperty ColumnProperty =
DependencyProperty.RegisterAttached("Column", typeof(object), typeof(DIYGrid), new PropertyMetadata());
public static object GetColumn(DependencyObject d) => d.GetValue(ColumnProperty);
public static void SetColumn(DependencyObject d, object value) => d.SetValue(ColumnProperty, value);
#endregion
#region ColumnModels
public static readonly DependencyProperty ColumnModelsProperty =
DependencyProperty.RegisterAttached("ColumnModels", typeof(IReadOnlyObservableCollection<IDIYGridColumn>),
typeof(DIYGrid),
new PropertyMetadata(null, OnColumnModelsChanged));
static void OnColumnModelsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) {
IDisposable hook = null;
if (e.NewValue is IEnumerable<IDIYGridColumnModel> col_models) {
resort();
if (e.NewValue is INotifyCollectionChanged col_models_notifier) {
hook = CollectionHelper.buffer_collection_changed_callback(col_models_notifier, resort, TimeSpan.FromSeconds(0.3), TimeSpan.Zero);
}
void resort() {
if (d is DIYGrid grid) {
var cols = grid.Columns;
if (cols != null) {
var col_map = cols.ToDictionary(c => c.id);
var sorted_cols = col_models.Select(cm => {
if (col_map.TryGetValue(cm.id, out var cb))
return cb;
if (cm is IDIYGridColumnFactory col_factory) {
cb = col_factory.create_view();
} else if (!string.IsNullOrEmpty(cm.column_template)) {
cb = grid.TryFindResource(cm.column_template) as ColumnBase;
}
if (cb is null) {
cb = new DIYGridColumn { id = cm.id };
BindingOperations.SetBinding(cb, ColumnBase.HeaderProperty, new Binding(nameof(DIYGridColumnModel<int>.header)) { Source = cm });
BindingOperations.SetBinding(cb, ColumnBase.SortDirectionProperty, new Binding(nameof(DIYGridColumnModel<int>.sort_direction)) { Source = cm, Mode = BindingMode.TwoWay });
cb.set_model(cm);
BindingOperations.SetBinding(cb, ColumnBase.IsVisibleProperty, new Binding(nameof(DIYGridColumnModel<int>.is_visible)) { Source = cm });
if (cm is IFilterableColumn fc) {
DataGridFilterProperties.SetFilter(cb, fc.filter);
DataGridFilterProperties.SetFilterTemplate(cb, grid.FindResource(fc.filter_template) as DataTemplate);
BindingOperations.SetBinding(cb, DataGridFilterProperties.FilterActiveProperty, new Binding(nameof(IDataGridColumnFilter.active)) { Source = fc.filter });
BindingOperations.SetBinding(cb, DataGridFilterProperties.FilterOpenProperty, new Binding(nameof(IDataGridColumnFilter.open)) { Source = fc.filter });
}
}
return cb;
}).ToList();
CollectionHelper.sync_with_never_duplicate(cols, sorted_cols);
}
}
}
}
SetColumnModelsHooks(d, hook);
}
public static IReadOnlyObservableCollection<IDIYGridColumn> GetColumnModels(DependencyObject d) =>
d.GetValue(ColumnModelsProperty) as IReadOnlyObservableCollection<IDIYGridColumn>;
public static void SetColumnModels(DependencyObject d, IReadOnlyObservableCollection<IDIYGridColumn> value) =>
d.SetValue(ColumnModelsProperty, value);
static readonly DependencyPropertyKey ColumnModelsHooksPropertyKey =
DependencyProperty.RegisterAttachedReadOnly("ColumnModelsHooks", typeof(IDisposable),
typeof(DIYGrid),
new PropertyMetadata(null, FrameworkElementLifeDependencyHelper.DisposeOld));
internal static DependencyProperty ColumnModelsHooksProperty => ColumnModelsHooksPropertyKey.DependencyProperty;
internal static IDisposable GetColumnModelsHooks(DependencyObject d) =>
d.GetValue(ColumnModelsHooksProperty) as IDisposable;
static void SetColumnModelsHooks(DependencyObject d, IDisposable value) =>
d.SetValue(ColumnModelsHooksPropertyKey, value);
#endregion
#region SyncWithColumnGeometrySource
public static readonly DependencyProperty SyncWithColumnGeometrySourceProperty =
DependencyProperty.RegisterAttached(
@@ -1,5 +1,6 @@
using bts.utils;
using mbts.spark;
using mbts.ui.controls;
using mbts.ui.settings;
using mbts.ui.shell;
using mbts.utils;
@@ -121,4 +122,111 @@ namespace mbts.ui {
}
}
}
class SimpleGridSettingsManagerVM<TColumnKey> : ViewModelBase, IObserver<GridSettings> where TColumnKey : struct {
readonly IReadOnlyList<DIYGridColumnModel<TColumnKey>> _columns;
readonly Property<GridSettings> _grid_settings;
readonly DelegateProperty<FontFamily> _font_family;
readonly DelegateProperty<FontWeight> _font_weight;
readonly DelegateProperty<double> _font_size;
readonly DelegateProperty<SolidColorBrush> _font_color, _selection_highlight, _background_color;
readonly IReadOnlyDictionary<string, ImmutableColumnSettingStore> _column_flags;
readonly Action<IEnumerable<GridColumnSettings>> _sync_column_order;
readonly Action _invalidate_rows;
public SimpleGridSettingsManagerVM(
IReadOnlyList<DIYGridColumnModel<TColumnKey>> columns,
IReadOnlyDictionary<string, GridColumnSettingsFeatureFlags> column_flags,
Action<IEnumerable<GridColumnSettings>> sync_column_order,
Action invalidate_rows) {
//
_columns = columns;
_sync_column_order = sync_column_order;
_invalidate_rows = invalidate_rows;
_column_flags = (column_flags ?? DictionaryHelper.empty<string, GridColumnSettingsFeatureFlags>())
.ToDictionary(kv => kv.Key, kv => ImmutableColumnSettingStore.create(kv.Value));
_grid_settings = backing(nameof(grid_settings), GridSettings.Default);
_font_family = backing(nameof(font_family), () => new FontFamily(grid_settings.font_family), nameof(grid_settings));
_font_weight = backing(nameof(font_weight), () => grid_settings.font_weight, nameof(grid_settings));
_font_size = backing(nameof(font_size), () => grid_settings.font_size, nameof(font_size));
_font_color = backing(nameof(font_color), () => grid_settings.font_color.rgb_solid_brush().frozen(), nameof(grid_settings));
_selection_highlight = backing(nameof(selection_highlight), () => grid_settings.selection_highlight.to_brush().frozen(), nameof(grid_settings));
_background_color = backing(nameof(background_color), () => grid_settings.background_color.argb_color().to_solid_brush().frozen(), nameof(grid_settings));
}
public GridSettings grid_settings => _grid_settings.Value;
public FontFamily font_family => _font_family.Value;
public FontWeight font_weight => _font_weight.Value;
public double font_size => _font_size.Value;
public SolidColorBrush font_color => _font_color.Value;
public SolidColorBrush selection_highlight => _selection_highlight.Value;
public SolidColorBrush background_color => _background_color.Value;
public SimpleGridSettingsVM create_vm(GridSettings settings) {
var vm = new SimpleGridSettingsVM(_column_flags.ToDictionary(kv => kv.Key, kv => kv.Value.flags));
vm.load_from(settings);
return vm;
}
public GridSettings create() {
// IMPORTANT: don't overwrite current sorting
_grid_settings.set(grid_settings.with(_columns.Select(c => {
var col_settings = c.create();
if (_column_flags.TryGetValue(c.id.ToString(), out ImmutableColumnSettingStore store))
col_settings = store.apply(col_settings);
return col_settings;
})));
return grid_settings;
}
/// <summary>
/// This will overwrite the columns' immutable-value store (unlike the IObserver&lt;<see cref="GridSettings"/>&gt; 'OnNext' implementation)
/// </summary>
public void load_from(GridSettings grid) => _load_from_core(grid, true);
void IObserver<GridSettings>.OnCompleted() { }
void IObserver<GridSettings>.OnError(Exception error) { }
void IObserver<GridSettings>.OnNext(GridSettings grid) {
if (grid.columns != null) {
var cols_with_applied_flags = grid.columns.ToList();
for (int i = 0; i < cols_with_applied_flags.Count; i++) {
if (_column_flags.TryGetValue(cols_with_applied_flags[i].id, out ImmutableColumnSettingStore store)) {
cols_with_applied_flags[i] = store.apply(cols_with_applied_flags[i]);
}
}
grid = grid.with(cols_with_applied_flags);
}
_load_from_core(grid, false);
}
void _load_from_core(GridSettings grid, bool reset_immutable_flag_stores) {
grid = grid ?? GridSettings.Default;
_grid_settings.set(grid);
foreach (var col in _columns) {
col.set_fallback_font_params(new FontFamily(grid.font_family), grid.font_size, grid.font_color.rgb_color(), grid.font_weight, grid.background_color.argb_color());
}
// ** in the unfortunate event that we botch backwards compatability, and the columns don't bear a 1:1 relationship with the column-settings
// don't add insult to injury by crashing **
if (grid_settings.columns != null) {
if (reset_immutable_flag_stores) {
foreach (var kv in _column_flags) {
if (grid.columns.TryGetFirst(c => c.id == kv.Key, out GridColumnSettings cs))
kv.Value.store(cs);
}
}
if (_columns != null) {
var col_settings_id_map = grid_settings.columns.ToDictionary(cs => cs.id);
var columns_id_map = _columns.ToDictionary(c => c.id.ToString());
if (col_settings_id_map.Count == columns_id_map.Count && col_settings_id_map.Count == grid_settings.columns.Count)
_sync_column_order?.Invoke(grid_settings.columns);
// ** don't assume that columns:column_settings have a perfect 1:1 relationship (they should, but it is possible we accidentally break the settings as grids/uis change) **
foreach (var col in _columns) {
if (col_settings_id_map.TryGetValue(col.id.ToString(), out GridColumnSettings cs))
col.load_from(cs);
}
}
_invalidate_rows?.Invoke();
}
}
}
}
@@ -60,6 +60,7 @@ namespace mbts.spark.filters {
TimeFilter = "TimeFilterTemplate",
DiscreteValues = "DiscreteValuesTemplate",
DiscreteValuesCollectionView = "DiscreteValuesCollectionViewTemplate",
SecurityCriteriaCriteria = "SecurityCriteriaCriteria",
EnumValues = "EnumValuesTemplate",
Regex = "RegexTemplate",
YesNo = "YesNoTemplate";
@@ -12,6 +12,8 @@ namespace mbts.spark.filters {
ICommand cancel { get; }
bool filter(object row);
event Action filter_changed;
void load_state(object state);
object get_state();
}
interface IDataGridColumnFilter<in TRow> : IDataGridColumnFilter {
@@ -20,6 +22,6 @@ namespace mbts.spark.filters {
interface IDataGridColumnPersistentFilter<in TRow, TState> : IDataGridColumnFilter<TRow> {
void load_state(TState state);
TState get_state();
new TState get_state();
}
}
}
@@ -1,5 +1,6 @@
using mbts.ui;
using mbts.ui.shell;
using mbts.utils;
using System;
using System.Windows.Input;
@@ -53,6 +54,15 @@ namespace mbts.spark.filters {
_raise_filter_changed();
}
object IDataGridColumnFilter.get_state() =>
get_state();
void IDataGridColumnFilter.load_state(object state) {
if (state is TState fstate)
load_state(fstate);
else if (state != null) throw ExceptionBuilder.Argument.not_of_type<TState>(nameof(state), state?.GetType());
}
protected abstract bool _get_active();
protected abstract bool _filter(TValue value);
protected abstract void _load_state_internal(TState state);
@@ -111,4 +121,4 @@ namespace mbts.spark.filters {
bool IDataGridColumnFilter.filter(object row) =>
filter(ConvertUtils.try_convert<TRow>(row));
}
}
}
@@ -1,5 +1,7 @@
using bts.api;
using System;
using System.Collections.Generic;
using System.Linq;
namespace mbts.spark.filters {
class SecurityCriteriaFilter<TRow> : FilterVMBase<TRow, SecurityImmutable, SecurityCriteria>, IDisposable {
@@ -43,4 +45,50 @@ namespace mbts.spark.filters {
void _set_default_values() =>
_security_criteria = model.result_criteria;
}
}
class SecurityCriteriaCriteriaFilter<TRow> : FilterVMBase<TRow, SecurityCriteria, SecurityCriteria>, IDisposable {
SecurityCriteria _security_criteria;
public SecurityCriteriaCriteriaFilter(Func<TRow, SecurityCriteria> get_row_val, string prop_name)
: base(get_row_val, prop_name) { }
public ContractPickerModel model { get; }
public void Dispose() =>
model.security_criteria_clause_changed -= _on_security_criteria_clause_changed;
public override SecurityCriteria get_state() =>
_security_criteria;
protected override bool _filter(SecurityCriteria value) {
if ((_security_criteria?.clauses).is_null_or_empty())
return true;
if (!_security_criteria.is_defined())
return true;
if ((value?.clauses).is_null_or_empty())
return false;
var result = value.clauses.Any(c => c.is_defined && _security_criteria.clauses.Any(fclause => c.is_subset_of(fclause)));
return result;
}
protected override void _load_state_internal(SecurityCriteria state) =>
_security_criteria = state;
protected override void _clear() {
_close();
using (_clear_properties())
_set_default_values();
}
protected override bool _get_active() =>
_security_criteria != null && _security_criteria.clauses.Length > 0;
void _on_security_criteria_clause_changed(object sender, SecurityCriteriaClauseChangedEventsArgs e) {
_security_criteria = model.result_criteria;
_raise_filter_changed();
}
void _set_default_values() =>
_security_criteria = model.result_criteria;
}
}
@@ -1,6 +1,7 @@
using bts;
using mbts.ui;
using mbts.ui.shell;
using mbts.utils;
using System;
using System.Windows.Input;
@@ -60,16 +61,24 @@ namespace mbts.spark.filters {
public TCompoundState get_state() =>
_get_state(_filter1.get_state(), _filter2.get_state());
object IDataGridColumnFilter.get_state() =>
get_state();
public void load_state(TCompoundState state) {
_filter1.load_state(_get_filter1_state(state));
_filter2.load_state(_get_filter2_state(state));
}
void IDataGridColumnFilter.load_state(object state) {
if (state is TCompoundState cstate)
load_state(cstate);
else throw ExceptionBuilder.Argument.not_of_type<TCompoundState>(nameof(state), state?.GetType());
}
protected void _raise_request_update() =>
RequestUpdate?.Invoke();
bool IDataGridColumnFilter.filter(object row) =>
filter(ConvertUtils.try_convert<TRow>(row));
}
}
}
Loaded 100 of 223 files, more files were not shown because too many files have changed in this diff. Show more