void Items_ItemRemoved(object sender, ListEventArgs <ListBoxItem> e)
{
_itemContainer.Controls.Clear();
if (e.Item.Selected)
{
if (Multiselect)
{
_selected.Remove(e.Item);
}
else
{
SelectedItem = null;
}
}
e.Item.Selected = false;
e.Item.MouseClick -= item_MouseClick;
e.Item.SelectedChanged -= Item_SelectedChanged;
foreach (var item in Items)
{
_itemContainer.Controls.Add(item);
}
}
public override void OnChangeTrade(TransactionPairBinary comboTrade, LogicalFill fill, LogicalOrder filledOrder)
{
lastMidpoint = double.NaN;
if (fill.Position % lotSize != 0)
{
return;
}
var size = Math.Abs(comboTrade.CurrentPosition);
var change = size - lastSize;
totalVolume += change;
lastSize = size;
if (change > 0)
{
fills.AddFirst(new LocalFill(change, fill.Price, fill.Time));
SetupBidAsk(fill.Price);
}
else
{
change = Math.Abs(change);
for (var current = fills.First; current != null; current = current.Next)
{
var prevFill = current.Value;
if (change > prevFill.Size)
{
change -= prevFill.Size;
fills.Remove(current);
if (fills.Count > 0)
{
SetupBidAsk(fill.Price);
}
}
else
{
prevFill.Size -= change;
if (prevFill.Size == 0)
{
fills.Remove(current);
if (fills.Count > 0)
{
SetupBidAsk(fill.Price);
}
}
break;
}
}
}
}
public void Change(double price, int positionChange)
{
InventoryGroupDefault changeInventory;
if (positionChange > 0)
{
changeInventory = bidOwner;
//if( maxInventories > 1) AdjustBidOffset();
}
else if (positionChange < 0)
{
changeInventory = offerOwner;
//if (maxInventories > 1) AdjustOfferOffset();
}
else
{
throw new InvalidOperationException("Change position must be either greater or less than zero.");
}
changeInventory.Change(price, positionChange);
if (changeInventory.Status == InventoryStatus.Flat)
{
changeInventory.Pause();
active.Remove(changeInventory);
EnsureActiveInventory();
}
}
public void OrderModified(LogicalOrder order)
{
if (order.IsActive)
{
// Any change to an active order even if only
// a price change means the list change.
IsActiveOrdersChanged = true;
if (!activeOrders.Contains(order))
{
var newNode = nodePool.Create(order);
bool found = false;
var next = activeOrders.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
LogicalOrder other = node.Value;
if (order.CompareTo(other) < 0)
{
activeOrders.AddBefore(node, newNode);
found = true;
break;
}
}
if (!found)
{
activeOrders.AddLast(newNode);
}
}
}
else
{
var node = activeOrders.Find(order);
if (node != null)
{
activeOrders.Remove(node);
nodePool.Free(node);
// Since this order became inactive, it
// means the active list changed.
IsActiveOrdersChanged = true;
}
}
if (order.IsNextBar)
{
if (!nextBarOrders.Contains(order))
{
nextBarOrders.Add(order);
}
}
else
{
if (nextBarOrders.Contains(order))
{
nextBarOrders.Remove(order);
}
}
ActiveOrdersChanged(order);
}
public void PopChanges(ActiveList <bTriangle> triangleList, ActiveList <bVertex> vertexList)
{
if (triangleStack.Count <= 0)
{
return;
}
runningbTriangleChanges = triangleStack[triangleStack.Count - 1];
triangleStack.RemoveAt(triangleStack.Count - 1);
runningVertexChanges = vertexStack[vertexStack.Count - 1];
vertexStack.RemoveAt(vertexStack.Count - 1);
runningbTriangleChanges.Reverse();
runningVertexChanges.Reverse();
foreach (bTriangle_Change t in runningbTriangleChanges)
{
if (t.oldData != null)
{
t.node.data = t.oldData;
}
if (t.activityToggle)
{
triangleList.SetActivity(t.node, !t.node.IsActive());
}
if (t.newNode)
{
triangleList.Remove(t.node);
}
}
foreach (Vertex_Change v in runningVertexChanges)
{
if (v.oldData != null)
{
v.node.data = v.oldData;
}
if (v.activityToggle)
{
vertexList.SetActivity(v.node, !v.node.IsActive());
}
if (v.newNode)
{
vertexList.Remove(v.node);
}
}
runningbTriangleChanges = new List <bTriangle_Change>();
runningVertexChanges = new List <Vertex_Change>();
}
public void destroyRenderedObject(GameObject activeObject, POICoordinatesObject poiCoordinatesObject)
{
ActiveList.Remove(activeObject);
SpawnedObjects.Remove(poiCoordinatesObject);
foreach (Transform objects in transform.parent)
{
if (objects.gameObject == activeObject)
{
Destroy(objects.gameObject);
break;
}
}
Debug.Log("Unloaded spawned Object");
}
public async void CompareNewBar(IAgg bar, string symbol)
{
var id = StockList.Where(e => e.Symbol == symbol).Select(e => e.Id).FirstOrDefault();
var itemFlags = ActiveList.Where(e => e.SymbolId == id).ToList();
foreach (var item in itemFlags)
{
if (item.IsActive == "Y")
{
if (item.ExpirationDate >= DateTime.Now)
{
if (item.ComparisonType == "GreaterThan")
{
if (item.AlertPrice >= bar.Close)
{
var xx = item.BuySellFlag;
var emailList = await GetUserEmails();
EmailEngine.SendTradeAlert(emailList);
//send alert,
//remove active flag in table,
ActiveList.Remove(item);
}
}
else if (item.ComparisonType == "LessThan")
{
if (item.AlertPrice <= bar.Close)
{
ActiveList.Remove(item);
}
}
}
else
{
//send tracker expired email,
//update active flag
ActiveList.Remove(item);
}
}
else
{
ActiveList.Remove(item);
}
}
}
public void TestRemoveWhileIterate()
{
ActiveList <int> list = new ActiveList <int>();
for (int i = 0; i < 10; i++)
{
list.AddLast(i);
}
var next = list.First;
for (var node = next; node != null; node = next)
{
next = node.Next;
list.Remove(node.Value);
}
Assert.AreEqual(0, list.Count);
}
public void TestRemoveWhileReading()
{
for (var i = 0; i < 50; i++)
{
list.AddLast(Interlocked.Increment(ref nextValue));
}
var next = list.First;
var item = next.Value;
for (var current = next; current != null; current = next)
{
next = current.Next;
item = current.Value;
if (item == 10)
{
list.Remove(next);
}
if (item == 35)
{
break;
}
}
Assert.AreEqual(35, item, "found item");
}
private void ProcessFill(LogicalFillBinary fill, bool isCompletePhysicalFill)
{
if (debug)
{
log.Debug("ProcessFill() logical: " + fill);
}
int orderId = fill.OrderId;
if (orderId == 0)
{
// This is an adjust-to-position market order.
// Position gets set via SetPosition instead.
return;
}
var filledOrder = FindLogicalOrder(orderId);
if (debug)
{
log.Debug("Matched fill with order: " + filledOrder);
}
var isCompleteLogicalFill = filledOrder.Position == Math.Abs(fill.Position);
if (filledOrder.TradeDirection == TradeDirection.Change)
{
var strategyPosition = filledOrder.StrategyPosition;
var orderPosition =
filledOrder.Type == OrderType.BuyLimit ||
filledOrder.Type == OrderType.BuyMarket ||
filledOrder.Type == OrderType.BuyStop ?
filledOrder.Position : -filledOrder.Position;
if (debug)
{
log.Debug("Change order fill = " + orderPosition + ", strategy = " + strategyPosition + ", fill = " + fill.Position);
}
isCompleteLogicalFill = orderPosition + strategyPosition == fill.Position;
if (!isCompleteLogicalFill)
{
var change = fill.Position - filledOrder.StrategyPosition;
filledOrder.Position = Math.Abs(orderPosition - change);
if (debug)
{
log.Debug("Changing order to position: " + filledOrder.Position);
}
}
}
if (isCompleteLogicalFill)
{
try {
if (debug)
{
log.Debug("Marking order id " + filledOrder.Id + " as completely filled.");
}
filledOrders.Add(filledOrder.SerialNumber, TimeStamp.UtcNow.Internal);
originalLogicals.Remove(filledOrder);
CleanupAfterFill(filledOrder);
} catch (ApplicationException) {
}
}
UpdateOrderCache(filledOrder, fill);
if (onProcessFill != null)
{
if (debug)
{
log.Debug("Sending logical fill for " + symbol + ": " + fill);
}
onProcessFill(symbol, fill);
}
if (isCompletePhysicalFill && !isCompleteLogicalFill)
{
if (debug)
{
log.Debug("Found complete physical fill but incomplete logical fill.");
}
ProcessMissingPhysical(filledOrder);
}
if (isCompleteLogicalFill)
{
if (debug)
{
log.Debug("Performing extra compare.");
}
lock ( performCompareLocker) {
PerformCompareInternal();
}
}
}
private void ProcessMatchPhysicalEntry(LogicalOrder logical, PhysicalOrder physical)
{
log.Trace("ProcessMatchPhysicalEntry()");
var strategyPosition = logical.StrategyPosition;
var difference = logical.Position - Math.Abs(strategyPosition);
log.Trace("position difference = " + difference);
if (difference == 0)
{
TryCancelBrokerOrder(physical);
}
else if (difference != physical.Size)
{
var origBrokerOrder = physical.BrokerOrder;
if (strategyPosition == 0)
{
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference);
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
if (strategyPosition > 0)
{
if (logical.Type == OrderType.BuyStop || logical.Type == OrderType.BuyLimit)
{
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference);
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
TryCancelBrokerOrder(physical);
}
}
if (strategyPosition < 0)
{
if (logical.Type == OrderType.SellStop || logical.Type == OrderType.SellLimit)
{
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference);
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
TryCancelBrokerOrder(physical);
}
}
}
}
else if (logical.Price.ToLong() != physical.Price.ToLong())
{
var origBrokerOrder = physical.BrokerOrder;
physicalOrders.Remove(physical);
var side = GetOrderSide(logical.Type);
physical = new PhysicalOrderDefault(OrderState.Active, symbol, logical, side, difference);
TryChangeBrokerOrder(physical, origBrokerOrder);
}
else
{
VerifySide(logical, physical);
}
}
private void PerformCompareInternal()
{
if (debug)
{
log.Debug("PerformCompare for " + symbol + " with " +
actualPosition + " actual " +
desiredPosition + " desired and " +
originalLogicals.Count + " logical, " +
originalPhysicals.Count + " physical.");
}
originalPhysicals.Clear();
originalPhysicals.AddLast(physicalOrderHandler.GetActiveOrders(symbol));
if (debug)
{
var next = originalLogicals.First;
for (var node = next; node != null; node = node.Next)
{
var order = node.Value;
log.Debug("Logical Order: " + order);
}
}
if (debug)
{
var next = originalPhysicals.First;
for (var node = next; node != null; node = node.Next)
{
var order = node.Value;
log.Debug("Physical Order: " + order);
}
}
if (CheckForPending())
{
if (debug)
{
log.Debug("Found pending physical orders. Skipping compare.");
}
return;
}
lock ( bufferedLogicalsLocker) {
if (CheckForFilledOrders(bufferedLogicals))
{
if (debug)
{
log.Debug("Found already filled orders in position change event. Skipping compare.");
}
return;
}
originalLogicals.Clear();
if (bufferedLogicals != null)
{
originalLogicals.AddLast(bufferedLogicals);
}
}
logicalOrders.Clear();
logicalOrders.AddLast(originalLogicals);
physicalOrders.Clear();
if (originalPhysicals != null)
{
physicalOrders.AddLast(originalPhysicals);
}
PhysicalOrder physical;
extraLogicals.Clear();
while (logicalOrders.Count > 0)
{
var logical = logicalOrders.First.Value;
if (TryMatchId(logical, out physical))
{
ProcessMatch(logical, physical);
physicalOrders.Remove(physical);
}
else
{
extraLogicals.Add(logical);
}
logicalOrders.Remove(logical);
}
// Find any pending adjustments.
int pendingAdjustments = FindPendingAdjustments();
if (trace)
{
log.Trace("Found " + physicalOrders.Count + " extra physicals.");
}
int cancelCount = 0;
while (physicalOrders.Count > 0)
{
physical = physicalOrders.First.Value;
if (ProcessExtraPhysical(physical))
{
cancelCount++;
}
physicalOrders.Remove(physical);
}
if (cancelCount > 0)
{
// Wait for cancels to complete before creating any orders.
return;
}
if (TrySyncPosition(pendingAdjustments))
{
// Wait for fill to process before creating any orders.
return;
}
if (trace)
{
log.Trace("Found " + extraLogicals.Count + " extra logicals.");
}
while (extraLogicals.Count > 0)
{
var logical = extraLogicals[0];
ProcessExtraLogical(logical);
extraLogicals.Remove(logical);
}
}