protected override void Orders_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, ActiveOrder.UpdateTypeEnum[] updatesType)
{
base.Orders_OrderUpdatedEvent(provider, account, orders, updatesType);
// Run in a separate thread since it takes time to request from server.
//GeneralHelper.FireAndForget(new GeneralHelper.GenericReturnDelegate<bool>(Update));
}
void TradeEntities_OrdersUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
{
bool recalculateNeeded = false;
for (int i = 0; i < orders.Length; i++)
{
if (orders[i].Symbol == Symbol)
{
recalculateNeeded = true;
if (updatesType[i] == Order.UpdateTypeEnum.Submitted)
{
if (SubmitEvent != null)
{
SubmitEvent(this, orders[i].Id);
}
}
if (updatesType[i] == Order.UpdateTypeEnum.Executed)
{
if (ExecuteEvent != null)
{
ExecuteEvent(this, orders[i].Id);
}
}
}
}
if (recalculateNeeded)
{
RecalculateParameters(true);
}
}
protected override void Orders_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, ActiveOrder.UpdateTypeEnum[] updatesType)
{
base.Orders_OrderUpdatedEvent(provider, account, orders, updatesType);
// Run in a separate thread since it takes time to request from server.
//GeneralHelper.FireAndForget(new GeneralHelper.GenericReturnDelegate<bool>(Update));
}
/// <summary>
/// An order has been received an update containing critical modification of its information,
/// so handle this here and show to user.
/// </summary>
void management_OrdersCriticalInformationChangedEvent(ITradeEntityManagement provider, AccountInfo account, Order order, OrderInfo updateInfo)
{
// Compose the critical update message instantly, as otherwise it is wrong since the order gets instantly updated after this call.
string criticalUpdateMessage = string.Empty;
if (order.OpenPrice.HasValue && updateInfo.OpenPrice.HasValue && order.OpenPrice.Value != updateInfo.OpenPrice.Value)
{
criticalUpdateMessage = string.Format("Open Price Difference [{0}], Existing [{1}], New [{2}].", order.OpenPrice - updateInfo.OpenPrice, order.OpenPrice.ToString(), updateInfo.OpenPrice) + Environment.NewLine;
}
if (order.ClosePrice.HasValue && updateInfo.ClosePrice.HasValue && order.ClosePrice.Value != updateInfo.ClosePrice.Value)
{
criticalUpdateMessage += string.Format("Close Price Difference [{0}], Existing [{1}], New [{2}].", order.ClosePrice - updateInfo.ClosePrice, order.ClosePrice.ToString(), updateInfo.ClosePrice) + Environment.NewLine;
}
WinFormsHelper.BeginManagedInvoke(this, delegate()
{
if (toolStripButtonPopupNotifications.Checked == false)
{
return;
}
if (string.IsNullOrEmpty(criticalUpdateMessage) == false)
{
MessageBox.Show("Account [" + account.Name + "] Order Id[" + order.Id + "] Critical Information Updated" + Environment.NewLine + criticalUpdateMessage, "Critical Order Update", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
});
}
protected bool RemoveSession(ExpertSession session)
{
if (_sessions.Contains(session) == false)
{
return(false);
}
_sessions.Remove(session);
if (session.DataProvider != null && session.DataProvider.Quotes != null)
{
session.DataProvider.Quotes.QuoteUpdateEvent -= new QuoteProviderUpdateDelegate(Quote_QuoteUpdateEvent);
}
if (session.OrderExecutionProvider != null)
{
ITradeEntityManagement management = session.OrderExecutionProvider.TradeEntities;
if (management != null)
{
management.OrdersAddedEvent -= new OrderManagementOrdersUpdateDelegate(history_OrdersAddedEvent);
management.OrdersRemovedEvent -= new OrderManagementOrdersUpdateDelegate(history_OrdersRemovedEvent);
management.OrdersUpdatedEvent -= new OrderManagementOrdersUpdateTypeDelegate(management_OrderUpdatedEvent);
management.OrdersCriticalInformationChangedEvent -= new OrderManagementOrderCriticalModificationDelegate(management_OrdersCriticalInformationChangedEvent);
}
}
return(true);
}
/// <summary>
///
/// </summary>
public void Initialize(ISessionDataProvider dataProvider, ISourceOrderExecution orderExecutionProvider)
{
if (dataProvider == null)
{
return;
}
lock (this)
{
_dataProvider = dataProvider;
if (_dataProvider != null)
{
_dataProvider.CurrentDataBarProviderChangedEvent += new DataProviderUpdateDelegate(_dataProvider_CurrentDataBarProviderChangedEvent);
CurrentDataBarProvider = _dataProvider.DataBars;
if (_dataProvider.Quotes != null)
{
_dataProvider.Quotes.QuoteUpdateEvent += new QuoteProviderUpdateDelegate(Quotes_QuoteUpdateEvent);
}
}
_orderExecutionProvider = orderExecutionProvider;
if (_orderExecutionProvider != null)
{
IOrderSink executor = _orderExecutionProvider;
if (executor != null)
{
executor.OrdersUpdatedEvent += new OrdersUpdateDelegate(executor_OrderUpdatedEvent);
}
ITradeEntityManagement management = _orderExecutionProvider.TradeEntities;
if (management != null)
{
management.OrdersAddedEvent += new OrderManagementOrdersUpdateDelegate(management_OrdersAddedEvent);
management.OrdersRemovedEvent += new OrderManagementOrdersUpdateDelegate(management_OrdersRemovedEvent);
management.OrdersUpdatedEvent += new OrderManagementOrdersUpdateTypeDelegate(management_OrderUpdatedEvent);
}
}
ComponentResourceManager resources = new ComponentResourceManager(typeof(ProviderTradeChartSeries));
_imageDown = ((Image)(resources.GetObject("imageDown")));
_imageUp = ((Image)(resources.GetObject("imageUp")));
_imageCross = ((Image)(resources.GetObject("imageCross")));
_buyDashedPen.DashPattern = new float[] { 5, 5 };
_buyDashedPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom;
_priceLevelPen.DashPattern = new float[] { 3, 3 };
_priceLevelPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom;
_sellDashedPen.DashPattern = new float[] { 5, 5 };
_sellDashedPen.DashStyle = System.Drawing.Drawing2D.DashStyle.Custom;
}
}
/// <summary>
///
/// </summary>
void TradeEntities_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <Order> orders)
{
foreach (Order order in orders)
{
if (order.Symbol == Symbol)
{
RecalculateParameters(true);
break;
}
}
}
public void UnInitialize()
{
lock (this)
{
_ordersArrows.Clear();
GeneralHelper.FireAndForget(SelectedOrderChangedEvent, _selectedOrder, null);
_selectedOrder = null;
CurrentDataBarProvider = null;
if (_dataProvider != null)
{
if (_dataProvider.Quotes != null)
{
_dataProvider.Quotes.QuoteUpdateEvent += new QuoteProviderUpdateDelegate(Quotes_QuoteUpdateEvent);
}
_dataProvider.CurrentDataBarProviderChangedEvent -= new DataProviderUpdateDelegate(_dataProvider_CurrentDataBarProviderChangedEvent);
_dataProvider = null;
}
if (_orderExecutionProvider != null)
{
IOrderSink executor = _orderExecutionProvider;
ITradeEntityManagement management = _orderExecutionProvider.TradeEntities;
if (executor != null)
{
executor.OrdersUpdatedEvent -= new OrdersUpdateDelegate(executor_OrderUpdatedEvent);
}
if (management != null)
{
management.OrdersAddedEvent -= new OrderManagementOrdersUpdateDelegate(management_OrdersAddedEvent);
management.OrdersRemovedEvent -= new OrderManagementOrdersUpdateDelegate(management_OrdersRemovedEvent);
management.OrdersUpdatedEvent -= new OrderManagementOrdersUpdateTypeDelegate(management_OrderUpdatedEvent);
}
_orderExecutionProvider = null;
}
_buyDashedPen.Dispose();
_sellDashedPen.Dispose();
}
}
void management_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updateType)
{
WinFormsHelper.BeginFilteredManagedInvoke(this, UpdateUI);
}
/// <summary>
/// NON UI Thread.
/// </summary>
void history_OrdersAddedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <Order> order)
{
WinFormsHelper.BeginFilteredManagedInvoke(this, UpdateUI);
}
/// <summary>
/// NON UI Thread.
/// </summary>
void history_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable<Order> order)
{
WinFormsHelper.BeginFilteredManagedInvoke(this, UpdateUI);
}
protected override void Orders_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable<Order> order)
{
base.Orders_OrdersRemovedEvent(provider, account, order);
// Run in a separate thread since it takes time to request from server.
BeginUpdate();
}
/// <summary>
/// An order has been received an update containing critical modification of its information,
/// so handle this here and show to user.
/// </summary>
void management_OrdersCriticalInformationChangedEvent(ITradeEntityManagement provider, AccountInfo account, Order order, OrderInfo updateInfo)
{
// Compose the critical update message instantly, as otherwise it is wrong since the order gets instantly updated after this call.
string criticalUpdateMessage = string.Empty;
if (order.OpenPrice.HasValue && updateInfo.OpenPrice.HasValue && order.OpenPrice.Value != updateInfo.OpenPrice.Value)
{
criticalUpdateMessage = string.Format("Open Price Difference [{0}], Existing [{1}], New [{2}].", order.OpenPrice - updateInfo.OpenPrice, order.OpenPrice.ToString(), updateInfo.OpenPrice) + Environment.NewLine;
}
if (order.ClosePrice.HasValue && updateInfo.ClosePrice.HasValue && order.ClosePrice.Value != updateInfo.ClosePrice.Value)
{
criticalUpdateMessage += string.Format("Close Price Difference [{0}], Existing [{1}], New [{2}].", order.ClosePrice - updateInfo.ClosePrice, order.ClosePrice.ToString(), updateInfo.ClosePrice) + Environment.NewLine;
}
WinFormsHelper.BeginManagedInvoke(this, delegate()
{
if (toolStripButtonPopupNotifications.Checked == false)
{
return;
}
if (string.IsNullOrEmpty(criticalUpdateMessage) == false)
{
string message = "Account [" + account.Name + "] Order Id[" + order.Id + "] Critical Information Updated" + Environment.NewLine + criticalUpdateMessage;
NotificationForm form = new NotificationForm();
form.labelMessage.Text = message;
form.Text = "Critical Order Update";
form.TopMost = true;
form.Show();
//MessageBox.Show("Critical Order Update", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
});
}
void management_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updateType)
{
WinFormsHelper.BeginFilteredManagedInvoke(this, UpdateUI);
}
protected virtual void Orders_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
{
}
void TradeEntities_PositionsAddedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <IPosition> positions)
{
WinFormsHelper.BeginFilteredManagedInvoke(this, TimeSpan.FromMilliseconds(250), UpdateUI);
}
protected override void Orders_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <Order> order)
{
base.Orders_OrdersRemovedEvent(provider, account, order);
// Run in a separate thread since it takes time to request from server.
BeginUpdate();
}
protected override void Orders_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <Order> order)
{
base.Orders_OrdersRemovedEvent(provider, account, order);
DoUpdate();
}
void management_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <Order> order)
{
RaiseSeriesValuesUpdated(true);
}
void management_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
{
//RaiseSeriesValuesUpdated(true);
}
/// <summary>
///
/// </summary>
void TradeEntities_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable<Order> orders)
{
foreach (Order order in orders)
{
if (order.Symbol == Symbol)
{
RecalculateParameters(true);
break;
}
}
}
protected override void Orders_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
{
base.Orders_OrderUpdatedEvent(provider, account, orders, updatesType);
DoUpdate();
}
protected override void Orders_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
{
base.Orders_OrderUpdatedEvent(provider, account, orders, updatesType);
DoUpdate();
}
/// <summary>
/// Updates some parts of the UI, since others must be updated on given events only.
/// </summary>
public void UpdateUI()
{
this.Enabled = ((_selectedSession != null && _selectedSession.OrderExecutionProvider != null) || _sessionManager != null);
if (this.Enabled == false)
{
return;
}
// Update SessionsArray UI combobox
for (int i = 0; i < _sessions.Count + 1; i++)
{
if (toolStripComboBoxAccount.Items.Count <= i)
{
toolStripComboBoxAccount.Items.Add("");
}
if (i == 0)
{// All accountInfos go first.
if ((string)toolStripComboBoxAccount.Items[0] != "All")
{
toolStripComboBoxAccount.Items[0] = "All";
}
}
else
{
string name = GetSessionName(_sessions[i - 1]);
if ((string)toolStripComboBoxAccount.Items[i] != name)
{
toolStripComboBoxAccount.Items[i] = name;
}
}
}
while (_sessions.Count + 1 < toolStripComboBoxAccount.Items.Count)
{
toolStripComboBoxAccount.Items.RemoveAt(toolStripComboBoxAccount.Items.Count - 1);
}
if (toolStripComboBoxAccount.SelectedIndex < 0)
{
toolStripComboBoxAccount.SelectedIndex = 0;
}
// Update
this.listViewOrders.Visible = _compactMode == false;
this.toolStripButtonCloseOrder.Visible = _compactMode == false;
this.toolStripButtonModifyOrder.Visible = _compactMode == false;
toolStripButtonDisplayMode.Visible = _allowCompactMode;
toolStripSeparatorDisplayMode.Visible = _allowCompactMode;
this.toolStripButtonNewOrder.Enabled = _selectedSession != null;
//this.toolStripButtonObtainOrders.Enabled = true;
this.toolStripButtonCloseOrder.Enabled = listViewOrders.SelectedItems.Count > 0;
this.toolStripButtonModifyOrder.Enabled = listViewOrders.SelectedItems.Count > 0;
if (_compactMode)
{
toolStripButtonDisplayMode.Text = "Full Mode";
}
else
{
toolStripButtonDisplayMode.Text = "Compact Mode";
}
if (_alwaysShowAccountSelectionTools)
{
toolStripLabelAccount.Visible = true;
toolStripComboBoxAccount.Visible = true;
toolStripSeparatorAccount.Visible = true;
}
else
{
// If only 1 account to manage, do not show
toolStripLabelAccount.Visible = _sessions.Count > 1;
toolStripComboBoxAccount.Visible = _sessions.Count > 1;
toolStripSeparatorAccount.Visible = _sessions.Count > 1;
}
List <ListViewItem> items = new List <ListViewItem>();
foreach (ListViewItem item in listViewOrders.Items)
{
items.Add(item);
}
foreach (ExpertSession session in _sessions)
{
if (IsSessionVisible(session))
{
lock (session)
{
GeneralHelper.GenericDelegate <Order, AccountInfo> UpdateOrder = delegate(Order order, AccountInfo account)
{
if (IsOrderVisible(order) == false)
{
return;
}
bool orderFound = false;
foreach (ListViewItem item in items)
{
if (item.Tag == order)
{
SetItemAsOrder(item, order, account);
orderFound = true;
items.Remove(item);
break;
}
}
if (orderFound == false)
{
ListViewItem item = new ListViewItem();
listViewOrders.Items.Add(item);
SetItemAsOrder(item, order, account);
}
};
IOrderSink executor = session.OrderExecutionProvider;
ITradeEntityManagement ordersManagement = session.OrderExecutionProvider.TradeEntities;
if (ordersManagement != null && session.OrderExecutionProvider.DefaultAccount != null)
{
lock (ordersManagement)
{
foreach (Order order in ordersManagement.OrdersUnsafe)
{
UpdateOrder(order, session.OrderExecutionProvider.DefaultAccount.Info);
}
}
}
}
}
}
foreach (ListViewItem item in items)
{
listViewOrders.Items.Remove(item);
}
}
void TradeEntities_OrdersUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
{
bool recalculateNeeded = false;
for (int i = 0; i < orders.Length; i++)
{
if (orders[i].Symbol == Symbol)
{
recalculateNeeded = true;
if (updatesType[i] == Order.UpdateTypeEnum.Submitted)
{
if (SubmitEvent != null)
{
SubmitEvent(this, orders[i].Id);
}
}
if (updatesType[i] == Order.UpdateTypeEnum.Executed)
{
if (ExecuteEvent != null)
{
ExecuteEvent(this, orders[i].Id);
}
}
}
}
if (recalculateNeeded)
{
RecalculateParameters(true);
}
}
protected virtual void Orders_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable<Order> order)
{
}
void TradeEntities_PositionsUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable<IPosition> positions)
{
WinFormsHelper.BeginFilteredManagedInvoke(this, TimeSpan.FromMilliseconds(250), UpdateUI);
}
/// <summary>
/// Main drawing routine.
/// </summary>
public override void Draw(ChartPane managingPane, GraphicsWrapper g, int unitsUnification,
RectangleF clippingRectangle, float itemWidth, float itemMargin)
{
//TracerHelper.Trace(TracerHelper.GetCallingMethod(2).Name);
if (Visible == false)
{
return;
}
if (_dataProvider == null)
{
return;
}
IDataBarHistoryProvider dataBarProvider = CurrentDataBarProvider;
if (dataBarProvider == null)
{
return;
}
lock (dataBarProvider)
{
base.Draw(g, dataBarProvider.BarsUnsafe, unitsUnification, clippingRectangle, itemWidth, itemMargin, _maxVolume, null);
}
// Draw ask/bid line.
if (_dataProvider.OperationalState == CommonSupport.OperationalStateEnum.Operational && _dataProvider.Quotes != null &&
_dataProvider.Quotes.Bid.HasValue && _dataProvider.Quotes.Ask.HasValue)
{
if (_showCurrentAskLine)
{
float price = (float)_dataProvider.Quotes.Ask;
g.DrawLine(_priceLevelPen, clippingRectangle.X, price, clippingRectangle.X + clippingRectangle.Width, price);
}
if (_showCurrentBidLine)
{
float price = (float)_dataProvider.Quotes.Bid;
g.DrawLine(_priceLevelPen, clippingRectangle.X, price, clippingRectangle.X + clippingRectangle.Width, price);
}
}
List <Order> ordersOpening;
// Draw orders locations on chart.
lock (this)
{
if (_orderExecutionProvider == null)
{
return;
}
}
// Render orders.
ordersOpening = new List <Order>();
ITradeEntityManagement history = _orderExecutionProvider.TradeEntities;
if (history != null && _dataProvider != null)
{
lock (history)
{
ordersOpening.AddRange(history.GetOrdersBySymbol(_dataProvider.SessionInfo.Symbol));
}
}
// Use for orders closes.
List <Order> ordersClosing = new List <Order>();
foreach (Order order in ordersOpening)
{
if (order.State == OrderStateEnum.Closed)
{// Only add orders already closed.
ordersClosing.Add(order);
}
}
// This is used later on, since ordersClosing is modified.
List <Order> ordersClosed = new List <Order>(ordersClosing);
// TradeEntities opening at current bar.
List <Order> pendingOpeningOrders = new List <Order>();
// Order closing at current bar.
List <Order> pendingClosingOrders = new List <Order>();
PointF drawingPoint = new PointF();
int startIndex, endIndex;
GetDrawingRangeIndecesFromClippingRectange(clippingRectangle, drawingPoint, unitsUnification, out startIndex, out endIndex, itemWidth, itemMargin);
lock (dataBarProvider)
{
float lastBarX = (itemMargin + itemWidth) * dataBarProvider.BarCount;
for (int i = startIndex; i < endIndex && i < dataBarProvider.BarCount &&
(ordersOpening.Count > 0 || ordersClosing.Count > 0); i++)
{ // Foreach bar, draw orders (and closeVolume).
while (ordersOpening.Count > 0)
{ // All orders before now.
if (ordersOpening[0].OpenTime < (dataBarProvider.BarsUnsafe[i].DateTime - Period))
{ // Order before time period.
if ((ordersOpening[0].State == OrderStateEnum.Executed /*||
* ordersOpening[0].State == OrderInformation.OrderStateEnum.Submitted*/) &&
_showPendingOrdersTracing)
{// Since it is an open pending order, we shall also need to draw it as well.
pendingOpeningOrders.Add(ordersOpening[0]);
}
ordersOpening.RemoveAt(0);
continue;
}
if (ordersOpening[0].OpenTime > dataBarProvider.BarsUnsafe[i].DateTime)
{// Order after time period - look no further.
break;
}
// Order open is within the current period.
// Only if order is part of the current period - add to pending.
pendingOpeningOrders.Add(ordersOpening[0]);
ordersOpening.RemoveAt(0);
}
for (int j = ordersClosing.Count - 1; j >= 0; j--)
{
if (ordersClosing[j].CloseTime >= (dataBarProvider.BarsUnsafe[i].DateTime - dataBarProvider.Period) &&
ordersClosing[j].CloseTime <= dataBarProvider.BarsUnsafe[i].DateTime)
{// Order close is within the current period.
pendingClosingOrders.Add(ordersClosing[j]);
ordersClosing.RemoveAt(j);
}
}
drawingPoint.X = i * (itemMargin + itemWidth);
DrawOrders(g, i, drawingPoint, itemWidth, itemMargin, pendingOpeningOrders, pendingClosingOrders, dataBarProvider.BarsUnsafe[i], lastBarX);
pendingOpeningOrders.Clear();
pendingClosingOrders.Clear();
}
if (_showClosedOrdersTracing && dataBarProvider.BarCount > 0 && startIndex < dataBarProvider.BarCount)
{// Since a closed order may be before or after (or during) the curren set of periods - make a special search and render for them.
endIndex = Math.Max(0, endIndex);
endIndex = Math.Min(dataBarProvider.BarCount - 1, endIndex);
foreach (Order order in ordersClosed)
{
if (order.OpenTime.HasValue &&
order.CloseTime.HasValue &&
order.OpenTime.Value <= dataBarProvider.BarsUnsafe[endIndex].DateTime &&
order.CloseTime.Value >= dataBarProvider.BarsUnsafe[startIndex].DateTime - dataBarProvider.Period)
{
int openIndex = dataBarProvider.GetIndexAtTime(order.OpenTime.Value);
int closeIndex = dataBarProvider.GetIndexAtTime(order.CloseTime.Value);
Pen pen = _buyDashedPen;
if (order.IsBuy == false)
{
pen = _sellDashedPen;
}
Decimal?doubleOpenValue = order.OpenPrice;
Decimal?doubleCloseValue = order.ClosePrice;
if (doubleOpenValue.HasValue == false)
{
SystemMonitor.Error("Invalid open price value for closed order to draw.");
continue;
}
if (doubleCloseValue.HasValue == false)
{
SystemMonitor.Error("Invalid close price value for closed order to draw.");
continue;
}
g.DrawLine(pen, new PointF(openIndex * (itemWidth + itemMargin), (float)doubleOpenValue),
new PointF(closeIndex * (itemWidth + itemMargin), (float)doubleCloseValue));
}
}
}
} // Lock
}
void management_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable<Order> order)
{
RaiseSeriesValuesUpdated(true);
}
protected virtual void Orders_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
{
}
void management_OrderUpdatedEvent(ITradeEntityManagement provider, AccountInfo account, Order[] orders, Order.UpdateTypeEnum[] updatesType)
{
//RaiseSeriesValuesUpdated(true);
}
protected virtual void Orders_OrdersAddedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable <Order> order)
{
}
protected override void Orders_OrdersRemovedEvent(ITradeEntityManagement provider, AccountInfo account, IEnumerable<Order> order)
{
base.Orders_OrdersRemovedEvent(provider, account, order);
DoUpdate();
}
