void UpdateWatchList(StockData[] watchListData)
{
int count = 0;
int isRise = 0;
oldWatchListData = new ObservableCollection <CompanyTradingDataViewModel>(watchLisBindingData as IEnumerable <CompanyTradingDataViewModel>);
oldWatchListData = new ObservableCollection <CompanyTradingDataViewModel>();
foreach (CompanyTradingDataViewModel item in watchLisBindingData)
{
oldWatchListData.Add(new CompanyTradingDataViewModel(item.TradingData, item.CompanyName, item.Rise, item.TotalRise));
}
watchLisBindingData.BeginUpdate();
foreach (StockData dt in watchListData)
{
if (companies.Count <= (dt.CompanyID))
{
continue;
}
CompanyTradingData ctd = new CompanyTradingData(dt, companies[dt.CompanyID]);
if (watchLisBindingData.Count < companies.Count)
{
watchLisBindingData.Add(new CompanyTradingDataViewModel(ctd, ctd.CompanyName, isRise, 1));
}
else
{
SetWatchListBindingData(count, ctd);
count++;
}
}
watchLisBindingData.EndUpdate();
if (watchListChanged != null)
{
watchListChanged(this, EventArgs.Empty);
}
}
void SetStockChartBindingData(CompanyTradingData ctd)
{
TradingDataViewModel tdvm = null;
if (stockChartBindingData.Count > 0)
{
tdvm = new TradingDataViewModel(stockChartBindingData[stockChartBindingData.Count - 1].TradingData);
}
else
{
tdvm = new TradingDataViewModel();
}
highestPrice = Math.Max(highestPrice, ctd.High);
lowestPrice = Math.Min(lowestPrice, ctd.Low);
tdvm.Volume = Math.Round((ctd.Volume / 1000000), 2);
tdvm.Close = ctd.Close;
tdvm.Low = lowestPrice;
tdvm.High = highestPrice;
tdvm.Price = ctd.Price;
if (stockChartBindingData.Count > 0)
{
stockChartBindingData[stockChartBindingData.Count - 1] = tdvm;
}
else
{
stockChartBindingData.Add(tdvm);
}
}
LockableCollection <TradingDataViewModel> CreateVolumeDynamicsBindingData(StockData[] data)
{
LockableCollection <TradingDataViewModel> result = new LockableCollection <TradingDataViewModel>();
foreach (StockData currentData in data)
{
CompanyTradingData ctd = new CompanyTradingData(currentData, "");
ctd.Close = double.Parse(currentData.CloseP.ToString());
ctd.Volume = Math.Round(((double)ctd.Volume / 1000000), 2);
ctd.Low = double.Parse(currentData.LowP.ToString());
ctd.High = double.Parse(currentData.HighP.ToString());
result.Add(new TradingDataViewModel(ctd));
}
return(result);
}
void SetWatchListBindingData(int index, CompanyTradingData ctd)
{
watchLisBindingData[index].Rise = 0;
if (ctd.Price > watchLisBindingData[index].Price)
{
watchLisBindingData[index].TotalRise = Math.Min(0.5 + (1 - watchLisBindingData[index].Price / ctd.Price) * 10, 1.3);
watchLisBindingData[index].Rise = 180;
}
else if (ctd.Price < watchLisBindingData[index].Price)
{
watchLisBindingData[index].TotalRise = Math.Min(0.5 + (1 - ctd.Price / watchLisBindingData[index].Price) * 10, 1.3);
watchLisBindingData[index].Rise = -180;
}
watchLisBindingData[index].Assign(ctd);
}
void UpdateVolumeDynamicsAsyncCompleted(CompanyStockData[] cd)
{
foreach (CompanyStockData companynStockData in cd)
{
try {
if (companynStockData.Data.Length == 0)
{
continue;
}
DateTime current = dates[currentDate];
CompanyTradingData ctd = GetCompanyTradingData(companynStockData.Data[0], current);
CompanyTradingDataViewModel vm = watchLisBindingData.Where(c => c.CompanyName == companynStockData.CompanyName).Select(c => c).FirstOrDefault();
if (vm == null)
{
continue;
}
IList <TradingDataViewModel> volDyn = vm.VolumeDynamics as IList <TradingDataViewModel>;
if (vm.VolumeDynamics == null || ((IList)vm.VolumeDynamics).Count == 0)
{
return;
}
if (tickCount == 2)
{
ctd.Volume = Math.Round((ctd.Volume / 1000000), 2);
volDyn.Add(new TradingDataViewModel(ctd));
}
if (tickCount != 2)
{
TradingDataViewModel tdvm = new TradingDataViewModel(volDyn[volDyn.Count - 1].TradingData);
tdvm.Volume = Math.Round((ctd.Volume / 1000000), 2);
tdvm.Close = ctd.Close;
tdvm.Low = lowestPrice;
tdvm.High = highestPrice;
tdvm.Price = ctd.Price;
volDyn[volDyn.Count - 1] = tdvm;
}
}
catch {
currentDate++;
UpdateStockChartBindingDataAsync();
}
}
TryEndUpdateBindingData();
}
void CreateChartBindingData(List <CompanyData> newStockChartData)
{
TryResetCurrentDate();
int index = 0;
DateTime firstDate = newStockChartData[0].Data.Date;
DateTime startDate = new DateTime(firstDate.Year, firstDate.Month, 1);
foreach (CompanyData candleData in newStockChartData)
{
CompanyTradingData ctd = new CompanyTradingData(candleData.Data, "");
ctd.Close = candleData.ClosePrice;
ctd.Volume = Math.Round(((double)ctd.Volume / 1000000), 2);
ctd.Low = lowestPrice = candleData.LowPrice;
ctd.High = highestPrice = candleData.HighPrice;
TradingDataViewModel viewModel = new TradingDataViewModel(ctd)
{
Date = startDate
};
if (stockChartBindingData.Count < candlesCount)
{
stockChartBindingData.Add(viewModel);
}
else
{
stockChartBindingData[index] = viewModel;
}
startDate = UpdateDate(startDate, true);
index++;
}
DateTime search = UpdateDate(startDate, false);
while (true)
{
int dateIndex = dates.IndexOf(search);
if (dateIndex != -1)
{
currentDate = dateIndex;
break;
}
search = search.AddDays(-1);
}
}
void AddStockChart(DateTime current, CompanyTradingData ctd, int count)
{
if (current.DayOfWeek == DayOfWeek.Monday && countOfWeek == count)
{
ctd.Volume = Math.Round((ctd.Volume / 1000000), 2);
stockChartBindingData.Add(new TradingDataViewModel(ctd));
highestPrice = ctd.High;
lowestPrice = ctd.Low;
countOfWeek = 1;
return;
}
if (current.DayOfWeek == DayOfWeek.Monday && countOfWeek != count)
{
SetStockChartBindingData(ctd);
countOfWeek++;
return;
}
if (current.DayOfWeek != DayOfWeek.Monday)
{
SetStockChartBindingData(ctd);
}
}
void UpdateStockChart(StockData newChartData)
{
tickCount++;
DateTime current = dates[currentDate];
CompanyTradingData ctd = GetCompanyTradingData(newChartData, current);
switch (totalTicks)
{
case 5:
AddStockChart(current, ctd, 1);
break;
case 10:
AddStockChart(current, ctd, 2);
break;
default:
AddStockChart(current, ctd, 4);
break;
}
currentDate++;
}
public void Assign(CompanyTradingData ctd)
{
CompanyName = ctd.CompanyName;
base.Assign(ctd);
}
CompanyTradingData GetCompanyTradingData(StockData newData, DateTime current)
{
CompanyTradingData ctd = new CompanyTradingData(newData, "");
return(ctd);
}
