private void DrawFrame(Graphics g, BrushesStorage brushes, PenStorage pens)
{
var brMain = brushes.GetBrush(SystemColors.ControlText);
var cy = Height / 2;
// текст (название тикера)
var fmt = new StringFormat {
LineAlignment = StringAlignment.Center
};
g.DrawString(Ticker, font, brMain, padding, cy, fmt);
// область истории
var barRight = Width - padding - imageCancel.Width - padding;
var barWd = barRight - barLeft;
if (barWd < 0)
{
barWd = 0;
}
barBounds = new Rectangle(barLeft, cy - barHeight / 2, barWd, barHeight);
if (barWd == 0)
{
return;
}
// рамка
g.DrawRectangle(pens.GetPen(SystemColors.ControlText), barBounds);
}
public void Draw(Font font, Graphics g, RectangleD worldRect, Rectangle canvasRect,
PenStorage penStorage, BrushesStorage brushStorage)
{
var strFormat = new StringFormat {
LineAlignment = StringAlignment.Center,
Alignment = StringAlignment.Center
};
var pen = penStorage.GetPen(Color.FromArgb(Transparency, ColorLine), Selected ? 3f : 1f);
var brush = brushStorage.GetBrush(Color.FromArgb(Transparency, ColorFill));
var brushText = brushStorage.GetBrush(Color.FromArgb(Transparency, ColorText));
var ptCenter = Conversion.WorldToScreen(new PointD(CandleIndex, Price),
worldRect, canvasRect);
screenX = ptCenter.X;
screenY = ptCenter.Y;
DrawShape(g, brush, ptCenter, pen);
// значок
g.DrawString(Sign, font, brushText, (float)ptCenter.X, (float)ptCenter.Y, strFormat);
// маркеры
if (Selected)
{
foreach (var marker in markers)
{
marker.CalculateScreenCoords(worldRect, canvasRect);
marker.Draw(g, penStorage, brushStorage);
}
}
}
public Image CreateSample(Size sizeHint)
{
var originalPoints = new List <PointF>(points);
points.Clear();
var centerx = sizeHint.Width / 2;
var centery = sizeHint.Height / 2;
var dx = sizeHint.Width / 2;
var dy = sizeHint.Height / 2;
var left = centerx - dx;
var top = centery - dy;
var width = sizeHint.Width;
var height = sizeHint.Height;
points.Add(new PointF(left, top));
points.Add(new PointF(left + width, top + height));
points.Add(new PointF(left + width / 2, top + height));
var worldRect = new RectangleD(left - 50, top - 50, width + 100, height + 100);
var result = new Bitmap(sizeHint.Width, sizeHint.Height);
var brushStorage = new BrushesStorage();
var penStorage = new PenStorage();
DrawEllipse(Graphics.FromImage(result), worldRect, new Rectangle(new Point(0, 0), sizeHint), brushStorage,
penStorage, new Font(FontFamily.GenericSansSerif, 8));
points.Clear();
points.AddRange(originalPoints);
return(result);
}
public Image CreateSample(Size sizeHint)
{
if (sizeHint.IsEmpty)
{
return(null);
}
var result = new Bitmap(sizeHint.Width, sizeHint.Height);
var g = Graphics.FromImage(result);
var brushStorage = new BrushesStorage();
var penStorage = new PenStorage();
var pen = penStorage.GetPen(Color.FromArgb(Transparency, ColorLine));
var brush = brushStorage.GetBrush(Color.FromArgb(Transparency, ColorFill));
var brushText = brushStorage.GetBrush(Color.FromArgb(Transparency, ColorText));
var ptCenter = new PointD(sizeHint.Width / 2.0, sizeHint.Height / 2.0);
DrawShape(g, brush, ptCenter, pen);
// значок
var strFormat = new StringFormat
{
LineAlignment = StringAlignment.Center,
Alignment = StringAlignment.Center
};
g.DrawString(Sign, new Font(FontFamily.GenericSansSerif, 8), brushText, (float)ptCenter.X,
(float)ptCenter.Y, strFormat);
return(result);
}
private void DrawComments(Graphics g, RectangleD worldRect, Rectangle canvasRect)
{
List <Rectangle> areasDrawn = null;
// контроль перекрывающихся комментов
if (hideSpannedComments)
{
areasDrawn = new List <Rectangle>();
}
using (var fonts = new FontStorage(new Font(Chart.Font.FontFamily, fontSize,
FontBold ? FontStyle.Bold : FontStyle.Regular)))
using (var penStorage = new PenStorage())
using (var brushStorage = new BrushesStorage())
{
for (var i = data.Count - 1; i >= 0; i--)
{
data[i].DrawComment(g, fonts, worldRect, canvasRect, penStorage, brushStorage, areasDrawn);
if (!hideSpannedComments)
{
continue;
}
}
}
}
/// <summary>
/// Прорисовать индикатор - пририсовка квадритика и надписи в соответствии с установлеными для них размеров и положения
/// </summary>
/// <param name="graphic">Объект типа "Graphics" контрола типа QuoteTradeControl на котором будем рисовать индикатор</param>
/// <param name="brushes">Кисть</param>
public void Draw(Graphics graphic, BrushesStorage brushes)
{
graphic.FillRectangle(brushes.GetBrush(Color.FromArgb(255, 192, 255, 192)), spreadPointRectangle);
graphic.DrawRectangle(new Pen(Color.FromArgb(255, 90, 188, 90), 1), spreadPointRectangle);
var pipsStr = (Value * precisionPower).ToString("N1");
// Устанавливаем стандартный размер шрифта
var textSize = spreadPointRectangle.Height / 1.5f > spreadPointRectangle.Width / 3f ? spreadPointRectangle.Width / 3f : spreadPointRectangle.Height / 1.5f;
var rectSize = graphic.MeasureString(pipsStr, new Font("Open Sans", textSize, FontStyle.Bold));
// Если при стандарном размере шрифта текст полкостью не влезает, то смотрим насколько не влезло и высчитаваем подходящий размер шрифта
if (rectSize.Height > spreadPointRectangle.Height || rectSize.Width > spreadPointRectangle.Width)
{
textSize = rectSize.Height > rectSize.Width
? textSize * spreadPointRectangle.Height / rectSize.Height - 0.5f
: textSize * spreadPointRectangle.Width / rectSize.Width - 0.5f;
rectSize = graphic.MeasureString(pipsStr, new Font("Open Sans", textSize, FontStyle.Bold));
}
var px = (spreadPointRectangle.Width - rectSize.Width) / 2;
var py = (spreadPointRectangle.Height - rectSize.Height) / 2;
graphic.DrawString(pipsStr, new Font("Open Sans", textSize, FontStyle.Bold),
brushes.GetBrush(Color.Black), spreadPointRectangle.X + px, spreadPointRectangle.Y + py);
}
private void DrawCursorCross(Graphics gr, BrushesStorage brushes)
{
if (!cursorInBounds)
{
return;
}
var pointModel = cursorCrossCoords;
var pointScreen = Conversion.WorldToScreen(pointModel.Value,
WorldRect, CanvasRect);
var pointRight = new PointD(CanvasRect.Width, CanvasRect.Height);
// нарисовать перекрестие
using (var penCross = new Pen(Chart.visualSettings.SeriesForeColor)
{
DashStyle = DashStyle.Custom,
DashPattern = dashPattern
})
{
gr.DrawLine(penCross, 0, (int)pointScreen.Y, (int)pointRight.X, (int)pointScreen.Y);
gr.DrawLine(penCross, (int)pointScreen.X, 0, (int)pointScreen.X, Height);
}
if (!ShowCrossToolTip)
{
return;
}
// нарисовать tooltip
var tipText = Chart.GetTipText((int)pointScreen.X, (int)pointScreen.Y);
if (!string.IsNullOrEmpty(tipText))
{
DrawHint(gr, pointScreen, tipText, brushes);
}
}
private void DrawTextOrSymbol(string comment,
BrushesStorage brushes,
FontStorage fonts,
Color commentColor, Graphics g,
float left, float top, float width, float height)
{
const int textShift = 4;
if (comment != null)
{
if (comment.Contains(TemplateBuy) || comment.Contains(TemplateSell))
{
var smb = symbolBuySell.Copy();
smb.Scale(SymbolBuySellWidth / smb.Width, SymbolBuySellHeight / smb.Height);
if (comment.Contains(TemplateBuy))
{
smb.Move2Point(new PointF(left + width / 2, top + height - textShift));
smb.PaintFills(Color.Blue);
}
if (comment.Contains(TemplateSell))
{
smb.Rotate((float)-Math.PI);
smb.Move2Point(new PointF(left + width / 2, top + textShift));
smb.PaintFills(Color.Red);
}
smb.Draw(g);
return;
}
}
var text = string.IsNullOrEmpty(comment) ? "<пусто>" : comment;
g.DrawFormattedText(left + textShift, top + textShift, brushes, commentColor,
text, fonts);
}
private void DrawYAxisGrid(Graphics g, BrushesStorage brushes)
{
if (GridLineVisible || GridBandVisible)
{
Rectangle canvasRect = Owner.CanvasRect;
RectangleD worldRect = Owner.WorldRect;
var pen = new Pen(GridLineColor);
var brush = brushes.GetBrush(GridBandColor);
pen.DashStyle = (DashStyle)Enum.Parse(typeof(DashStyle), GridLineStyle.ToString());
using (pen)
{
var ef =
(SizeF)Conversion.WorldToScreen(new SizeD(0.0, LabelInfo.MajorStep), worldRect, canvasRect);
float left = canvasRect.Left;
float right = canvasRect.Right;
right = (right < left) ? left : right;
double max = LabelInfo.Max;
bool flag = true;
while (max > LabelInfo.Min)
{
var tf = (PointF)Conversion.WorldToScreen(new PointD(0.0, max), worldRect, canvasRect);
if ((GridBandVisible && (GridBandColor != Color.Empty)) && flag)
{
g.FillRectangle(brush, canvasRect.Left, tf.Y, canvasRect.Width, ef.Height);
}
if (GridLineVisible)
{
g.DrawLine(pen, left, tf.Y, right, tf.Y);
}
flag = !flag;
max -= LabelInfo.MajorStep;
}
}
}
}
internal virtual void Draw(Graphics g)
{
try
{
using (var brushes = new BrushesStorage())
using (var pens = new PenStorage())
{
AdjustLayout();
DrawBackground(g, brushes);
DrawFrame(g);
GraphicsContainer container = g.BeginContainer();
g.TranslateTransform(ClientRect.X, ClientRect.Y);
DrawYAxis(g);
DrawStockSeries(g);
DrawSeries(g);
if (paneIconStrip != null)
{
paneIconStrip.Draw(g);
}
DrawCursorCross(g, brushes);
g.EndContainer(container);
// нарисовать иконки - кнопочки
DrawButtons(g, brushes, pens);
}
}
catch (Exception ex)
{
Logger.Error("Pane.Draw()", ex);
throw;
}
}
public override void Draw(Graphics g, RectangleD worldRect, Rectangle canvasRect)
{
base.Draw(g, worldRect, canvasRect);
using (var penStorage = new PenStorage())
using (var brushStorage = new BrushesStorage())
foreach (var marker in data)
{
var ptScreen = Conversion.WorldToScreen(new PointD(marker.candleIndex, marker.Price),
worldRect, canvasRect);
marker.Draw(g, ptScreen, Chart.Font);
if (marker.exitPair.HasValue)
{
var pairId = marker.exitPair;
var pair = data.FirstOrDefault(m => m.id == pairId);
if (pair != null)
{
var ptPair = Conversion.WorldToScreen(new PointD(pair.candleIndex, pair.Price),
worldRect, canvasRect);
// соединить две точки
var pen = penStorage.GetPen(Color.DarkSlateBlue, 1,
DashStyle.Dash);
g.DrawLine(pen, ptScreen.ToPointF(), ptPair.ToPointF());
}
}
if (marker.Selected)
{
marker.DrawMarker(g, worldRect, canvasRect, penStorage, brushStorage);
}
}
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
try
{
using (var brushes = new BrushesStorage())
using (var pens = new PenStorage())
{
// подготовить фон
DrawBackgr(e.Graphics, brushes);
// нарисовать разметку
DrawFrame(e.Graphics, brushes, pens);
// кнопка отмены
if (CancelEnabled)
{
e.Graphics.DrawImageUnscaled(imageCancel,
Width - imageCancel.Width - padding,
(Height - imageCancel.Height) / 2);
}
if (gaps == null)
{
return;
}
DrawGaps(e.Graphics, brushes);
}
}
catch (Exception ex)
{
Logger.Error("QuoteHistoryFillLineControl error", ex);
}
}
private void TrendLineTypeDialogLoad(object sender, EventArgs e)
{
// заполнить список линий
var w = imageListLarge.ImageSize.Width;
var h = imageListLarge.ImageSize.Height;
var rectWorld = new RectangleD(0, 0, w, h);
var rectCanvas = new Rectangle(0, 0, w, h);
var colors = new [] { Color.BlanchedAlmond, Color.GreenYellow, Color.PaleTurquoise };
var colorIndex = 0;
foreach (TrendLine.TrendLineStyle lineType in Enum.GetValues(typeof(TrendLine.TrendLineStyle)))
{
var bmp = new Bitmap(w, h);
var line = new TrendLine();
line.AddPoint(h * 0.23, w - 5);
line.AddPoint(h * 0.77, 5);
if (lineType == TrendLine.TrendLineStyle.Отрезок ||
lineType == TrendLine.TrendLineStyle.Окружность || lineType == TrendLine.TrendLineStyle.ЛинияСМаркерами ||
lineType == TrendLine.TrendLineStyle.ОтрезокСМаркерами)
{
line.linePoints[1] = new PointD(h * 0.32, w - 16);
line.linePoints[0] = new PointD(h * 0.68, 16);
}
line.LineColor = Color.Black;
line.ShapeFillColor = colors[colorIndex];
line.LineStyle = lineType;
colorIndex++;
if (colorIndex == colors.Length)
{
colorIndex = 0;
}
using (var gr = Graphics.FromImage(bmp))
using (var brushes = new BrushesStorage())
using (var pens = new PenStorage())
{
gr.SmoothingMode = SmoothingMode.AntiAlias;
line.Draw(gr, rectWorld, rectCanvas, pens, brushes);
}
imageListLarge.Images.Add(bmp);
var item = listView.Items.Add(lineType.ToString(),
EnumFriendlyName <TrendLine.TrendLineStyle> .GetString(lineType),
imageListLarge.Images.Count - 1);
item.Tag = lineType;
if (lineType == selectedStyle)
{
item.Selected = true;
}
}
// привязать картинки к списку
listView.LargeImageList = imageListLarge;
listView.SmallImageList = imageListLarge;
}
public QuotePartButton(float scaleX, float scaleY, BrushesStorage brushes, PenStorage pens, bool isLeft = true)
{
brushesStor = brushes;
pensStor = pens;
colorScheme.Add(ButtonFigureColorScheme.Normal, Color.FromArgb(255, 180, 247, 180));
colorScheme.Add(ButtonFigureColorScheme.Pressed, Color.FromArgb(255, 200, 247, 210));
colorScheme.Add(ButtonFigureColorScheme.Light, Color.FromArgb(255, 160, 195, 180));
currentBrush = brushesStor.GetBrush(colorScheme[ButtonFigureColorScheme.Normal]) as SolidBrush;
ScaleX = scaleX;
ScaleY = scaleY;
this.isLeft = isLeft;
translateMatrix = new Matrix();
string buySellIndicatorHaderText;
if (isLeft)
{
translateMatrix.Translate(paddingLeftRightProportion / 2, PaddingTopProportion);
buySellIndicatorHaderText = "Bid";
}
else
{
translateMatrix.Translate(QuotePartButtonFigure.OriginalWidth * 2 + paddingLeftRightProportion / 2, PaddingTopProportion);
translateMatrix.Scale(-1, 1);
buySellIndicatorHaderText = "Ask";
}
buySellIndicator = new BuySellIndicator
{
ScaleX = scaleX,
ScaleY = scaleY,
OriginalLocation = isLeft
?
new Point(
Convert.ToInt32(paddingLeftRightProportion),
Convert.ToInt32(PaddingTopProportion + PaddingTopBuySellIndicator))
:
new Point(
Convert.ToInt32(QuotePartButtonFigure.OriginalWidth + paddingLeftRightProportion),
Convert.ToInt32(PaddingTopProportion + PaddingTopBuySellIndicator)),
HaderText = buySellIndicatorHaderText,
Volume = null
};
arrowTrend = new ArrowTrend
{
Sx = ScaleX,
Sy = ScaleY,
Brushes = brushes,
Pens = pens,
OriginalLocation = isLeft ? new PointF(QuotePartButtonFigure.OriginalWidth - paddingLeftRightProportion - 2, PaddingTopArrow) :
new PointF(QuotePartButtonFigure.OriginalWidth * 2 - paddingLeftRightProportion - 2, PaddingTopArrow)
};
}
/// <summary>
/// нарисовать на истории полоски гэпов
/// </summary>
private void DrawGaps(Graphics g, BrushesStorage brushes)
{
if (gaps.Count == 0)
{
return;
}
var widthPx = barBounds.Width - 2;
if (widthPx == 0)
{
return;
}
var br = brushes.GetBrush(clHistOk);
g.FillRectangle(br, barBounds.Left + 1, barBounds.Top + 1, barBounds.Width - 1, barBounds.Height - 1);
// пересчитать модельные координаты в координаты времени,
// заодно склеив соседние
var startTick = Interval.a.Ticks;
var endTick = Interval.b.Ticks;
var widthTics = endTick - startTick;
var intervalsPx = new List <GapIntPx>();
GapIntPx?lastPoint = null;
var gapsCopy = gaps.ToArray();
foreach (var gap in gapsCopy)
{
var gapStartPx = (gap.start.Ticks - startTick) * widthPx / widthTics;
var gapEndPx = (gap.end.Ticks - startTick) * widthPx / widthTics;
var color = clGap[(int)gap.status];
if (lastPoint.HasValue)
{
if (lastPoint.Value.end >= gapStartPx && lastPoint.Value.color == color)
{
intervalsPx[intervalsPx.Count - 1] = new GapIntPx(lastPoint.Value.start, gapEndPx,
color);
continue;
}
}
lastPoint = new GapIntPx(gapStartPx, gapEndPx == gapStartPx ? gapStartPx + 1 : gapEndPx, color);
intervalsPx.Add(lastPoint.Value);
}
// отобразить
foreach (var inter in intervalsPx)
{
var brushGap = brushes.GetBrush(inter.color);
g.FillRectangle(brushGap,
inter.start + barLeft + 1,
barBounds.Top + 1,
(inter.end - inter.start),
barBounds.Height - 1);
}
}
private void DrawEllipses(Graphics g, RectangleD worldRect, Rectangle canvasRect)
{
using (var brushStorage = new BrushesStorage())
using (var penStorage = new PenStorage())
foreach (var ellipse in data)
{
ellipse.DrawEllipse(g, worldRect, canvasRect, brushStorage, penStorage, Chart.Font);
}
}
public void DrawComments(Graphics g, RectangleD worldRect, Rectangle canvasRect,
PenStorage penStorage, BrushesStorage brushStorage)
{
foreach (var marker in markers)
{
marker.CalculateScreenCoords(worldRect, canvasRect);
marker.Draw(g, penStorage, brushStorage);
}
}
private void DrawLabels(Graphics g,
BrushesStorage brushes,
Rectangle axisRect, YAxisAlignment alignment)
{
var canvasRect = Owner.CanvasRect;
var worldRect = Owner.WorldRect;
var format = PrepareStringFormat(alignment);
var provider = PrepareNumberFormat();
var brush = brushes.GetBrush(TextColor);
using (format)
{
var rect = new Rectangle(axisRect.Left + 5, 0, ((axisRect.Width - 5) - 5) - 1, Font.Height);
for (double i = LabelInfo.Max; i > LabelInfo.Min; i -= LabelInfo.MajorStep)
{
var tf = (PointF)Conversion.WorldToScreen(new PointD(0.0, i), worldRect, canvasRect);
rect.Y = ((int)tf.Y) - (Font.Height / 2);
double num2 = i / LabelInfo.Exponent;
if (axisRect.Contains(rect))
{
g.DrawString(num2.ToString("N", provider), Font, brush, rect, format);
}
}
if (CurrentPrice.HasValue)
{
// рисуем текущую цену в шкале
DrawSelectedPriceLabel(CurrentPrice.Value,
brush, format, axisRect, worldRect, canvasRect, g);
}
if (SelectedLabelPrice.HasValue)
{
// отметка цены для перекрестия
DrawSelectedPriceLabel(SelectedLabelPrice.Value,
brush, format, axisRect, worldRect, canvasRect, g);
}
switch (ShipsDrawMode)
{
case ShipsDrawMode.None:
break;
case ShipsDrawMode.Default:
DrawOrderShip(format, axisRect, worldRect, canvasRect, g); //Рисуем кораблики к открытым сделкам
break;
case ShipsDrawMode.Average:
DrawAverageOrderShip(format, axisRect, worldRect, canvasRect, g); //Рисуем кораблики средних значений к открытым сделкам
break;
default:
throw new ArgumentOutOfRangeException(nameof(ShipsDrawMode));
}
ExponentLabel.Draw(g, axisRect, alignment);
}
}
public void DrawMarkers(Graphics g, RectangleD worldRect, Rectangle canvasRect)
{
using (var penStorage = new PenStorage())
using (var brushStorage = new BrushesStorage())
foreach (var marker in markers)
{
marker.CalculateScreenCoords(worldRect, canvasRect);
marker.Draw(g, penStorage, brushStorage);
}
}
private void DrawXAxisGrid(Graphics g, BrushesStorage brushes)
{
Rectangle canvasRect = Owner.CanvasRect;
RectangleD worldRect = Owner.WorldRect;
GraphicsState gstate = g.Save();
g.SetClip(canvasRect);
if ((Chart.XAxis.GridLineVisible || Chart.XAxis.GridBandVisible) &&
(Chart.XAxis.Grid.Count > 0))
{
var pen = new Pen(Chart.XAxis.GridLineColor);
var brush = brushes.GetBrush(Chart.XAxis.GridBandColor);
pen.DashStyle = (DashStyle)Enum.Parse(typeof(DashStyle), Chart.XAxis.GridLineStyle.ToString());
using (pen)
{
bool flag = true;
XAxisLabelInfo info;
for (int i = 0; i < Chart.XAxis.Grid.Count; i++)
{
info = (XAxisLabelInfo)Chart.XAxis.Grid[i];
var tf = (PointF)Conversion.WorldToScreen(new PointD(info.X, 0.0), worldRect, canvasRect);
if (Chart.XAxis.GridBandVisible)
{
if (flag)
{
PointF tf2;
if (i != (Chart.XAxis.Grid.Count - 1))
{
var info2 = (XAxisLabelInfo)Chart.XAxis.Grid[i + 1];
tf2 =
(PointF)
Conversion.WorldToScreen(new PointD(info2.X, 0.0), worldRect, canvasRect);
}
else
{
tf2 = new PointF(canvasRect.Right, canvasRect.Top);
}
g.FillRectangle(brush, tf.X, 0f, tf2.X - tf.X, canvasRect.Height);
}
else if ((i == 0) && (tf.X > canvasRect.Left))
{
g.FillRectangle(brush, canvasRect.Left, 0f, tf.X - canvasRect.Left,
canvasRect.Height);
}
flag = !flag;
}
if (Chart.XAxis.GridLineVisible)
{
g.DrawLine(pen, tf.X, 0f, tf.X, (canvasRect.Height - 1));
}
}
}
}
g.Restore(gstate);
}
private void DrawButtons(Graphics g, BrushesStorage brushes, PenStorage pens)
{
if (customButtons == null)
{
return;
}
foreach (var btn in customButtons)
{
btn.Draw(g, brushes, pens);
}
}
private void DrawDragScaleMarks(Graphics g, BrushesStorage brushes)
{
if (!startDragPoint.HasValue)
{
return;
}
// найти X-координату (точно в центре области, занимаемой отметками оси)
var xCoord = startDragPoint.Value.X;
if (Chart.YAxisAlignment == YAxisAlignment.Left)
{
xCoord = (int)(LeftAxisRect.Left + LeftAxisRect.Width * 0.5);
}
else if (Chart.YAxisAlignment == YAxisAlignment.Right)
{
xCoord = (int)(RightAxisRect.Left + RightAxisRect.Width * 0.5);
}
else
{
var left = (int)(LeftAxisRect.Left + LeftAxisRect.Width * 0.5);
var right = (int)(RightAxisRect.Left + RightAxisRect.Width * 0.5);
var deltaLeft = Math.Abs(xCoord - left);
var deltaRight = Math.Abs(xCoord - right);
xCoord = deltaLeft < deltaRight ? left : right;
}
// нарисовать отметку начала перетягивания
const int pointStartR = 5, pointStartD = 10;
var brush = brushes.GetBrush(Chart.visualSettings.SeriesForeColor);
var ptCenter = new Point(xCoord, startDragPoint.Value.Y);
g.FillEllipse(brush, ptCenter.X - pointStartR, ptCenter.Y - pointStartR, pointStartD, pointStartD);
// нарисовать отметку текущей позиции курсора
if (!currentDragPoint.HasValue)
{
return;
}
const int shapeWd2 = 5, shapeHt2 = 4, shapeHt = 7;
var x = currentDragPoint.Value.X;
var y = currentDragPoint.Value.Y;
var dir = y > startDragPoint.Value.Y ? 1 : -1;
var points = new []
{
new Point(x - shapeWd2, y - shapeHt2 * dir),
new Point(x + shapeWd2, y - shapeHt2 * dir),
new Point(x, y + shapeHt * dir)
};
g.FillPolygon(brush, points);
}
public override void Draw(Graphics g, RectangleD worldRect, Rectangle canvasRect)
{
base.Draw(g, worldRect, canvasRect);
using (var pens = new PenStorage())
using (var brushes = new BrushesStorage())
{
foreach (TrendLine line in data)
{
line.Draw(g, worldRect, canvasRect, pens, brushes);
}
}
}
public Image CreateSample(Size sizeHint)
{
var result = new Bitmap(sizeHint.Width, sizeHint.Height);
var g = Graphics.FromImage(result);
var pens = new PenStorage();
var brushes = new BrushesStorage();
var worldRect = new RectangleD(StartIndex - 1, Price * 0.9, EndIndex + 1, Price * 1.1);
Draw(g, pens, brushes, worldRect, new Rectangle(new Point(0, 0), sizeHint),
new Font(FontFamily.GenericSansSerif, 8));
return(result);
}
public void DrawButtons(Graphics g)
{
if (customButtons == null)
{
return;
}
using (var brushes = new BrushesStorage())
using (var pens = new PenStorage())
foreach (var btn in customButtons)
{
btn.Draw(g, brushes, pens);
}
}
private void DrawTangent(List <PointD> screenPoints, Rectangle canvasRect, Graphics g, PenStorage penStorage,
BrushesStorage brushStorage, Font font)
{
var ptLeft = points[0].X < points[1].X ? points[0] : points[1];
var ptRight = points[0].X < points[1].X ? points[1] : points[0];
var m1 = new PointD(cx + b * Math.Sin(angle), cy + b * Math.Cos(angle));
var m2 = new PointD(cx + b * Math.Sin(angle + Math.PI), cy + b * Math.Cos(angle + Math.PI));
var m = ptLeft.Y > ptRight.Y
? m1.Y < m2.Y ? m1 : m2 // нижняя касательная для растущего эллипса
: m1.Y < m2.Y ? m2 : m1; // верхняя для падающего
var o = new PointD(cx, cy);
var r = new PointD(m.X - o.X, m.Y - o.Y);
var pen = penStorage.GetPen(TangentColor);
foreach (var level in tangentFiboLevels)
{
// нарисовать касательную или параллельную ей линию
var A = new PointD(screenPoints[0].X + r.X * (level + 1), screenPoints[0].Y + r.Y * (level + 1));
var B = new PointD(screenPoints[1].X + r.X * (level + 1), screenPoints[1].Y + r.Y * (level + 1));
if (TangentType == EllipseTangentType.Прямая)
{
StretchSpanToScreen(ref A, ref B, canvasRect);
}
g.DrawLine(pen, A.ToPointF(), B.ToPointF());
if (level == 0)
{
continue;
}
// нарисовать текстовую отметку
var ptText = new PointD(o.X + r.X * (level + 1), o.Y + r.Y * (level + 1));
var textSz = g.MeasureString(level.ToString(), font);
var textRect = new Rectangle((int)(ptText.X - textSz.Width / 2 - 2),
(int)(ptText.Y - textSz.Height / 2 - 2),
(int)textSz.Width + 4, (int)textSz.Height + 4);
var brushWhite = brushStorage.GetBrush(Color.FromArgb(60, pen.Color));
g.FillRectangle(brushWhite, textRect);
g.DrawRectangle(pen, textRect);
var brushText = brushStorage.GetBrush(pen.Color);
g.DrawString(level.ToString(), font, brushText, (float)ptText.X, (float)ptText.Y,
new StringFormat
{
Alignment = StringAlignment.Center,
LineAlignment = StringAlignment.Center
});
}
}
public override void Draw(Graphics g, RectangleD worldRect, Rectangle canvasRect)
{
if (data.Count == 0)
{
return;
}
base.Draw(g, worldRect, canvasRect);
using (var pens = new PenStorage())
using (var brushes = new BrushesStorage())
{
foreach (var span in data)
{
span.Draw(g, pens, brushes, worldRect, canvasRect, Chart.Font);
}
}
}
private void DrawHint(Graphics gr, PointD pointScreen,
string tipText, BrushesStorage brushes)
{
var spaceToRight = CanvasRect.Width - pointScreen.X;
var spaceToBotom = CanvasRect.Height - pointScreen.Y;
var tipSz = gr.MeasureString(tipText, Chart.Font);
const int textPadding = 2;
const int pointDisplace = 2;
tipSz.Width += textPadding * 2;
tipSz.Height += textPadding * 2;
var placeRight = spaceToRight >= tipSz.Width;
var placeBotom = spaceToBotom >= tipSz.Height;
var ptLeft = new Point((int)pointScreen.X + pointDisplace,
(int)pointScreen.Y + pointDisplace);
if (!placeRight)
{
ptLeft.X -= (pointDisplace * 2 + (int)tipSz.Width);
}
if (!placeBotom)
{
ptLeft.Y -= (pointDisplace * 2 + (int)tipSz.Height);
}
var rect = new Rectangle(ptLeft, new Size((int)tipSz.Width, (int)tipSz.Height));
using (var brushFill = new SolidBrush(Chart.visualSettings.PaneBackColor))
gr.FillRectangle(brushFill, rect);
using (var pen = new Pen(Chart.visualSettings.SeriesForeColor))
gr.DrawRectangle(pen, rect);
using (var brushText = new SolidBrush(Chart.visualSettings.SeriesForeColor))
{//brushes.GetBrush();
try
{
gr.DrawString(tipText, Chart.Font, brushText, ptLeft);
}
catch (Exception ex)
{
Logger.ErrorFormat("DrawHint::DrawString error (left is {0}) - {1}", ptLeft, ex);
//throw;
}
}
}
public override void Draw(Graphics g, RectangleD worldRect, Rectangle canvasRect)
{
base.Draw(g, worldRect, canvasRect);
using (var penDic = new PenStorage())
using (var brushStorage = new BrushesStorage())
foreach (var channel in data)
{
try
{
channel.Draw(g, worldRect, canvasRect, Chart.Font, penDic, brushStorage);
}
catch (Exception ex)
{
logNoFlood.LogMessageFormatCheckFlood(LogEntryType.Error,
LogMsgErrorDrawChannel, "SeriesFiboChannel darawing error: {0}", ex);
}
}
}
private void DrawBackground(Graphics g, BrushesStorage brushes,
Rectangle axisRect, YAxisAlignment alignment)
{
var brush = brushes.GetBrush(BackColor);
var pen = new Pen(ForeColor);
g.FillRectangle(brush, axisRect);
using (pen)
{
if (alignment == YAxisAlignment.Left)
{
g.DrawLine(pen, axisRect.Right - 1, axisRect.Top, axisRect.Right - 1, axisRect.Bottom - 1);
}
else if (alignment == YAxisAlignment.Right)
{
g.DrawLine(pen, axisRect.Left, axisRect.Top, axisRect.Left, axisRect.Bottom - 1);
}
}
}
