// **********************************************************************
public static void Deactivate()
{
foreach (IConnector connector in connectors)
{
IStockProvider sp = connector as IStockProvider;
if (sp != null)
{
sp.Unsubscribe();
}
ITicksProvider tp = connector as ITicksProvider;
if (tp != null)
{
tp.Unsubscribe();
}
ISettingsProvider stp = connector as ISettingsProvider;
if (stp != null)
{
stp.Unsubscribe();
}
ITradesProvider trp = connector as ITradesProvider;
if (trp != null)
{
trp.Unsubscribe();
}
}
Activated = false;
}
private void DoDrawMayorLabels()
{
additionalLabelsCanvas.Children.Clear();
ITicksProvider <T> mayorTicksProvider = ticksProvider.MayorProvider;
if (mayorTicksProvider != null && MayorLabelProvider != null)
{
Size renderSize = RenderSize;
var mayorTicks = mayorTicksProvider.GetTicks(range, DefaultTicksProvider.DefaultTicksCount);
double[] screenCoords = mayorTicks.Ticks.Select(tick => createDataPoint(convertToDouble(tick))).
Select(p => p.DataToScreen(transform)).Select(p => getCoordinate(p)).ToArray();
// todo this is not the best decision - when displaying, for example,
// milliseconds, it causes to create hundreds and thousands of textBlocks.
double rangesRatio = GetRangesRatio(mayorTicks.Ticks.GetPairs().ToArray()[0], range);
object info = mayorTicks.Info;
MayorLabelsInfo newInfo = new MayorLabelsInfo
{
Info = info,
MayorLabelsCount = (int)Math.Ceiling(rangesRatio)
};
var newMayorTicks = new TicksInfo <T>
{
Info = newInfo,
Ticks = mayorTicks.Ticks,
TickSizes = mayorTicks.TickSizes
};
UIElement[] additionalLabels = MayorLabelProvider.CreateLabels(newMayorTicks);
for (int i = 0; i < additionalLabels.Length; i++)
{
if (screenCoords[i].IsNaN())
{
continue;
}
UIElement tickLabel = additionalLabels[i];
tickLabel.Measure(renderSize);
StackCanvas.SetCoordinate(tickLabel, screenCoords[i]);
StackCanvas.SetEndCoordinate(tickLabel, screenCoords[i + 1]);
if (tickLabel is FrameworkElement)
{
((FrameworkElement)tickLabel).LayoutTransform = additionalLabelTransform;
}
additionalLabelsCanvas.Children.Add(tickLabel);
}
}
}
private CustomBaseNumericTicksProvider(double customBase, ITicksProvider <double> ticksProvider)
{
if (ticksProvider == null)
{
throw new ArgumentNullException("ticksProvider");
}
CustomBase = customBase;
TicksProvider = ticksProvider;
}
private void DoDrawMayorLabels()
{
AdditionalLabelsCanvas.Children.Clear();
ITicksProvider <T> mayorTicksProvider = ticksProvider.MayorProvider;
if (mayorTicksProvider != null && MayorLabelProvider != null)
{
Size renderSize = RenderSize;
//if (renderSize.Width == 0 || renderSize.Height == 0) return;
var mayorTicks = mayorTicksProvider.GetTicks(range, DefaultTicksProvider.DefaultTicksCount);
double[] screenCoords = mayorTicks.Ticks.Select(tick => createDataPoint(convertToDouble(tick))).
Select(p => p.DataToScreen(transform)).Select(p => getCoordinate(p)).ToArray();
int expectedMayorLabelsCount = mayorTicks.Ticks.Length;
// todo this is not the best decision - when displaying, for example,
// milliseconds, it causes to create hundreds and thousands of textBlocks.
double rangesRatio = GetRangesRatio(mayorTicks.Ticks.GetPairs().ToArray()[0], range);
object info = mayorTicks.Info;
MayorLabelsInfo newInfo = new MayorLabelsInfo
{
Info = info,
MayorLabelsCount = (int)Math.Ceiling(rangesRatio)
};
var newMayorTicks = new TicksInfo <T>
{
Info = newInfo,
Ticks = mayorTicks.Ticks,
TickSizes = mayorTicks.TickSizes
};
IEnumerable <FrameworkElement> additionalLabels = MayorLabelProvider.CreateLabels(newMayorTicks);
int i = 0;
foreach (FrameworkElement fe in additionalLabels)
{
fe.Measure(renderSize);
StackCanvas.SetCoordinate(fe, screenCoords[i]);
if (i + 1 < screenCoords.Length)
{
StackCanvas.SetEndCoordinate(fe, screenCoords[i + 1]);
}
AdditionalLabelsCanvas.Children.Add(fe);
i++;
}
}
}
// **********************************************************************
static MarketProvider()
{
foreach (IConnector connector in connectors)
{
IStockProvider sp = connector as IStockProvider;
if (sp != null)
{
sp.Connected += new StatusUpdateHandler(StockConnected);
sp.Disconnected += StockStatus.Disconnected;
sp.Broken += StockStatus.SetError;
sp.StockHandler += new StockHandler(StockHandler);
}
ITicksProvider tp = connector as ITicksProvider;
if (tp != null)
{
tp.Connected += TicksStatus.Connected;
tp.Disconnected += TicksStatus.Disconnected;
tp.Broken += TicksStatus.SetError;
tp.TickHandler += new TickHandler(TickHandler);
}
ISettingsProvider stp = connector as ISettingsProvider;
if (stp != null)
{
stp.Connected += SettingsStatus.Connected;
stp.Disconnected += SettingsStatus.Disconnected;
stp.Broken += SettingsStatus.SetError;
stp.SettingsHandler += new SettingsHandler(SettingsHandler);
}
ITradesProvider trp = connector as ITradesProvider;
if (trp != null)
{
trp.Connected += TradeStatus.Connected;
trp.Disconnected += TradeStatus.Disconnected;
trp.Broken += TradeStatus.SetError;
trp.TradesHandler += new TradesHandler(TradesHandler);
}
}
Receiver = new IDataReceiver[1];
Receiver[0] = new NullReceiver();
Activated = false;
}
// **********************************************************************
public static void Activate()
{
if (!isReplayMode)
{
foreach (IConnector connector in connectors)
{
connector.Setup();
IStockProvider sp = connector as IStockProvider;
if (sp != null)
{
if (sp == stockProvider)
{
sp.Subscribe(cfg.u.SecCode);
}
else
{
sp.Unsubscribe();
}
}
ITicksProvider tp = connector as ITicksProvider;
if (tp != null)
{
tp.Subscribe();
}
ISettingsProvider stp = connector as ISettingsProvider;
if (stp != null)
{
stp.Subscribe();
}
ITradesProvider trp = connector as ITradesProvider;
if (trp != null)
{
trp.Subscribe();
}
}
}
Activated = true;
}
// **********************************************************************
public static void SetMode(bool replay, bool nullTader)
{
if (isReplayMode != replay)
{
if (isReplayMode = replay)
{
foreach (IConnector connector in connectors)
{
IStockProvider sp = connector as IStockProvider;
if (sp != null)
{
sp.Unsubscribe();
}
ITicksProvider tp = connector as ITicksProvider;
if (tp != null)
{
tp.Unsubscribe();
}
ISettingsProvider stp = connector as ISettingsProvider;
if (stp != null)
{
stp.Unsubscribe();
}
ITradesProvider trp = connector as ITradesProvider;
if (trp != null)
{
trp.Unsubscribe();
}
}
}
}
isNullTrader = nullTader;
Activate();
}
internal MinorNumericTicksProvider(ITicksProvider <double> parent)
{
this.parent = parent;
Coeffs = new double[] { };
}
public MinorTimeSpanTicksProvider(ITicksProvider <TimeSpan> owner) : base(owner)
{
}
public MinorTimeProviderBase(ITicksProvider <T> provider)
{
this.provider = provider;
}
public MinorDateTimeProvider(ITicksProvider <DateTime> owner) : base(owner)
{
}
private void DoDrawMinorTicks(GeometryGroup geomGroup)
{
ITicksProvider <T> minorTicksProvider = ticksProvider.MinorProvider;
if (minorTicksProvider != null)
{
int minorTicksCount = DefaultTicksProvider.DefaultTicksCount;
int prevActualTicksCount = -1;
ITicksInfo <T> minorTicks;
TickChange result = TickChange.OK;
TickChange prevResult;
int iteration = 0;
//PerformanceCounter.startStopwatch("Minor ticks: computing tickCounts");
do
{
Verify.IsTrue(++iteration < maxTickArrangeIterations);
minorTicks = minorTicksProvider.GetTicks(range, minorTicksCount);
prevActualTicksCount = minorTicks.Ticks.Length;
prevResult = result;
result = CheckMinorTicksArrangement(minorTicks);
if (prevResult == TickChange.Decrease && result == TickChange.Increase)
{
// stop tick number oscillating
result = TickChange.OK;
}
if (result == TickChange.Decrease)
{
int newMinorTicksCount = minorTicksProvider.DecreaseTickCount(minorTicksCount);
if (newMinorTicksCount == minorTicksCount)
{
result = TickChange.OK;
}
minorTicksCount = newMinorTicksCount;
}
else if (result == TickChange.Increase)
{
int newCount = minorTicksProvider.IncreaseTickCount(minorTicksCount);
if (newCount == minorTicksCount)
{
result = TickChange.OK;
}
minorTicksCount = newCount;
}
} while (result != TickChange.OK);
//PerformanceCounter.stopStopwatch("Minor ticks: computing tickCounts");
minorTicks = minorTicksProvider.GetTicks(range, minorTicksCount);
double[] sizes = minorTicks.TickSizes;
double[] screenCoords = minorTicks.Ticks.Select(
coord => getCoordinate(createDataPoint(convertToDouble(coord)).
ToScreen(converter))).ToArray();
minorScreenTicks = new MinorTickInfo <double> [screenCoords.Length];
for (int i = 0; i < screenCoords.Length; i++)
{
minorScreenTicks[i] = new MinorTickInfo <double>(sizes[i], screenCoords[i]);
}
for (int i = 0; i < screenCoords.Length; i++)
{
double screenCoord = screenCoords[i];
if (i + usedTicks < allocatedTicks)
{
//PerformanceCounter.startStopwatch("Minor ticks: getting allocated lines");
LineGeometry line = allocatedTicksList[i + usedTicks];
//PerformanceCounter.stopStopwatch("Minor ticks: getting allocated lines");
//PerformanceCounter.startStopwatch("Minor ticks: renewing allocated lines");
line.StartPoint = createScreenPoint1(screenCoord);;
line.EndPoint = createScreenPoint2(screenCoord, sizes[i]);
//PerformanceCounter.stopStopwatch("Minor ticks: renewing allocated lines");
}
else
{
//PerformanceCounter.startStopwatch("Minor ticks: creating new lines");
LineGeometry line = new LineGeometry();
line.StartPoint = createScreenPoint1(screenCoord);;
line.EndPoint = createScreenPoint2(screenCoord, sizes[i]);
geomGroup.Children.Add(line);
allocatedTicksList.Add(line);
//PerformanceCounter.stopStopwatch("Minor ticks: creating new lines");
}
}
usedTicks += screenCoords.Length;
}
}
internal static ITicksInfo <T> GetTicks <T>(this ITicksProvider <T> provider, Range <T> range)
{
return(provider.GetTicks(range, DefaultTicksCount));
}
private void DoDrawMinorTicks(GeometryGroup geomGroup)
{
ITicksProvider <T> minorTicksProvider = ticksProvider.MinorProvider;
if (minorTicksProvider != null)
{
int minorTicksCount = prevMinorTicksCount;
int prevActualTicksCount = -1;
ITicksInfo <T> minorTicks;
TickCountChange result = TickCountChange.OK;
TickCountChange prevResult;
int iteration = 0;
do
{
Verify.IsTrue(++iteration < maxTickArrangeIterations);
minorTicks = minorTicksProvider.GetTicks(range, minorTicksCount);
prevActualTicksCount = minorTicks.Ticks.Length;
prevResult = result;
result = CheckMinorTicksArrangement(minorTicks);
if (prevResult == TickCountChange.Decrease && result == TickCountChange.Increase)
{
// stop tick number oscillating
result = TickCountChange.OK;
}
if (result == TickCountChange.Decrease)
{
int newMinorTicksCount = minorTicksProvider.DecreaseTickCount(minorTicksCount);
if (newMinorTicksCount == minorTicksCount)
{
result = TickCountChange.OK;
}
minorTicksCount = newMinorTicksCount;
}
else if (result == TickCountChange.Increase)
{
int newCount = minorTicksProvider.IncreaseTickCount(minorTicksCount);
if (newCount == minorTicksCount)
{
result = TickCountChange.OK;
}
minorTicksCount = newCount;
}
} while (result != TickCountChange.OK);
prevMinorTicksCount = minorTicksCount;
double[] sizes = minorTicks.TickSizes;
double[] screenCoords = minorTicks.Ticks.Select(
coord => getCoordinate(createDataPoint(convertToDouble(coord)).
DataToScreen(transform))).ToArray();
minorScreenTicks = new MinorTickInfo <double> [screenCoords.Length];
for (int i = 0; i < screenCoords.Length; i++)
{
minorScreenTicks[i] = new MinorTickInfo <double>(sizes[i], screenCoords[i]);
}
for (int i = 0; i < screenCoords.Length; i++)
{
double screenCoord = screenCoords[i];
Point p1 = createScreenPoint1(screenCoord);
Point p2 = createScreenPoint2(screenCoord, sizes[i]);
LineGeometry line = new LineGeometry(p1, p2);
geomGroup.Children.Add(line);
}
}
}
public MinorNumericTicksProvider(ITicksProvider <double> parent)
{
this.parent = parent;
Coeffs = new double[] { 0.3, 0.3, 0.3, 0.3, 0.6, 0.3, 0.3, 0.3, 0.3 };
}
