private void CalculateSingleWPR(string contractDesc, WPRCalculator calc, WPRType type, DataGridView grid)
{
CalcWPRDelegate calcFunc;
int columnIndex;
double otherLatestWPR;
if (type == WPRType.OneDay)
{
otherLatestWPR = calc.Latest5DayWPR;
calcFunc = calc.Get1DayWPR;
columnIndex = WPR_1DAY_INDEX;
}
else
{
otherLatestWPR = calc.Latest1DayWPR;
calcFunc = calc.Get5DayWPR;
columnIndex = WPR_5DAY_INDEX;
}
double wpr = calcFunc();
if (ContractDescToRow.ContainsKey(contractDesc))
{
if (wpr < 0)
{
int rowIndex = ContractDescToRow[contractDesc];
grid[columnIndex, rowIndex].Value = string.Format("{0:F2}", wpr);
}
if ((wpr <= -80) && (otherLatestWPR <= -80))
{
SoundPlayer.Play();
}
}
}
private void CalculateBothWPRs(string contractDesc, WPRCalculator calc, DataGridView grid)
{
double oneDayWPR = calc.Get1DayWPR();
double fiveDayWPR = calc.Get5DayWPR();
if (ContractDescToRow.ContainsKey(contractDesc))
{
int rowIndex = ContractDescToRow[contractDesc];
if (oneDayWPR < 0)
{
grid[WPR_1DAY_INDEX, rowIndex].Value = string.Format("{0:F4}", oneDayWPR);
}
if (fiveDayWPR < 0)
{
grid[WPR_5DAY_INDEX, rowIndex].Value = string.Format("{0:F4}", fiveDayWPR);
}
if ((oneDayWPR <= -80) && (fiveDayWPR <= -80))
{
SoundPlayer.Play();
grid[WPR_1DAY_INDEX, rowIndex].Style.BackColor = Color.Red;
grid[WPR_5DAY_INDEX, rowIndex].Style.BackColor = Color.Red;
}
else
{
grid[WPR_1DAY_INDEX, rowIndex].Style.BackColor = Color.White;
grid[WPR_5DAY_INDEX, rowIndex].Style.BackColor = Color.White;
}
}
}
public void UpdateHistoricalData(IBMessage message)
{
switch (message.Type)
{
case MessageType.HistoricalData:
HistoricalDataMessage hdMsg = (HistoricalDataMessage)message;
if (!HistoricalData.ContainsKey(hdMsg.RequestId))
{
HistoricalData.Add(hdMsg.RequestId, new List <HistoricalDataMessage>());
}
HistoricalData[hdMsg.RequestId].Add(hdMsg);
break;
case MessageType.HistoricalDataEnd:
HistoricalDataEndMessage endMsg = (HistoricalDataEndMessage)message;
int requestId = endMsg.RequestId;
if (!HistoricalData.ContainsKey(requestId))
{
throw new Exception("Received end message with no historical data");
}
HistoricalData[endMsg.RequestId].Sort(HistoricalDataComparer);
if (HistoricalReqIdToContractDesc.ContainsKey(requestId))
{
string contractDesc = HistoricalReqIdToContractDesc[requestId];
if (ContractDescToWPR.ContainsKey(contractDesc))
{
WPRCalculator calc = ContractDescToWPR[contractDesc];
if (HistoricalData.ContainsKey(requestId) &&
(HistoricalData[requestId].Count > 0))
{
List <HistoricalDataMessage> historicalData = HistoricalData[requestId];
HistoricalDataMessage last = historicalData.Last();
calc.OneDayHigh = last.High;
calc.OneDayLow = last.Low;
calc.Close = last.Close;
double fiveDayHigh = -1;
double fiveDayLow = double.MaxValue;
foreach (var item in historicalData)
{
fiveDayHigh = Math.Max(fiveDayHigh, item.High);
fiveDayLow = Math.Min(fiveDayLow, item.Low);
}
calc.FiveDayHigh = fiveDayHigh;
calc.FiveDayLow = (fiveDayLow == double.MaxValue) ? -1 : fiveDayLow;
}
}
}
break;
}
}
public void UpdateRealTimeData(RealTimeBarMessage message)
{
if (RealTimeReqIdToContractDesc.ContainsKey(message.RequestId))
{
string contractDesc = RealTimeReqIdToContractDesc[message.RequestId];
if (ContractDescToWPR.ContainsKey(contractDesc))
{
WPRCalculator calc = ContractDescToWPR[contractDesc];
calc.Close = message.Close;
calc.LatestHigh = message.High;
calc.LatestLow = message.Low;
DataGridView grid = (DataGridView)DataGrid;
CalculateBothWPRs(contractDesc, calc, grid);
}
}
}
public override void UpdateUI(IBMessage message)
{
DataGridView grid = (DataGridView)DataGrid;
if (message is MarketDataMessage)
{
MarketDataMessage dataMessage = (MarketDataMessage)message;
int requestId = dataMessage.RequestId;
string contractDesc = ReqIdToContractDesc[requestId];
if (RequestIdToRow.ContainsKey(dataMessage.RequestId))
{
if (message is TickPriceMessage)
{
TickPriceMessage priceMessage = (TickPriceMessage)message;
int columnIndex = -1;
switch (dataMessage.Field) // TickType
{
case TickType.BID:
case TickType.DELAYED_BID:
columnIndex = BID_PRICE_INDEX;
break;
case TickType.ASK:
case TickType.DELAYED_ASK:
columnIndex = ASK_PRICE_INDEX;
break;
case TickType.LAST:
case TickType.DELAYED_LAST:
columnIndex = LAST_PRICE_INDEX;
break;
case TickType.LOW:
case TickType.DELAYED_LOW:
if (ContractDescToWPR.ContainsKey(contractDesc))
{
WPRCalculator calc = ContractDescToWPR[contractDesc];
calc.LatestLow = priceMessage.Price;
CalculateBothWPRs(contractDesc, calc, grid);
}
return;
case TickType.HIGH:
case TickType.DELAYED_HIGH:
if (ContractDescToWPR.ContainsKey(contractDesc))
{
WPRCalculator calc = ContractDescToWPR[contractDesc];
calc.LatestHigh = priceMessage.Price;
CalculateBothWPRs(contractDesc, calc, grid);
}
return;
case TickType.CLOSE:
case TickType.DELAYED_CLOSE:
if (ContractDescToWPR.ContainsKey(contractDesc))
{
WPRCalculator calc = ContractDescToWPR[contractDesc];
calc.Close = priceMessage.Price;
CalculateBothWPRs(contractDesc, calc, grid);
}
return;
default:
return;
}
int rowIndex = RequestIdToRow[dataMessage.RequestId];
grid[columnIndex, rowIndex].Value = GetFormattedPrice(priceMessage);
double previousPrice = Convert.ToDouble(grid[columnIndex, rowIndex].Value);
if (previousPrice > priceMessage.Price)
{
grid[columnIndex, rowIndex].Style.ForeColor = Color.Green;
}
else if (previousPrice < priceMessage.Price)
{
grid[columnIndex, rowIndex].Style.ForeColor = Color.Red;
}
else
{
grid[columnIndex, rowIndex].Style.ForeColor = Color.Black;
}
}
}
}
else if (message is CalculateWPRMessage)
{
CalculateWPRMessage calcMsg = (CalculateWPRMessage)message;
foreach (var item in ContractDescToWPR)
{
string contractDesc = item.Key;
WPRCalculator calc = item.Value;
if (calcMsg.WPRType == WPRType.Both)
{
CalculateBothWPRs(contractDesc, calc, grid);
}
else
{
CalculateSingleWPR(contractDesc, calc, calcMsg.WPRType, grid);
}
}
}
}
