/**
* Gets the size of the margin in inches.
* @param margin which margin to Get
* @return the size of the margin
*/
public double GetMargin(MarginType margin)
{
IMargin m = GetMarginRec(margin);
if (m != null)
{
return(m.Margin);
}
else
{
switch (margin)
{
case MarginType.LeftMargin:
return(.7);
case MarginType.RightMargin:
return(.7);
case MarginType.TopMargin:
return(.75);
case MarginType.BottomMargin:
return(.75);
}
throw new InvalidOperationException("Unknown margin constant: " + margin);
}
}
/**
* Sets the size of the margin in inches.
* @param margin which margin to Get
* @param size the size of the margin
*/
public void SetMargin(MarginType margin, double size)
{
IMargin m = GetMarginRec(margin);
if (m == null)
{
switch (margin)
{
case MarginType.LeftMargin:
_leftMargin = new LeftMarginRecord();
m = _leftMargin;
break;
case MarginType.RightMargin:
_rightMargin = new RightMarginRecord();
m = _rightMargin;
break;
case MarginType.TopMargin:
_topMargin = new TopMarginRecord();
m = _topMargin;
break;
case MarginType.BottomMargin:
_bottomMargin = new BottomMarginRecord();
m = _bottomMargin;
break;
default:
throw new InvalidOperationException("Unknown margin constant: " + margin);
}
}
m.Margin = size;
}
/// <summary>
/// Draws the view
/// </summary>
/// <param name="drawing">drawing wrapper</param>
/// <param name="options">drawing options</param>
/// <param name="margin">drawing margin</param>
public virtual void Draw(IDrawing drawing, IDrawOptions options, IMargin margin)
{
if (drawing == null || margin == null)
{
throw new InvalidArgumentException("parameter is null");
}
if (!(options is DataDrawOptions))
{
throw new InvalidArgumentException("options is not compatible");
}
var state = ((DataDrawOptions)options).State;
var canvasSize = options.CanvasSize;
var clip = new System.Drawing.RectangleF((float)margin.Left, (float)margin.Top, (float)(canvasSize.Width - margin.LeftAndRight), (float)(canvasSize.Height - margin.TopAndBottom));
if (options.DrawOnlyNewData)
{
DrawNewData(state, drawing, options, margin, canvasSize, clip);
}
else
{
DrawAllData(state, drawing, margin, canvasSize, clip);
}
}
private void WriteTreeNode(IMargin margin, StringBuilder builder, String indent)
{
builder.Append($"{margin.Name}");
if (margin.Name != margin.Identifier)
{
if (margin.Identifier.Contains(" ") && (margin.Name != "Add-on"))
{
builder.Append($" \"{margin.Identifier}\"");
}
else
{
builder.Append($" {margin.Identifier}");
}
}
builder.AppendLine($" = {Amount.Round(margin.Value, 2).ToString(m_FormatProvider, CurrencyCodeSymbol.None)}");
Int32 lastIndex = margin.ChildrenCount - 1;
for (Int32 i = 0; i < margin.ChildrenCount; ++i)
{
IMargin child = margin.Children[i];
WriteTreeNodeChild(child, builder, indent, (i == lastIndex));
}
}
/// <summary>
/// Draws the view
/// </summary>
/// <param name="drawing">drawing wrapper</param>
/// <param name="options">drawing options</param>
/// <param name="margin">drawing margin</param>
public virtual void Draw(IDrawing drawing, IDrawOptions options, IMargin margin)
{
if (drawing == null || margin == null)
{
throw new InvalidArgumentException("parameter is null");
}
if (!(options is ScalingDrawOptions))
{
throw new InvalidArgumentException("options is not compatible");
}
var state = ((ScalingDrawOptions)options).State;
var canvasSize = options.CanvasSize;
var clip = new RectangleF((float)margin.Left, (float)margin.Top, (float)(canvasSize.Width - margin.LeftAndRight), (float)(canvasSize.Height - margin.TopAndBottom));
if (state.MovingStart != null && state.MovingPosition != null)
{
drawing.Line(state.MovingPenColor, state.MovingStart.Value.X, state.MovingStart.Value.Y, state.MovingPosition.Value.X, state.MovingPosition.Value.Y, clip);
}
if (state.ScalingStart != null && state.ScalingPosition != null)
{
Rectangle rectangle = SortCoordinates(state.ScalingStart.Value, state.ScalingPosition.Value);
var color = state.ZoomIncrease ? state.ZoomInPenColor : state.ZoomOutPenColor;
drawing.Rectangle(color, rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height, clip);
}
}
public static void CreateBaseServices(IApplicationController applicationController, IDataProviderService provider,
out IGridState gridState, out IDataDrawState graphState,
out IItemFormatter itemFormatter, out IMargin margin,
out IDataService dataService, out IScaleService scaleService, ref IBufferedDrawingService bufferedDrawingService)
{
var formView = new TestGraphControlFormView();
margin = formView.GraphMargin;
itemFormatter = formView.ItemFormatter;
var labelMargin = formView.LabelMargin;
// Set property and Reset()
formView.LabelMargin = labelMargin;
formView.Reset();
TestFactory.CreateStateInstancees(applicationController,
out IBackgroundState backgroundState, out gridState, out IScaleState scaleState, out graphState, out IGraphControlFormState graphControlFormState);
TestFactory.CreateServiceInstances(applicationController,
margin, scaleState,
out dataService, out scaleService, ref bufferedDrawingService);
if (provider != null)
{
dataService.RegisterDataProvider(provider);
}
}
public void Refresh(IMargin margin)
{
_updateMargin = margin;
Invalidate(_updateMargin.DrawingPosition);
Update();
_updateMargin = null;
}
private static void CreateStateInstances(IApplicationController applicationController,
IItemFormatter itemFormatter,
IMargin labelMargin,
out IBackgroundState backgroundState,
out IGridState gridState,
out IScaleState scaleState,
out IDataDrawState graphState,
out IScalingState scalingState,
out IGraphControlFormState graphControlFormState)
{
backgroundState = new BackgroundState();
applicationController.RegisterInstance <IBackgroundState>(backgroundState);
gridState = new GridState();
gridState.LabelPadding = labelMargin;
gridState.ItemFormatter = itemFormatter;
applicationController.RegisterInstance <IGridState>(gridState);
scaleState = new ScaleState();
applicationController.RegisterInstance <IScaleState>(scaleState);
graphState = new DataDrawState();
applicationController.RegisterInstance <IDataDrawState>(graphState);
scalingState = new ScalingState();
applicationController.RegisterInstance <IScalingState>(scalingState);
graphControlFormState = new GraphControlFormState();
applicationController.RegisterInstance <IGraphControlFormState>(graphControlFormState);
}
/// <summary>
/// Draws the view
/// </summary>
/// <param name="drawing">drawing wrapper</param>
/// <param name="options">drawing options</param>
/// <param name="margin">drawing margin</param>
public virtual void Draw(IDrawing drawing, IDrawOptions options, IMargin margin)
{
if (drawing == null || margin == null)
{
throw new InvalidArgumentException("parameter is null");
}
if (!(options is GridDrawOptions))
{
throw new InvalidArgumentException("options is not compatible");
}
var state = ((GridDrawOptions)options).State;
var canvasSize = options.CanvasSize;
// Step 1 - Measure all texts and calc offsets
MeashureLabelSizes(drawing, margin, state, canvasSize, out SizeF strX, out SizeF strY, out double stepDataY);
// Step 2 - Draw vertical lines
DrawVerticalLines(drawing, margin, state, canvasSize, strX, out double stepDataX);
// Step 3 - Draw horizontal lines
DrawHorizontalLines(drawing, margin, state, canvasSize, ref strY, ref stepDataY);
// Step 4 - Draw axis X and Y
DrawAxis(drawing, margin, state, canvasSize, strX, strY, stepDataY, stepDataX);
this.scaleService.SetStepX(stepDataX);
this.scaleService.SetStepY(stepDataY);
}
protected override void OnMouseMove(MouseEventArgs e)
{
base.OnMouseMove(e);
if (!_toolTipRectangle.Contains(e.Location))
{
_toolTipRectangle = Rectangle.Empty;
if (_toolTipActive)
{
RequestToolTip(e.Location);
}
}
foreach (IMargin margin in _leftMargins)
{
if (margin.DrawingPosition.Contains(e.X, e.Y))
{
Cursor = margin.Cursor;
margin.HandleMouseMove(new Point(e.X, e.Y), e.Button);
if (_lastMouseInMargin != margin)
{
if (_lastMouseInMargin != null)
{
_lastMouseInMargin.HandleMouseLeave(EventArgs.Empty);
}
_lastMouseInMargin = margin;
}
return;
}
}
if (_lastMouseInMargin != null)
{
_lastMouseInMargin.HandleMouseLeave(EventArgs.Empty);
_lastMouseInMargin = null;
}
if (TextView.DrawingPosition.Contains(e.X, e.Y))
{
TextLocation realmousepos = TextView.GetLogicalPosition(e.X - TextView.DrawingPosition.X, e.Y - TextView.DrawingPosition.Y);
if (SelectionManager.IsSelected(Document.PositionToOffset(realmousepos)) && MouseButtons == MouseButtons.None)
{
// mouse is hovering over a selection, so show default mouse
Cursor = Cursors.Default;
}
else
{
// mouse is hovering over text area, not a selection, so show the textView cursor
Cursor = TextView.Cursor;
}
return;
}
Cursor = Cursors.Default;
}
public ScaleService(IScaleState scaleState, IDataService dataService, IMargin margin)
{
if (scaleState == null)
{
throw new InvalidArgumentException("parameter is null");
}
this.scaleState = scaleState;
this.scaleState.Margin = margin;
this.dataService = dataService;
}
public Margin(IMargin margin)
{
if (margin == null)
{
throw new InvalidArgumentException("parameter is null");
}
this.Left = margin.Left;
this.Top = margin.Top;
this.Right = margin.Right;
this.Bottom = margin.Bottom;
}
public bool Equals(IMargin other)
{
if (other == null)
{
return(false);
}
return(this.Left.Equals(other.Left) &&
this.Top.Equals(other.Top) &&
this.Right.Equals(other.Right) &&
this.Bottom.Equals(other.Bottom));
}
private void DrawHorizontalLines(IDrawing drawing, IMargin margin, IGridState state, Structs.Size canvasSize, ref SizeF strY, ref double stepDataY)
{
if (this.scaleService.State.Y1 <= 0 && this.scaleService.State.Y2 > 0)
{
DrawHorizontalLines(state, drawing, canvasSize, margin, ref strY, ref stepDataY, true, false, false);
DrawHorizontalLines(state, drawing, canvasSize, margin, ref strY, ref stepDataY, true, true, false);
}
else if (this.scaleService.State.Y1 != this.scaleService.State.Y2)
{
DrawHorizontalLines(state, drawing, canvasSize, margin, ref strY, ref stepDataY, false, false, false);
}
}
public static void CreateBaseServices(IApplicationController applicationController, IDataProviderService provider,
out IGridState gridState, out IDataDrawState graphState,
out IItemFormatter itemFormatter, out IMargin margin,
out IDataService dataService, out IScaleService scaleService)
{
applicationController = applicationController ?? GraphControlFactory.CreateController();
IBufferedDrawingService bufferedDrawingService = null;
TestFactory.CreateBaseServices(applicationController, provider,
out gridState, out graphState,
out itemFormatter, out margin,
out dataService, out scaleService, ref bufferedDrawingService);
}
/// <summary>
/// Draws the view
/// </summary>
/// <param name="drawing">drawing wrapper</param>
/// <param name="options">drawing options</param>
/// <param name="margin">drawing margin</param>
public void Draw(IDrawing drawing, IDrawOptions options, IMargin margin)
{
if (options == null)
{
throw new InvalidArgumentException("parameter is null");
}
// Fix 1 - User can not move/zoom after pressing Fit by Y button
// Update Fit By states from curent drawing operation
this.state.FitByX = options.FitToX;
this.state.FitByY = options.FitToY;
this.view.Draw(drawing, new ScalingDrawOptions(options, this.state), margin);
}
private void DrawVerticalLines(IDrawing drawing, IMargin margin, IGridState state, Structs.Size canvasSize, SizeF strX, out double stepDataX)
{
// Draw axe X and grid from axe X to left and to right
stepDataX = 0;
if (this.scaleService.State.X1 <= 0 && this.scaleService.State.X2 > 0)
{
DrawVerticalLines(state, drawing, canvasSize, margin, strX, ref stepDataX, true, false);
DrawVerticalLines(state, drawing, canvasSize, margin, strX, ref stepDataX, true, true);
}
else if (this.scaleService.State.X1 != this.scaleService.State.X2)
{
DrawVerticalLines(state, drawing, canvasSize, margin, strX, ref stepDataX, false, false);
}
}
/// <summary>
/// Draws the view
/// </summary>
/// <param name="drawing">drawing wrapper</param>
/// <param name="options">drawing options</param>
/// <param name="margin">drawing margin</param>
public virtual void Draw(IDrawing drawing, IDrawOptions options, IMargin margin)
{
if (drawing == null || margin == null)
{
throw new InvalidArgumentException("parameter is null");
}
if (!(options is BackgroundDrawOptions))
{
throw new InvalidArgumentException("options is not compatible");
}
var state = ((BackgroundDrawOptions)options).State;
drawing.FillRectangle(state.PenColor, state.BackgroundColor, 0, 0, options.CanvasSize.Width - 1, options.CanvasSize.Height - 1);
}
private static void CreateServiceInstances(IApplicationController applicationController,
IMargin margin,
IScaleState scaleState,
out IDataService dataService,
out IScaleService scaleService,
out IBufferedDrawingService bufferedDrawingService)
{
dataService = new DataService();
applicationController.RegisterInstance <IDataService>(dataService);
scaleService = new ScaleService(scaleState, dataService, margin);
applicationController.RegisterInstance <IScaleService>(scaleService);
bufferedDrawingService = new BufferedDrawingService();
applicationController.RegisterInstance <IBufferedDrawingService>(bufferedDrawingService);
}
private void DrawAxis(IDrawing drawing, IMargin margin, IGridState state, Structs.Size canvasSize, SizeF strX, SizeF strY, double stepDataY, double stepDataX)
{
if (this.scaleService.State.X1 < 0 && this.scaleService.State.X2 > 0)
{
int lastTextPos = 0;
double valueData = 0;
double maxData = this.scaleService.State.X2;
double screenPos = this.scaleService.ToScreenX(valueData);
DrawVerticalLine(state, drawing, canvasSize, margin, strX, screenPos, valueData, maxData, stepDataX, StringAlignment.Center, ref lastTextPos);
}
if (this.scaleService.State.Y1 < 0 && this.scaleService.State.Y2 > 0)
{
double maxTextSize = 0;
int lastTextPos = 0;
DrawHorizontalLine(state, drawing, canvasSize, margin, ref strY, 0, stepDataY, false, ref maxTextSize, StringAlignment.Center, ref lastTextPos);
}
}
public void Assign(IMargin Source)
{
this.BeginUpdate();
try
{
this.Pen.Width = Source.Pen.Width;
this.Pen.Color = Source.Pen.Color;
this.Position = Source.Position;
this.Visible = Source.Visible;
this.AllowDrag = Source.AllowDrag;
this.ShowHints = Source.ShowHints;
}
finally
{
this.EndUpdate();
}
}
private void WriteTreeNodeChild(IMargin margin, StringBuilder builder, String indent, Boolean isLastChild)
{
builder.Append(indent);
if (isLastChild)
{
builder.Append(TREE_CORNER);
indent += TREE_SPACE;
}
else
{
builder.Append(TREE_CROSS);
indent += TREE_LINE;
}
WriteTreeNode(margin, builder, indent);
}
private void MeashureLabelSizes(IDrawing drawing, IMargin margin, IGridState state, Structs.Size canvasSize, out SizeF strX, out SizeF strY, out double stepDataY)
{
// For bottom offset get X string height for 0 value
var strValueX = state.ItemFormatter.ToString(Axis.X, new DataItem(0, 0), this.scaleService.ScaleToDataX(state.MinGridLineDistance));
strX = drawing.MeasureText(strValueX);
strY = new SizeF();
// For left offset find max Y string width
stepDataY = 0;
if (this.scaleService.State.Y1 <= 0 && this.scaleService.State.Y2 > 0)
{
DrawHorizontalLines(state, drawing, canvasSize, margin, ref strY, ref stepDataY, true, false, true);
DrawHorizontalLines(state, drawing, canvasSize, margin, ref strY, ref stepDataY, true, true, true);
}
else if (this.scaleService.State.Y1 != this.scaleService.State.Y2)
{
DrawHorizontalLines(state, drawing, canvasSize, margin, ref strY, ref stepDataY, false, false, true);
}
}
private void DrawAllData(IDataDrawState state, IDrawing drawing, IMargin margin, Size canvasSize, System.Drawing.RectangleF clip)
{
var startX = this.scaleService.State.X1;
var endX = this.scaleService.State.X2;
if (this.dataService.ItemCount == 1)
{
// Draw point for single data item
foreach (var item in this.dataService.GetItems(startX, endX))
{
if (item != null && this.scaleService.IsItemVisible(item))
{
var x = this.scaleService.ToScreen(Axis.X, item.X);
var y = this.scaleService.ToScreen(Axis.Y, item.Y);
drawing.Circle(state.LineColor, margin.Left + x, canvasSize.Height - margin.Bottom - y, 4, clip);
}
}
}
else
{
IDataItem prevItem = null;
// Draw lines
foreach (var item in this.dataService.GetItems(startX, endX))
{
if (item != null && prevItem != null &&
(this.scaleService.IsItemVisible(prevItem) ||
this.scaleService.IsItemVisible(item)))
{
var x1 = this.scaleService.ToScreen(Axis.X, prevItem.X);
var y1 = this.scaleService.ToScreen(Axis.Y, prevItem.Y);
var x2 = this.scaleService.ToScreen(Axis.X, item.X);
var y2 = this.scaleService.ToScreen(Axis.Y, item.Y);
drawing.Line(state.LineColor, margin.Left + x1, canvasSize.Height - margin.Bottom - y1, margin.Left + x2, canvasSize.Height - margin.Bottom - y2, clip);
}
prevItem = item;
}
}
}
private void WriteCsvRecursive(IMargin margin, List <String[]> fieldsMatrix)
{
Int32 level = margin.Level;
String[] fieldsRow;
if (fieldsMatrix.Count == 0)
{
fieldsRow = new String[s_CsvHeaderFields.Length];
fieldsRow[0] = level.ToString(m_FormatProvider);
fieldsRow[1] = margin.Identifier;
for (Int32 i = 2; i < s_CsvHeaderFields.Length - 1; ++i)
{
fieldsRow[i] = String.Empty;
}
}
else
{
fieldsRow = (String[])fieldsMatrix.Last().Clone();
fieldsRow[0] = level.ToString(m_FormatProvider);
fieldsRow[level - 1] = margin.Identifier;
for (Int32 i = level; i < s_CsvHeaderFields.Length - 1; ++i)
{
fieldsRow[i] = String.Empty;
}
}
fieldsRow[s_CsvHeaderFields.Length - 1] = Amount.Round(margin.Value, 2).ToString(m_FormatProvider, CurrencyCodeSymbol.None);
fieldsMatrix.Add(fieldsRow);
foreach (IMargin child in margin.Children)
{
WriteCsvRecursive(child, fieldsMatrix);
}
}
/// <summary>
/// Draws the view
/// </summary>
/// <param name="drawing">drawing wrapper</param>
/// <param name="options">drawing options</param>
/// <param name="margin">drawing margin</param>
public void Draw(IDrawing drawing, IDrawOptions options, IMargin margin)
{
this.view.Draw(drawing, new DataDrawOptions(options, this.state), margin);
}
public Margins(IMargin left, IMargin right)
{
Left = left;
Right = right;
}
public void SetMargin(IMargin margin)
{
this.Margin = new Thickness(margin.Left, margin.Top, margin.Right, margin.Bottom);
}
public void UpdateMargin(IMargin margin)
{
this.scaleState.Margin = margin;
}
public void InsertLeftMargin(int index, IMargin margin)
{
_leftMargins.Insert(index, margin);
Refresh();
}
public void SetMargin(IMargin margin)
{
this.Margin = new Thickness(margin.Left, margin.Top, margin.Right, margin.Bottom);
}
