private void DrawRegion(Polyline chain, Graphics g,
RectangleD worldRect, Rectangle canvasRect,
PenStorage penStor, Pen markerPen, Brush markerBrush)
{
var linePoints = new List <PointF>();
for (var i = 0; i < chain.parts.Count; i++)
{
var p = Conversion.WorldToScreen(
new PointD(chain.parts[i].index - 0.5, (double)chain.parts[i].quote), worldRect, canvasRect);
linePoints.Add(new PointF((float)p.X, (float)p.Y));
}
var pen = penStor.GetPen(chain.color ?? lineColor);
g.DrawLines(pen, linePoints.ToArray());
if (MarkerRadius > 0)
{
foreach (var point in linePoints)
{
var ellipseRect = new RectangleF(
point.X - MarkerRadius, point.Y - MarkerRadius,
MarkerRadius * 2, MarkerRadius * 2);
g.FillEllipse(markerBrush, ellipseRect);
g.DrawEllipse(markerPen, ellipseRect);
}
}
}
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);
}
}
}
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)
{
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);
}
public void Draw(Graphics g, PenStorage penDic, float penWidth)
{
foreach (Polyline poly in lines)
{
if (poly.GetType() == typeof(Polygone))
{
g.FillPolygon(new SolidBrush(Color.FromArgb(alpha, ((Polygone)poly).FillColor)),
poly.points);
g.DrawPolygon(penDic.GetPen(poly.LineColor, penWidth), poly.points);
}
else
{
g.DrawLines(penDic.GetPen(poly.LineColor, penWidth), poly.points);
}
}
}
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);
}
private void DrawSpielerStat(Graphics g, BrushStorage brushes, PenStorage pens)
{
var top = Height - StatusStripHeight + 3;
var left = 20;
var spieler = Board.spielers[Board.currentSpielerIndex];
var text = "Spieler: " + spieler.Name + ", carrots: " + spieler.CarrotsSpare + ", cabbages: " +
spieler.CabbageSpare;
g.DrawString(text, cellFont, brushes.GetBrush(Color.Black), left, top);
var textSize = g.MeasureString(text, cellFont);
top += (int)textSize.Height + 3;
// выбор маркера
var tokens = Board.GetSpielerTokens();
tokenSelectors = tokens.Select((t, i) =>
new Point(left + i * (TokenSelectorSpan + TokenSelectorSz) + TokenSelectorSpan / 2, top + TokenSelectorSz / 2)).ToArray();
for (var i = 0; i < tokens.Length; i++)
{
var isSelected = Board.selectedTokenIndex >= 0 &&
Board.tokens[Board.selectedTokenIndex] == tokens[i];
var color = Token.TokenColor[tokens[i].ColorIndex];
var coords = tokenSelectors[i];
var rect = new Rectangle(coords.X - TokenSelectorSz / 2, coords.Y - TokenSelectorSz / 2,
TokenSelectorSz, TokenSelectorSz);
g.FillEllipse(brushes.GetBrush(color), rect);
if (isSelected)
{
g.DrawEllipse(pens.GetPen(Color.Black, 3), rect);
}
}
// нужно моркови / послед. ошибка
var notes = new List <string>();
if (carrotsNeeded != 0)
{
notes.Add(carrotsNeeded > 0 ? carrotsNeeded.ToString()
: "+" + (-carrotsNeeded).ToString());
}
if (!string.IsNullOrEmpty(lastError))
{
notes.Add(lastError);
}
if (notes.Count > 0)
{
top += TokenSelectorSz + 3;
left = 20;
g.DrawString(string.Join(", ", notes), Font, brushes.GetBrush(Color.Black), left, top);
}
}
private void DrawCell(int cellIndex, Graphics g, BrushStorage brushes, PenStorage pens)
{
var cell = Board.cells[cellIndex];
var ellipseRect = new Rectangle(cell.Location.X - cellShapeSz / 2, cell.Location.Y - cellShapeSz / 2,
cellShapeSz, cellShapeSz);
// залить фон
g.FillEllipse(brushes.GetBrush(Color.White), ellipseRect);
// граница
g.DrawEllipse(pens.GetPen(Color.Black, cellShapeSz > 22 ? 3 : 2,
cellIndex == selectedCellIndex ? DashStyle.Dot : DashStyle.Solid), ellipseRect);
// содержимое
int imageIndex;
if (imageByCellType.TryGetValue(cell.CellType, out imageIndex))
{
var bmp = pictures[imageIndex];
g.DrawImage(bmp, ellipseRect);
}
else
{
var textColor = cell.CellType == CellType.Cabbage
? Color.DarkGreen
: cell.CellType == CellType.Carrot ? Color.Brown : Color.Black;
var text = cell.CellType == CellType.Cabbage
? "CB" : cell.CellType == CellType.Carrot ? "Cr" : cell.CellType == CellType.Finish
? "fin" : cell.CellType == CellType.Hare ? "H" : cell.CellType == CellType.Hedgehog
? "Ig" : cell.CellType == CellType.Number ? cell.Points.ToString() : "St";
g.DrawString(text, cellFont, brushes.GetBrush(textColor), cell.Location.X, cell.Location.Y,
new StringFormat {
LineAlignment = StringAlignment.Center, Alignment = StringAlignment.Center
});
}
// индекс
g.DrawString(cellIndex.ToString(), indexFont, brushes.GetBrush(Color.Black),
cell.NumberLocation.X, cell.NumberLocation.Y,
new StringFormat {
LineAlignment = StringAlignment.Center, Alignment = StringAlignment.Center
});
// фишка
var tokenOnCell = Board.tokens.FirstOrDefault(t => t.Position == cellIndex);
if (tokenOnCell != null)
{
g.FillEllipse(brushes.GetBrush(Color.FromArgb(128, Token.TokenColor[tokenOnCell.ColorIndex])), ellipseRect);
}
}
private void DrawParts(Graphics g, RectangleD worldRect, Rectangle canvasRect)
{
using (var penStor = new PenStorage())
{
var markerPen = penStor.GetPen(lineColor);
using (var markerBrush = new SolidBrush(Color.White))
{
foreach (var chain in parts)
{
DrawRegion(chain, g, worldRect, canvasRect, penStor, markerPen, markerBrush);
}
}
}
}
public void Draw(Graphics g, PenStorage pens)
{
var oldMode = g.SmoothingMode;
g.SmoothingMode = SmoothingMode.AntiAlias;
var pen =
pens.GetPen(state == DrawState.Normal
? colorNormal
: state == DrawState.Hovered ? colorHovered : colorPressed, 0.7f);
g.DrawPolygon(pen, figurePoints.Select(p => new Point(p.X + area.Left, p.Y + area.Top)).ToArray());
g.SmoothingMode = oldMode;
}
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
});
}
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
spreadIndicator.Draw(e.Graphics, brushes);
leftButton.Draw(e.Graphics);
rightButton.Draw(e.Graphics);
Brush tickerBrush = null;
//Отрисовываем шапку контрола
switch (currentDragDropState)
{
case DragDropState.Normal:
tickerBrush = brushes.GetBrush(Color.Black);
break;
case DragDropState.Washy:
tickerBrush = brushes.GetBrush(Color.FromArgb(100, Color.DarkGray));
break;
case DragDropState.InFrame:
e.Graphics.DrawRectangle(pens.GetPen(Color.Black), PaddingLeftRightProportion / 2 * scaleX, PaddingBottonProportion,
Width - PaddingLeftRightProportion * scaleX, CalculatedHaderHeight);
tickerBrush = brushes.GetBrush(Color.Black);
break;
default:
tickerBrush = brushes.GetBrush(Color.Black);
break;
}
//Отрисовываем заголовок валютной пары
if (tickerBrush != null)
{
e.Graphics.DrawString(Ticker, new Font("Times New Roman", Height < Width ? 1 + Height / 9 : Width / 9, FontStyle.Bold), tickerBrush, PaddingBottonProportion, 0);
}
//Отрисовываем кнопку закрытия
var buttonCloseScale = scaleX < scaleY ? scaleX : scaleY;
btnClose.Location = new Point(Convert.ToInt32((QuotePartButtonFigure.OriginalWidth * 2 - PaddingLeftRightProportion / 2 - PaddingRightButtonCloseProportion) * scaleX), Convert.ToInt32(2f * scaleY));
btnClose.Size = new Size(Convert.ToInt32(ButtonCloseSizeProportion * buttonCloseScale), Convert.ToInt32(ButtonCloseSizeProportion * buttonCloseScale));
}
/// <summary>
/// Прорисовка кнопки на элементе "Graphics" контрола "QuoteTradeControl"
/// </summary>
/// <param name="graphics">Объект, на котором будт осущесвлятся прорисовка</param>
public void Draw(Graphics graphics)
{
scaleMatrix = new Matrix();
scaleMatrix.Scale(ScaleX, ScaleY);
Shape = QuotePartButtonFigure.instanceFigure.Clone() as GraphicsPath;
Shape.Transform(translateMatrix);
Shape.Transform(scaleMatrix);
graphics.FillPath(currentBrush, Shape);
graphics.DrawPath(pensStor.GetPen(Color.FromArgb(255, 64, 66, 64)), Shape);
if (buySellIndicator != null)
{
if (Value != null)
{
// Запоминаем значение для вычсления направления стрелки тренда
if (buySellIndicator.Volume == Value)
{
trandDeltaValues.Add(0);
}
else
{
trandDeltaValues.Add(buySellIndicator.Volume > Value ? -1 : 1);
}
buySellIndicator.Volume = Value;
}
buySellIndicator.ScaleX = ScaleX;
buySellIndicator.ScaleY = ScaleY;
buySellIndicator.Draw(graphics, brushesStor);
}
if (arrowTrend != null)
{
arrowTrend.Sx = ScaleX;
arrowTrend.Sy = ScaleY;
arrowTrend.DirectionAngle = trandDeltaValues.GetItemByIndex(0, true) * 1 + trandDeltaValues.GetItemByIndex(1, true) * 2 + trandDeltaValues.GetItemByIndex(2, true) * 4;
arrowTrend.Draw(graphics);
}
}
public void DrawProjection(Graphics g, RectangleD worldRect, Rectangle canvasRect, FiboSpanProjection proj,
Brush brushWhite, Font font, PenStorage penStorage, BrushesStorage brushes)
{
// нижняя точка
var projLow = Conversion.WorldToScreen(new PointD(proj.Index, 0), worldRect, canvasRect);
projLow.Y = canvasRect.Bottom;
// верхняя точка
PointD projHigh = proj.UpperPrice.HasValue
? Conversion.WorldToScreen(new PointD(proj.Index, proj.UpperPrice.Value), worldRect, canvasRect)
: new PointD(projLow.X, canvasRect.Top);
var dashStyle = proj.AckDegree == 1 ? DashStyle.Dash : DashStyle.Solid;
var pen = penStorage.GetPen(proj.Color, 1, dashStyle);
g.DrawLine(pen, (float)projLow.X, (float)projLow.Y, (float)projHigh.X, (float)projHigh.Y);
if (proj.AckDegree > 1)
{// показать степень подтверждения
const int textOffset = 37;
const int textSize = 18, textSize2 = 9;
g.FillEllipse(brushWhite, (float)projLow.X - textSize2, (float)projLow.Y - textOffset - textSize2,
textSize, textSize);
g.DrawEllipse(pen, (float)projLow.X - textSize2, (float)projLow.Y - textOffset - textSize2,
textSize, textSize);
var text = proj.AckDegree.ToString();
var textSz = g.MeasureString(text, Chart.Font);
var textLeft = (float)projLow.X - textSz.Width / 2;
var textTop = (float)projLow.Y - textSz.Height / 2 - textOffset;
var brush = brushes.GetBrush(proj.Color);
g.DrawString(text, font, brush, textLeft, textTop);
textTop += (textSize + 4);
var timeStr = Chart.StockSeries.GetCandleOpenTimeByIndex(proj.Index).ToString("dd MMM HH:ss");
textSz = g.MeasureString(timeStr, Chart.Font);
textLeft = (float)projLow.X - textSz.Width / 2;
g.FillRectangle(brushWhite, textLeft - 2, textTop - 2, textSz.Width + 4, textSz.Height + 3);
g.DrawRectangle(pen, textLeft - 2, textTop - 2, textSz.Width + 4, textSz.Height + 3);
g.DrawString(timeStr, Chart.Font, brush, textLeft, textTop);
}
}
public void DrawSpan(Graphics g, RectangleD worldRect, Rectangle canvasRect,
FiboSpan span, Brush brushWhite, PenStorage penStorage)
{
if (span.points.Count == 0)
{
return;
}
var pen = penStorage.GetPen(span.Color);
var ptA = Conversion.WorldToScreen(new PointD(span.points[0].X, span.points[0].Y),
worldRect, canvasRect);
if (span.points.Count == 2)
{
var ptB = Conversion.WorldToScreen(new PointD(span.points[1].X, span.points[1].Y),
worldRect, canvasRect);
g.DrawLine(pen, ptA.ToPointF(), ptB.ToPointF());
DrawMarker(g, pen, brushWhite, ptB);
}
DrawMarker(g, pen, brushWhite, ptA);
}
public void Draw(Graphics g, PenStorage penStorage, BrushesStorage brushStorage)
{
var pen = penStorage.GetPen(Color.Black);
var brush = brushStorage.GetBrush(Color.White);
if (action == MarkerAction.Move)
{
var points = new[]
{
new Point((int)centerScreen.X - Size2, (int)centerScreen.Y),
new Point((int)centerScreen.X, (int)centerScreen.Y - Size2),
new Point((int)centerScreen.X + Size2, (int)centerScreen.Y),
new Point((int)centerScreen.X, (int)centerScreen.Y + Size2)
};
g.FillPolygon(brush, points);
g.DrawPolygon(pen, points);
return;
}
g.FillRectangle(brush, (float)centerScreen.X - Size2, (float)centerScreen.Y - Size2, Size, Size);
g.DrawRectangle(pen, (float)centerScreen.X - Size2, (float)centerScreen.Y - Size2, Size, Size);
}
public virtual void Draw(Graphics g, BrushesStorage brushes, PenStorage pens)
{
var images = buttonImage[key];
// нарисовать подложку и обводку
if (State == ImageState.Pressed)
{
var brush =
brushes.GetBrush(Color.FromArgb(128, ColorThemeIndex == 0 ? Color.Black : Color.White));
g.FillRectangle(brush, Position.X, Position.Y, Size.Width - 1, Size.Height - 1);
}
if (State == ImageState.Highlighted || State == ImageState.Pressed)
{
var pen = pens.GetPen(ColorThemeIndex == 0 ? Color.Black : Color.White);
g.DrawRectangle(pen, Position.X, Position.Y, Size.Width - 1, Size.Height - 1);
}
// нарисовать картинку
var img = images.images[ColorThemeIndex, imageIndex];
var padding = (Size.Width - img.Width) / 2;
g.DrawImage(img, Position.X + padding, Position.Y + padding, img.Width, img.Height);
}
public void Draw(Graphics g, PenStorage pens, BrushesStorage brushes,
RectangleD worldRect, Rectangle canvasRect, Font font)
{
var ptA = Conversion.WorldToScreen(new PointD(StartIndex, Price),
worldRect, canvasRect);
var ptB = Conversion.WorldToScreen(new PointD(EndIndex, Price),
worldRect, canvasRect);
// линия
var pen = pens.GetPen(LineColor, LineWidth);
g.DrawLine(pen, (float)ptA.X, (float)ptA.Y, (float)ptB.X, (float)ptB.Y);
// текст
if (string.IsNullOrEmpty(TextLeft) && string.IsNullOrEmpty(TextRight))
{
return;
}
const int textOffsetPx = 2;
var brush = brushes.GetBrush(LineColor);
var fmt = new StringFormat
{
Alignment = StringAlignment.Far, LineAlignment = StringAlignment.Center
};
if (!string.IsNullOrEmpty(TextLeft))
{
g.DrawString(TextLeft, font, brush, (float)ptA.X - textOffsetPx,
(float)ptA.Y, fmt);
}
if (!string.IsNullOrEmpty(TextRight))
{
fmt.Alignment = StringAlignment.Near;
g.DrawString(TextRight, font, brush, (float)ptB.X + textOffsetPx,
(float)ptB.Y, fmt);
}
}
public void DrawComment(
Graphics g, FontStorage fonts,
RectangleD worldRect, Rectangle canvasRect, PenStorage penStorage,
BrushesStorage brushStorage,
List <Rectangle> areasToCheck)
{
var oldMode = g.SmoothingMode;
g.SmoothingMode = /*SmoothingMode.AntiAlias : */ SmoothingMode.None;
try
{
var brush = brushStorage.GetBrush(Color.FromArgb(FillTransparency, ColorFill));
// нормализовать угол стрелки
var arrowAngle = GetNormalizedArrowAngle();
while (arrowAngle < 0)
{
arrowAngle = Math.PI * 2 + arrowAngle;
}
// точка привязки
PointD ptPivot = Conversion.WorldToScreen(new PointD(PivotIndex, PivotPrice),
worldRect, canvasRect);
// вторая точка стрелки
var ptEnd = new PointD(ptPivot.X + ArrowLength * Math.Cos(arrowAngle),
ptPivot.Y + ArrowLength * Math.Sin(arrowAngle));
var commentText = string.IsNullOrEmpty(Text) ? "" : Text;
var color = Color;
commentText = GetColorByComment(commentText, ref color);
ReplaceTextPatterns();
var dashStyle = IsBeingCreated ? DashStyle.Dash : DashStyle.Solid;
var pen = penStorage.GetPen(color,
Selected ? 3f : 1f, dashStyle);
// посчитать координаты текста
float top, left, width, height;
GetTextAreaLeftTop(g, fonts, commentText, arrowAngle, ptEnd,
out left, out top, out width, out height);
// проверить пересечение с комментом
if (areasToCheck != null)
{
var rectOwn = new Rectangle((int)top, (int)left, (int)width, (int)height);
if (areasToCheck.Any(a => a.IntersectsWith(rectOwn)))
{
return;
}
areasToCheck.Add(rectOwn);
}
// нарисовать область с текстом
if (!HideBox)
{
DrawTextArea(pen, g, brush, left, top, width, height);
}
// .. и сам текст
DrawTextOrSymbol(commentText, brushStorage, fonts, ColorText, g, left, top, width, height);
TextArea = new Rectangle((int)left + canvasRect.Left, (int)top, (int)width, (int)height);
// нарисовать стрелку
if (!HideArrow)
{
PointD pointArrowEnd;
List <PointF> arrowPoints = GetArrowPoints(arrowAngle, ptPivot, out pointArrowEnd);
// нарисовать палку
g.DrawLine(pen, (float)pointArrowEnd.X, (float)pointArrowEnd.Y, (float)ptEnd.X, (float)ptEnd.Y);
// нарисовать стрелочку
g.FillPolygon(brush, arrowPoints.ToArray());
g.DrawPolygon(pen, arrowPoints.ToArray());
}
// маркеры
if (Selected)
{
DrawMarkers(g, worldRect, canvasRect);
}
}
finally
{
g.SmoothingMode = oldMode;
}
}
public void Draw(Graphics g, RectangleD worldRect, Rectangle canvasRect,
Brush brush, Font fnt, PenStorage penStorage,
bool doDrawText)
{
spansProjScreenCoords.Clear();
rectanglesTextScreenCoords.Clear();
var pen = penStorage.GetPen(Color, Selected ? 2f : 1f, DashStyle.Dot);
var screenPoints = points.Select(point =>
Conversion.WorldToScreen(new PointD(point.a, point.b), worldRect, canvasRect)).ToList();
// сохранить координаты начального отрезка (для проверки попадания)
if (screenPoints.Count > 1)
{
spanBaseScreenCoords = new Cortege2 <Point, Point>(screenPoints[0].ToPoint(), screenPoints[1].ToPoint());
}
// соединить
if (Completed && HideLine == false)
{
g.DrawLine(pen, (float)screenPoints[0].X, (float)screenPoints[0].Y,
(float)screenPoints[1].X, (float)screenPoints[1].Y);
}
// нарисовать кружки
foreach (var point in screenPoints)
{
g.FillEllipse(brush, (float)point.X - 3, (float)point.Y - 3, 6, 6);
g.DrawEllipse(pen, (float)point.X - 3, (float)point.Y - 3, 6, 6);
}
// нарисовать проекции
if (points.Count < 2 || points[0].b == points[1].b || pricesProj == null)
{
return;
}
visibleParts = new List <ProjectionLinePart>();
if (IsExtension)
{
foreach (var price in pricesProj)
{
visibleParts.Add(new ProjectionLinePart(StartIndex,
EndIndex, price));
}
}
if (IsCorrection)
{
foreach (var price in pricesCorr)
{
visibleParts.Add(new ProjectionLinePart(StartIndex,
EndIndex, price));
}
}
// скрыть "лишние" кусочки
if (HideFarParts)
{
DoHideFarParts(visibleParts);
}
foreach (var part in visibleParts)
{
var ptScrLeft = Conversion.WorldToScreen(new PointD(part.left,
part.price), worldRect, canvasRect);
var ptScrRight = Conversion.WorldToScreen(new PointD(part.right,
part.price), worldRect, canvasRect);
part.x1 = (float)ptScrLeft.X;
part.y1 = (float)ptScrLeft.Y;
part.x2 = (float)ptScrRight.X;
part.y2 = (float)ptScrRight.Y;
g.DrawLine(pen, (float)ptScrLeft.X, (float)ptScrLeft.Y, (float)ptScrRight.X, (float)ptScrRight.Y);
// сохранить координаты
spansProjScreenCoords.Add(new Cortege2 <Point, Point>(
new Point((int)ptScrLeft.X, (int)ptScrLeft.Y),
new Point((int)ptScrRight.X, (int)ptScrRight.Y)));
}
if (doDrawText)
{
using (var fontBrush = new SolidBrush(Color))
{
var strFormat = new StringFormat {
LineAlignment = StringAlignment.Center
};
foreach (var part in visibleParts)
{
if (part.left == part.right)
{
continue;
}
var priceStr = part.price.ToStringUniformPriceFormat(false);
var textSz = g.MeasureString(priceStr, fnt);
if (Markers == MarkerPlacement.Слева ||
Markers == MarkerPlacement.ДвеМетки)
{
g.DrawString(priceStr, fnt, fontBrush, part.x1 - textSz.Width - 2, part.y1, strFormat);
rectanglesTextScreenCoords.Add(new Rectangle((int)(part.x1 - textSz.Width - 2), (int)(part.y1 - textSz.Height / 2),
(int)textSz.Width, (int)textSz.Height));
}
if (Markers == MarkerPlacement.Справа ||
Markers == MarkerPlacement.ДвеМетки)
{
g.DrawString(priceStr, fnt, fontBrush, part.x2 + 2, part.y2, strFormat);
rectanglesTextScreenCoords.Add(new Rectangle((int)(part.x2 + 2), (int)(part.y2 - textSz.Height / 2),
(int)textSz.Width, (int)textSz.Height));
}
}
}
}
if (Selected)
{
DrawMarkers(g, worldRect, canvasRect);
}
}
public void DrawEllipse(Graphics g, RectangleD worldRect, Rectangle canvasRect,
BrushesStorage brushStorage, PenStorage penStorage, Font font)
{
const int markerSize = 3;
var pen = penStorage.GetPen(Color, Selected ? 3f : 1f);
var screenPoints = new List <PointD>();
foreach (var pt in points)
{
screenPoints.Add(Conversion.WorldToScreen(new PointD(pt.X, pt.Y),
worldRect, canvasRect));
}
foreach (var pt in screenPoints)
{
g.DrawRectangle(pen, (float)pt.X - markerSize, (float)pt.Y - markerSize,
markerSize * 2F, markerSize * 2F);
}
if (screenPoints.Count == 2)
{
g.DrawLine(pen, screenPoints[0].ToPointF(), screenPoints[1].ToPointF());
}
if (screenPoints.Count == 3)
{
// нарисовать собственно эллипс
double newAngle;
float newCx, newCy, newA, newB;
correctEllipse = Geometry.GetEllipseParams(screenPoints[0].ToPointF(),
screenPoints[1].ToPointF(),
screenPoints[2].ToPointF(),
out newAngle, out newA, out newB, out newCx, out newCy);
if (correctEllipse) // можно построить эллипс - рисуем его
{
a = newA;
b = newB;
angle = newAngle;
cx = newCx;
cy = newCy;
var ellipseBezierPoints = Geometry.GetEllipseBezierPoints(newAngle, newA, newB, newCx, newCy);
g.DrawBeziers(pen, ellipseBezierPoints);
if (BrushAlpha > 0)
{
var brush = brushStorage.GetBrush(Color.FromArgb(BrushAlpha, BrushColor));
g.FillClosedCurve(brush, ellipseBezierPoints);
}
// строить касательную
if (BuildTangent)
{
DrawTangent(screenPoints, canvasRect, g,
penStorage, brushStorage, font);
}
}
else // построить эллипс по указанным координатам невозможно
{
g.DrawLine(pen, screenPoints[1].ToPointF(), screenPoints[2].ToPointF());
g.DrawLine(pen, screenPoints[0].ToPointF(), screenPoints[2].ToPointF());
}
}
// маркеры
if (Selected)
{
DrawComments(g, worldRect, canvasRect, penStorage, brushStorage);
}
}
public void Draw(Graphics g, RectangleD worldRect, Rectangle canvasRect, Font font,
PenStorage penDic, BrushesStorage brushStorage)
{
spansInScreenCoords.Clear();
Draw(g, worldRect, canvasRect, penDic, brushStorage);
if (linePoints.Count == 2)
{// сохранить экранные координаты задающего отрезка
spansInScreenCoords.Add(new Cortege2 <Point, Point>(
new Point((int)screenPointA.X, (int)screenPointA.Y),
new Point((int)screenPointB.X, (int)screenPointB.Y)));
}
if (!Point3.HasValue)
{
return;
}
PointD oldPoint0 = linePoints[0], oldPoint1 = linePoints[1];
// параллельно перенести прямую по уровням
var pointC = ProjectDotOnSpan(worldRect, canvasRect);
var vector = new PointD(Point3.Value.X - pointC.X, Point3.Value.Y - pointC.Y);
// начальная прямая
linePoints[0] = oldPoint0 + vector;
linePoints[1] = oldPoint1 + vector;
Draw(g, worldRect, canvasRect, penDic, brushStorage);
spansInScreenCoords.Add(new Cortege2 <Point, Point>(
new Point((int)screenPointA.X, (int)screenPointA.Y),
new Point((int)screenPointB.X, (int)screenPointB.Y)));
// нормаль
var vectorScale = series.Count == 0 ? 1.0 : series[series.Count - 1] + 1;
var pointC2 = pointC + vector * vectorScale;
var pointArrow = Conversion.WorldToScreen(pointC + vector, worldRect, canvasRect);
var screenC = Conversion.WorldToScreen(pointC, worldRect, canvasRect);
var screenC2 = Conversion.WorldToScreen(pointC2, worldRect, canvasRect);
using (var pen = new Pen(LineColor)
{
DashStyle = DashStyle.Dot
})
{
g.DrawLine(pen, screenC.ToPointF(), screenC2.ToPointF());
g.DrawPolygon(pen, GetArrowPoints(screenC, pointArrow));
// сохранить экранные координаты нормали
spanNormalScreenCoords = new Cortege2 <Point, Point>(screenC.ToPoint(), screenC2.ToPoint());
}
// ряд прямых
var rectPen = penDic.GetPen(LineColor);
foreach (var level in series)
{
var vectorScaled = vector * (1 + level);
linePoints[0] = oldPoint0 + vectorScaled;
linePoints[1] = oldPoint1 + vectorScaled;
Draw(g, worldRect, canvasRect, penDic, brushStorage);
// сохранить координаты (для проверки попадания)
spansInScreenCoords.Add(new Cortege2 <Point, Point>(
new Point((int)screenPointA.X, (int)screenPointA.Y),
new Point((int)screenPointB.X, (int)screenPointB.Y)));
// вывести подпись в рамке
if (DrawText)
{
var whiteBrush = brushStorage.GetBrush(Color.White);
var brush = brushStorage.GetBrush(LineColor);
var ptText = pointC + vectorScaled;
ptText = Conversion.WorldToScreen(ptText, worldRect, canvasRect);
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);
g.FillRectangle(whiteBrush, textRect);
g.DrawRectangle(rectPen, textRect);
g.DrawString(level.ToString(), font, brush, (float)ptText.X, (float)ptText.Y,
new StringFormat
{
Alignment = StringAlignment.Center,
LineAlignment = StringAlignment.Center
});
}
}
// восстановить начальные точки
linePoints[0] = oldPoint0;
linePoints[1] = oldPoint1;
}
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
using (var pens = new PenStorage())
using (var brushes = new BrushesStorage())
{
var str = MakeDisplayedString();
// залить прямоугольник и отрисовать границу
var outerRectColor = Selected ? clOutlineSel[blinkCounter] : clOutline;
var pen = pens.GetPen(outerRectColor, BookmarkDrawState == DrawState.Pressed ||
DragState != DragDropState.Normal ? 2 : 1);
var brColor = brushColor[BookmarkDrawState];
if (IsBlinking)
{
brColor = brushColor[(DrawState)blinkCounter];
}
var brush = brushes.GetBrush(brColor);
var area = new Rectangle(new Point(0, 0), new Size(Width - 1, Height - 1));
e.Graphics.FillRectangle(brush, area);
e.Graphics.DrawRectangle(pen, area);
// нарисовать "тень"
if (Selected || DragState == DragDropState.InFrame)
{
var penSelected = pens.GetPen(clOutlineSel[blinkCounter]);
e.Graphics.DrawLine(penSelected, 1, 1, Width - 1, 1);
e.Graphics.DrawLine(penSelected, 1, 1, 1, Bottom - 1);
}
// нарисовать крестик контрастным
if (modeEdit)
{
var brushCross = brushes.GetBrush(closeBtnVisible ? clOutline : MakeContrastColor(brColor, 26));
var points =
pointsCross.Select(p => new PointF(p.X + areaCross.Left, p.Y + areaCross.Top)).ToArray();
e.Graphics.FillPolygon(brushCross, points);
}
// нарисовать картинку
var left = TilePad;
if (Bookmark.ShouldDrawImage && ImageList.Images.Count > Bookmark.ImageIndex && Bookmark.ImageIndex >= 0)
{
e.Graphics.DrawImage(ImageList.Images[Bookmark.ImageIndex], left, (TileH - ImageSize) / 2);
left += (ImageSize + TilePad);
}
// нарисовать текст
if (Bookmark.ShouldDrawText && str.Length > 0)
{
e.Graphics.DrawString(str,
Selected ? fontSelected : Font,
brushes.GetBrush(clOutline),
left, TileH / 2, new StringFormat
{
LineAlignment = StringAlignment.Center
});
}
}
}
