|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.ComponentModel;
|
|
|
using System.Drawing;
|
|
|
using System.Drawing.Drawing2D;
|
|
|
using System.Drawing.Text;
|
|
|
using System.Windows.Forms;
|
|
|
|
|
|
namespace Mesnac.Controls.ChemicalWeighing.HslCurve
|
|
|
{
|
|
|
/// <summary>
|
|
|
/// 曲线控件信息，可以用于显示一些实时的曲线信息，同时支持对曲线控件的一些简单的交互
|
|
|
/// </summary>
|
|
|
// Token: 0x02000014 RID: 20
|
|
|
[Description("实时曲线控件，主要用来显示实时的曲线信息，不支持光标移动显示数据信息，支持简单的交互，显示隐藏曲线")]
|
|
|
public class HslCurve : UserControl
|
|
|
{
|
|
|
/// <summary>
|
|
|
/// 实例化一个曲线显示的控件
|
|
|
/// </summary>
|
|
|
// Token: 0x060001FE RID: 510 RVA: 0x0001E290 File Offset: 0x0001C490
|
|
|
public HslCurve()
|
|
|
{
|
|
|
this.InitializeComponent();
|
|
|
this.random = new Random();
|
|
|
this.data_list = new Dictionary<string, HslCurveItem>();
|
|
|
this.auxiliary_lines = new List<AuxiliaryLine>();
|
|
|
this.hslMarkTexts = new List<HslMarkText>();
|
|
|
this.auxiliary_Labels = new List<AuxiliaryLable>();
|
|
|
this.format_left = new StringFormat
|
|
|
{
|
|
|
LineAlignment = StringAlignment.Center,
|
|
|
Alignment = StringAlignment.Near
|
|
|
};
|
|
|
this.format_right = new StringFormat
|
|
|
{
|
|
|
LineAlignment = StringAlignment.Center,
|
|
|
Alignment = StringAlignment.Far
|
|
|
};
|
|
|
this.format_center = new StringFormat
|
|
|
{
|
|
|
LineAlignment = StringAlignment.Center,
|
|
|
Alignment = StringAlignment.Center
|
|
|
};
|
|
|
this.font_size9 = new Font("微软雅黑", 9f);
|
|
|
this.InitializationColor();
|
|
|
this.pen_dash = new Pen(this.color_deep);
|
|
|
this.pen_dash.DashStyle = DashStyle.Custom;
|
|
|
this.pen_dash.DashPattern = new float[]
|
|
|
{
|
|
|
5f,
|
|
|
5f
|
|
|
};
|
|
|
this.referenceAxisLeft = new ReferenceAxis(this);
|
|
|
this.referenceAxisRight = new ReferenceAxis(this);
|
|
|
this.referenceAxisLeft.Color = Color.DimGray;
|
|
|
this.referenceAxisRight.Color = Color.DimGray;
|
|
|
base.SetStyle(ControlStyles.UserPaint | ControlStyles.SupportsTransparentBackColor, true);
|
|
|
base.SetStyle(ControlStyles.ResizeRedraw, true);
|
|
|
base.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
|
|
|
base.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置控件的背景色
|
|
|
/// </summary>
|
|
|
// Token: 0x170000AA RID: 170
|
|
|
// (get) Token: 0x060001FF RID: 511 RVA: 0x0001E4E3 File Offset: 0x0001C6E3
|
|
|
// (set) Token: 0x06000200 RID: 512 RVA: 0x0001E4EB File Offset: 0x0001C6EB
|
|
|
[Browsable(true)]
|
|
|
[Description("获取或设置控件的背景色")]
|
|
|
[Category("HslControls")]
|
|
|
[DefaultValue(typeof(Color), "Transparent")]
|
|
|
[EditorBrowsable(EditorBrowsableState.Always)]
|
|
|
public override Color BackColor
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return base.BackColor;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
base.BackColor = value;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置图形的左轴的坐标轴信息
|
|
|
/// </summary>
|
|
|
// Token: 0x170000AB RID: 171
|
|
|
// (get) Token: 0x06000201 RID: 513 RVA: 0x0001E4F5 File Offset: 0x0001C6F5
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置图形的左轴的坐标轴信息")]
|
|
|
[Browsable(true)]
|
|
|
[TypeConverter(typeof(ReferenceAxisConverter))]
|
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
|
public ReferenceAxis ReferenceAxisLeft
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.referenceAxisLeft;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置图形的右轴的坐标轴信息
|
|
|
/// </summary>
|
|
|
// Token: 0x170000AC RID: 172
|
|
|
// (get) Token: 0x06000202 RID: 514 RVA: 0x0001E4FD File Offset: 0x0001C6FD
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置图形的右轴的坐标轴信息")]
|
|
|
[Browsable(true)]
|
|
|
[TypeConverter(typeof(ReferenceAxisConverter))]
|
|
|
[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
|
|
|
public ReferenceAxis ReferenceAxisRight
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.referenceAxisRight;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置图形的纵轴分段数
|
|
|
/// </summary>
|
|
|
// Token: 0x170000AD RID: 173
|
|
|
// (get) Token: 0x06000203 RID: 515 RVA: 0x0001E508 File Offset: 0x0001C708
|
|
|
// (set) Token: 0x06000204 RID: 516 RVA: 0x0001E520 File Offset: 0x0001C720
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置图形的纵轴分段数")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue(5)]
|
|
|
public virtual int ValueSegment
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.value_Segment;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.value_Segment = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置所有的数据是否强制在一个界面里显示
|
|
|
/// </summary>
|
|
|
// Token: 0x170000AE RID: 174
|
|
|
// (get) Token: 0x06000205 RID: 517 RVA: 0x0001E534 File Offset: 0x0001C734
|
|
|
// (set) Token: 0x06000206 RID: 518 RVA: 0x0001E54C File Offset: 0x0001C74C
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置所有的数据是否强制在一个界面里显示")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue(false)]
|
|
|
public virtual bool IsAbscissaStrech
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.value_IsAbscissaStrech;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.value_IsAbscissaStrech = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置拉伸模式下的最大数据量
|
|
|
/// </summary>
|
|
|
// Token: 0x170000AF RID: 175
|
|
|
// (get) Token: 0x06000207 RID: 519 RVA: 0x0001E560 File Offset: 0x0001C760
|
|
|
// (set) Token: 0x06000208 RID: 520 RVA: 0x0001E578 File Offset: 0x0001C778
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置拉伸模式下的最大数据量")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue(300)]
|
|
|
public virtual int StrechDataCountMax
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.value_StrechDataCountMax;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.value_StrechDataCountMax = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置虚线是否进行显示
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B0 RID: 176
|
|
|
// (get) Token: 0x06000209 RID: 521 RVA: 0x0001E58C File Offset: 0x0001C78C
|
|
|
// (set) Token: 0x0600020A RID: 522 RVA: 0x0001E5A4 File Offset: 0x0001C7A4
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置虚线是否进行显示")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue(true)]
|
|
|
public virtual bool IsRenderDashLine
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.value_IsRenderDashLine;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.value_IsRenderDashLine = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置坐标轴及相关信息文本的颜色
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B1 RID: 177
|
|
|
// (get) Token: 0x0600020B RID: 523 RVA: 0x0001E5B8 File Offset: 0x0001C7B8
|
|
|
// (set) Token: 0x0600020C RID: 524 RVA: 0x0001E5D0 File Offset: 0x0001C7D0
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置坐标轴及相关信息文本的颜色")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue(typeof(Color), "DimGray")]
|
|
|
public virtual Color ColorLinesAndText
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.color_deep;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.color_deep = value;
|
|
|
this.InitializationColor();
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置虚线的颜色
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B2 RID: 178
|
|
|
// (get) Token: 0x0600020D RID: 525 RVA: 0x0001E5E8 File Offset: 0x0001C7E8
|
|
|
// (set) Token: 0x0600020E RID: 526 RVA: 0x0001E600 File Offset: 0x0001C800
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置虚线的颜色")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue(typeof(Color), "Gray")]
|
|
|
public virtual Color ColorDashLines
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.color_dash;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.color_dash = value;
|
|
|
Pen pen = this.pen_dash;
|
|
|
if (pen != null)
|
|
|
{
|
|
|
pen.Dispose();
|
|
|
}
|
|
|
this.pen_dash = new Pen(this.color_dash);
|
|
|
this.pen_dash.DashStyle = DashStyle.Custom;
|
|
|
this.pen_dash.DashPattern = new float[]
|
|
|
{
|
|
|
5f,
|
|
|
5f
|
|
|
};
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置纵向虚线的分隔情况，单位为多少个数据
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B3 RID: 179
|
|
|
// (get) Token: 0x0600020F RID: 527 RVA: 0x0001E670 File Offset: 0x0001C870
|
|
|
// (set) Token: 0x06000210 RID: 528 RVA: 0x0001E688 File Offset: 0x0001C888
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置纵向虚线的分隔情况，单位为多少个数据")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue(100)]
|
|
|
public virtual int IntervalAbscissaText
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.value_IntervalAbscissaText;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.value_IntervalAbscissaText = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置实时数据新增时文本相对应于时间的格式化字符串，默认HH:mm
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B4 RID: 180
|
|
|
// (get) Token: 0x06000211 RID: 529 RVA: 0x0001E69C File Offset: 0x0001C89C
|
|
|
// (set) Token: 0x06000212 RID: 530 RVA: 0x0001E6B4 File Offset: 0x0001C8B4
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置实时数据新增时文本相对应于时间的格式化字符串，默认HH:mm")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue("HH:mm")]
|
|
|
public virtual string TextAddFormat
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.textFormat;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.textFormat = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置图标的标题信息
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B5 RID: 181
|
|
|
// (get) Token: 0x06000213 RID: 531 RVA: 0x0001E6C8 File Offset: 0x0001C8C8
|
|
|
// (set) Token: 0x06000214 RID: 532 RVA: 0x0001E6E0 File Offset: 0x0001C8E0
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置图标的标题信息")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue("")]
|
|
|
public virtual string Title
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.value_title;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.value_title = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置是否显示右侧的坐标系信息
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B6 RID: 182
|
|
|
// (get) Token: 0x06000215 RID: 533 RVA: 0x0001E6F4 File Offset: 0x0001C8F4
|
|
|
// (set) Token: 0x06000216 RID: 534 RVA: 0x0001E70C File Offset: 0x0001C90C
|
|
|
[Category("HslControls")]
|
|
|
[Description("获取或设置是否显示右侧的坐标系信息")]
|
|
|
[Browsable(true)]
|
|
|
[DefaultValue(true)]
|
|
|
public virtual bool IsRenderRightCoordinate
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.isRenderRightCoordinate;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.isRenderRightCoordinate = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Token: 0x06000217 RID: 535 RVA: 0x0001E720 File Offset: 0x0001C920
|
|
|
private void InitializationColor()
|
|
|
{
|
|
|
Pen pen = this.pen_normal;
|
|
|
if (pen != null)
|
|
|
{
|
|
|
pen.Dispose();
|
|
|
}
|
|
|
Brush brush = this.brush_deep;
|
|
|
if (brush != null)
|
|
|
{
|
|
|
brush.Dispose();
|
|
|
}
|
|
|
this.pen_normal = new Pen(this.color_deep);
|
|
|
this.brush_deep = new SolidBrush(this.color_deep);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置曲线名称的布局宽度，默认为100
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B7 RID: 183
|
|
|
// (get) Token: 0x06000218 RID: 536 RVA: 0x0001E774 File Offset: 0x0001C974
|
|
|
// (set) Token: 0x06000219 RID: 537 RVA: 0x0001E77C File Offset: 0x0001C97C
|
|
|
[Browsable(true)]
|
|
|
[Description("获取或设置曲线名称的布局宽度，默认为150")]
|
|
|
[Category("HslControls")]
|
|
|
[DefaultValue(100)]
|
|
|
public virtual int CurveNameWidth
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.curveNameWidth;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
bool flag = value > 10;
|
|
|
if (flag)
|
|
|
{
|
|
|
this.curveNameWidth = value;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置所有的数据点显示的半径大小，默认是0，不显示数据点
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B8 RID: 184
|
|
|
// (get) Token: 0x0600021A RID: 538 RVA: 0x0001E79C File Offset: 0x0001C99C
|
|
|
// (set) Token: 0x0600021B RID: 539 RVA: 0x0001E7A4 File Offset: 0x0001C9A4
|
|
|
[Browsable(true)]
|
|
|
[Description("获取或设置所有的数据点显示的半径大小，默认是0，不显示数据点")]
|
|
|
[Category("HslControls")]
|
|
|
[DefaultValue(0)]
|
|
|
public virtual int PointsRadius
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.pointsRadius;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.pointsRadius = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置Y轴刻度文本的字体信息
|
|
|
/// </summary>
|
|
|
// Token: 0x170000B9 RID: 185
|
|
|
// (get) Token: 0x0600021D RID: 541 RVA: 0x0001E7C8 File Offset: 0x0001C9C8
|
|
|
// (set) Token: 0x0600021C RID: 540 RVA: 0x0001E7B5 File Offset: 0x0001C9B5
|
|
|
[Browsable(true)]
|
|
|
[Description("获取或设置Y轴刻度文本的字体信息")]
|
|
|
[Category("HslControls")]
|
|
|
public virtual Font FontCalibration
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.font_size9;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.font_size9 = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置左右两侧的坐标轴的宽度，以像素为单位
|
|
|
/// </summary>
|
|
|
// Token: 0x170000BA RID: 186
|
|
|
// (get) Token: 0x0600021E RID: 542 RVA: 0x0001E7E0 File Offset: 0x0001C9E0
|
|
|
// (set) Token: 0x0600021F RID: 543 RVA: 0x0001E7F8 File Offset: 0x0001C9F8
|
|
|
[Browsable(true)]
|
|
|
[Description("获取或设置左右两侧的坐标轴的宽度，以像素为单位")]
|
|
|
[Category("HslControls")]
|
|
|
[DefaultValue(50)]
|
|
|
public int LeftRightWidth
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.leftRight;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.leftRight = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取或设置上下两侧的空白的宽度，以像素为单位
|
|
|
/// </summary>
|
|
|
// Token: 0x170000BB RID: 187
|
|
|
// (get) Token: 0x06000220 RID: 544 RVA: 0x0001E80C File Offset: 0x0001CA0C
|
|
|
// (set) Token: 0x06000221 RID: 545 RVA: 0x0001E824 File Offset: 0x0001CA24
|
|
|
[Browsable(true)]
|
|
|
[Description("获取或设置上下两侧的空白的宽度，以像素为单位")]
|
|
|
[Category("HslControls")]
|
|
|
[DefaultValue(25)]
|
|
|
public int UpDownHeight
|
|
|
{
|
|
|
get
|
|
|
{
|
|
|
return this.upDown;
|
|
|
}
|
|
|
set
|
|
|
{
|
|
|
this.upDown = value;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 设置曲线的横坐标文本，适用于显示一些固定的曲线信息
|
|
|
/// </summary>
|
|
|
/// <param name="descriptions">应该和曲线的点数一致</param>
|
|
|
// Token: 0x06000222 RID: 546 RVA: 0x0001E835 File Offset: 0x0001CA35
|
|
|
public void SetCurveText(string[] descriptions)
|
|
|
{
|
|
|
this.data_text = descriptions;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增或修改一条指定关键字的左参考系曲线数据，需要指定数据，颜色随机，没有数据上限，线条宽度为1
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线关键字</param>
|
|
|
/// <param name="data">曲线的具体数据</param>
|
|
|
// Token: 0x06000223 RID: 547 RVA: 0x0001E848 File Offset: 0x0001CA48
|
|
|
public void SetLeftCurve(string key, float[] data)
|
|
|
{
|
|
|
this.SetLeftCurve(key, data, Color.FromArgb(this.random.Next(256), this.random.Next(256), this.random.Next(256)));
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增或修改一条指定关键字的左参考系曲线数据，需要指定数据，颜色，没有数据上限，线条宽度为1
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线关键字</param>
|
|
|
/// <param name="data">数据内容</param>
|
|
|
/// <param name="lineColor">曲线颜色</param>
|
|
|
// Token: 0x06000224 RID: 548 RVA: 0x0001E894 File Offset: 0x0001CA94
|
|
|
public void SetLeftCurve(string key, float[] data, Color lineColor)
|
|
|
{
|
|
|
this.SetCurve(key, 0, data, lineColor, 1f, CurveStyle.LineSegment);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增或修改一条指定关键字的左参考系曲线数据，需要指定数据，颜色，没有数据上限，线条宽度为1
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线关键字</param>
|
|
|
/// <param name="data">数据内容</param>
|
|
|
/// <param name="lineColor">曲线颜色</param>
|
|
|
/// <param name="style">曲线的样式</param>
|
|
|
// Token: 0x06000225 RID: 549 RVA: 0x0001E8A8 File Offset: 0x0001CAA8
|
|
|
public void SetLeftCurve(string key, float[] data, Color lineColor, CurveStyle style)
|
|
|
{
|
|
|
this.SetCurve(key, 0, data, lineColor, 1f, style);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增或修改一条指定关键字的右参考系曲线数据，需要指定数据，颜色随机，没有数据上限，线条宽度为1
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线关键字</param>
|
|
|
/// <param name="data">数据内容</param>
|
|
|
// Token: 0x06000226 RID: 550 RVA: 0x0001E8C0 File Offset: 0x0001CAC0
|
|
|
public void SetRightCurve(string key, float[] data)
|
|
|
{
|
|
|
this.SetRightCurve(key, data, Color.FromArgb(this.random.Next(256), this.random.Next(256), this.random.Next(256)));
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增或修改一条指定关键字的右参考系曲线数据，需要指定数据，颜色，没有数据上限，线条宽度为1
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线关键字</param>
|
|
|
/// <param name="data">数据内容</param>
|
|
|
/// <param name="lineColor">曲线颜色</param>
|
|
|
// Token: 0x06000227 RID: 551 RVA: 0x0001E90C File Offset: 0x0001CB0C
|
|
|
public void SetRightCurve(string key, float[] data, Color lineColor)
|
|
|
{
|
|
|
this.SetCurve(key, 1, data, lineColor, 1f, CurveStyle.LineSegment);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增或修改一条指定关键字的右参考系曲线数据，需要指定数据，颜色，没有数据上限，线条宽度为1
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线关键字</param>
|
|
|
/// <param name="data">数据内容</param>
|
|
|
/// <param name="lineColor">曲线颜色</param>
|
|
|
/// <param name="style">曲线的样式</param>
|
|
|
// Token: 0x06000228 RID: 552 RVA: 0x0001E920 File Offset: 0x0001CB20
|
|
|
public void SetRightCurve(string key, float[] data, Color lineColor, CurveStyle style)
|
|
|
{
|
|
|
this.SetCurve(key, 1, data, lineColor, 1f, style);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增或修改一条指定关键字的曲线数据，需要指定参考系及数据，颜色，线条宽度
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线关键字</param>
|
|
|
/// <param name="referenceAxis">是否以左侧坐标轴为参照系</param>
|
|
|
/// <param name="data">数据</param>
|
|
|
/// <param name="lineColor">线条颜色</param>
|
|
|
/// <param name="thickness">线条宽度</param>
|
|
|
/// <param name="style">曲线的样式</param>
|
|
|
// Token: 0x06000229 RID: 553 RVA: 0x0001E938 File Offset: 0x0001CB38
|
|
|
public void SetCurve(string key, int referenceAxis, float[] data, Color lineColor, float thickness, CurveStyle style)
|
|
|
{
|
|
|
bool flag = this.data_list.ContainsKey(key);
|
|
|
if (flag)
|
|
|
{
|
|
|
bool flag2 = data == null;
|
|
|
if (flag2)
|
|
|
{
|
|
|
data = new float[0];
|
|
|
}
|
|
|
this.data_list[key].Data = data;
|
|
|
bool flag3 = this.data_text != null && this.data_text.Length != data.Length;
|
|
|
if (flag3)
|
|
|
{
|
|
|
this.data_text = new string[data.Length];
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
bool flag4 = data == null;
|
|
|
if (flag4)
|
|
|
{
|
|
|
data = new float[0];
|
|
|
}
|
|
|
this.data_list.Add(key, new HslCurveItem
|
|
|
{
|
|
|
Data = data,
|
|
|
MarkText = new string[data.Length],
|
|
|
LineThickness = thickness,
|
|
|
LineColor = lineColor,
|
|
|
ReferenceAxisIndex = referenceAxis,
|
|
|
Style = style
|
|
|
});
|
|
|
bool flag5 = this.data_text == null || this.data_text.Length != data.Length;
|
|
|
if (flag5)
|
|
|
{
|
|
|
this.data_text = new string[data.Length];
|
|
|
}
|
|
|
}
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除指定关键字的曲线
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线关键字</param>
|
|
|
// Token: 0x0600022A RID: 554 RVA: 0x0001EA48 File Offset: 0x0001CC48
|
|
|
public void RemoveCurve(string key)
|
|
|
{
|
|
|
bool flag = this.data_list.ContainsKey(key);
|
|
|
if (flag)
|
|
|
{
|
|
|
this.data_list.Remove(key);
|
|
|
}
|
|
|
bool flag2 = this.data_list.Count == 0;
|
|
|
if (flag2)
|
|
|
{
|
|
|
this.data_text = new string[0];
|
|
|
}
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除所有的曲线
|
|
|
/// </summary>
|
|
|
// Token: 0x0600022B RID: 555 RVA: 0x0001EA9C File Offset: 0x0001CC9C
|
|
|
public void RemoveAllCurve()
|
|
|
{
|
|
|
int count = this.data_list.Count;
|
|
|
this.data_list.Clear();
|
|
|
bool flag = this.data_list.Count == 0;
|
|
|
if (flag)
|
|
|
{
|
|
|
this.data_text = new string[0];
|
|
|
}
|
|
|
bool flag2 = count > 0;
|
|
|
if (flag2)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除所有曲线的数据
|
|
|
/// </summary>
|
|
|
// Token: 0x0600022C RID: 556 RVA: 0x0001EAF4 File Offset: 0x0001CCF4
|
|
|
public void RemoveAllCurveData()
|
|
|
{
|
|
|
int count = this.data_list.Count;
|
|
|
foreach (KeyValuePair<string, HslCurveItem> keyValuePair in this.data_list)
|
|
|
{
|
|
|
keyValuePair.Value.Data = new float[0];
|
|
|
keyValuePair.Value.MarkText = new string[0];
|
|
|
}
|
|
|
this.data_text = new string[0];
|
|
|
bool flag = count > 0;
|
|
|
if (flag)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取曲线图中已经存在的曲线对象，用于动态修改一些复杂的数据信息，如线宽，标记点，修改以前的数据内容等等
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <returns>曲线对象信息</returns>
|
|
|
// Token: 0x0600022D RID: 557 RVA: 0x0001EB90 File Offset: 0x0001CD90
|
|
|
public HslCurveItem GetCurveItem(string key)
|
|
|
{
|
|
|
bool flag = this.data_list.ContainsKey(key);
|
|
|
HslCurveItem result;
|
|
|
if (flag)
|
|
|
{
|
|
|
result = this.data_list[key];
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
result = null;
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将当前的图形曲线保存为图片内容，可用于存储本地的文件，或是打印到纸张，默认大小为控件的大小
|
|
|
/// </summary>
|
|
|
/// <returns>图片内容</returns>
|
|
|
// Token: 0x0600022E RID: 558 RVA: 0x0001EBC4 File Offset: 0x0001CDC4
|
|
|
public Bitmap SaveToBitmap()
|
|
|
{
|
|
|
return this.SaveToBitmap(base.Width, base.Height);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将当前的图形曲线保存为图片内容，可用于存储本地的文件，或是打印到纸张，使用指定的大小，显示的曲线可能和控件上的不一致
|
|
|
/// </summary>
|
|
|
/// <returns>图片内容</returns>
|
|
|
// Token: 0x0600022F RID: 559 RVA: 0x0001EBE8 File Offset: 0x0001CDE8
|
|
|
public Bitmap SaveToBitmap(int width, int height)
|
|
|
{
|
|
|
Bitmap bitmap = new Bitmap(width, height);
|
|
|
Graphics graphics = Graphics.FromImage(bitmap);
|
|
|
this.OnPaint(new PaintEventArgs(graphics, new Rectangle(0, 0, width, height)));
|
|
|
return bitmap;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增指定关键字曲线的一个数据，注意该关键字的曲线必须存在，否则无效
|
|
|
/// </summary>
|
|
|
/// <param name="key">新增曲线的关键字</param>
|
|
|
/// <param name="values">数据值</param>
|
|
|
/// <param name="markTexts">标记的文本信息</param>
|
|
|
/// <param name="isUpdateUI">是否刷新界面</param>
|
|
|
// Token: 0x06000230 RID: 560 RVA: 0x0001EC20 File Offset: 0x0001CE20
|
|
|
private void AddCurveData(string key, float[] values, string[] markTexts, bool isUpdateUI)
|
|
|
{
|
|
|
bool flag = values != null && values.Length < 1;
|
|
|
if (!flag)
|
|
|
{
|
|
|
bool flag2 = this.data_list.ContainsKey(key);
|
|
|
if (flag2)
|
|
|
{
|
|
|
HslCurveItem hslCurveItem = this.data_list[key];
|
|
|
bool flag3 = hslCurveItem.Data != null;
|
|
|
if (flag3)
|
|
|
{
|
|
|
bool flag4 = this.value_IsAbscissaStrech;
|
|
|
if (flag4)
|
|
|
{
|
|
|
HslHelper.AddArrayData<float>(ref hslCurveItem.Data, values, this.value_StrechDataCountMax);
|
|
|
HslHelper.AddArrayData<string>(ref hslCurveItem.MarkText, markTexts, this.value_StrechDataCountMax);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
HslHelper.AddArrayData<float>(ref hslCurveItem.Data, values, 4096);
|
|
|
HslHelper.AddArrayData<string>(ref hslCurveItem.MarkText, markTexts, 4096);
|
|
|
}
|
|
|
if (isUpdateUI)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Token: 0x06000231 RID: 561 RVA: 0x0001ECE0 File Offset: 0x0001CEE0
|
|
|
private void AddCurveTime(int count)
|
|
|
{
|
|
|
this.AddCurveTime(count, DateTime.Now.ToString(this.textFormat));
|
|
|
}
|
|
|
|
|
|
// Token: 0x06000232 RID: 562 RVA: 0x0001ED0C File Offset: 0x0001CF0C
|
|
|
private void AddCurveTime(int count, string text)
|
|
|
{
|
|
|
bool flag = this.data_text == null;
|
|
|
if (!flag)
|
|
|
{
|
|
|
string[] array = new string[count];
|
|
|
for (int i = 0; i < array.Length; i++)
|
|
|
{
|
|
|
array[i] = text;
|
|
|
}
|
|
|
bool flag2 = this.value_IsAbscissaStrech;
|
|
|
if (flag2)
|
|
|
{
|
|
|
HslHelper.AddArrayData<string>(ref this.data_text, array, this.value_StrechDataCountMax);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
HslHelper.AddArrayData<string>(ref this.data_text, array, 4096);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增指定关键字曲线的一个数据，注意该关键字的曲线必须存在，否则无效
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线的关键字</param>
|
|
|
/// <param name="value">数据值</param>
|
|
|
// Token: 0x06000233 RID: 563 RVA: 0x0001ED7F File Offset: 0x0001CF7F
|
|
|
public void AddCurveData(string key, float value)
|
|
|
{
|
|
|
this.AddCurveData(key, new float[]
|
|
|
{
|
|
|
value
|
|
|
});
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增指定关键字曲线的一个数据，注意该关键字的曲线必须存在，否则无效
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线的关键字</param>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <param name="markText">标记的本文信息</param>
|
|
|
// Token: 0x06000234 RID: 564 RVA: 0x0001ED94 File Offset: 0x0001CF94
|
|
|
public void AddCurveData(string key, float value, string markText)
|
|
|
{
|
|
|
this.AddCurveData(key, new float[]
|
|
|
{
|
|
|
value
|
|
|
}, new string[]
|
|
|
{
|
|
|
markText
|
|
|
});
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增指定关键字曲线的一组数据，注意该关键字的曲线必须存在，否则无效
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线的关键字</param>
|
|
|
/// <param name="values">数组值</param>
|
|
|
// Token: 0x06000235 RID: 565 RVA: 0x0001EDB3 File Offset: 0x0001CFB3
|
|
|
public void AddCurveData(string key, float[] values)
|
|
|
{
|
|
|
this.AddCurveData(key, values, null);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增指定关键字曲线的一组数据，注意该关键字的曲线必须存在，否则无效
|
|
|
/// </summary>
|
|
|
/// <param name="key">曲线的关键字</param>
|
|
|
/// <param name="values">数组值</param>
|
|
|
/// <param name="markTexts">标记的本文信息</param>
|
|
|
// Token: 0x06000236 RID: 566 RVA: 0x0001EDC0 File Offset: 0x0001CFC0
|
|
|
public void AddCurveData(string key, float[] values, string[] markTexts)
|
|
|
{
|
|
|
bool flag = markTexts == null;
|
|
|
if (flag)
|
|
|
{
|
|
|
markTexts = new string[values.Length];
|
|
|
}
|
|
|
this.AddCurveData(key, values, markTexts, false);
|
|
|
bool flag2 = values != null && values.Length != 0;
|
|
|
if (flag2)
|
|
|
{
|
|
|
this.AddCurveTime(values.Length);
|
|
|
}
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增指定关键字数组曲线的一组数据，注意该关键字的曲线必须存在，否则无效，一个数据对应一个数组
|
|
|
/// </summary>
|
|
|
/// <param name="keys">曲线的关键字数组</param>
|
|
|
/// <param name="values">数组值</param>
|
|
|
// Token: 0x06000237 RID: 567 RVA: 0x0001EE0D File Offset: 0x0001D00D
|
|
|
public void AddCurveData(string[] keys, float[] values)
|
|
|
{
|
|
|
this.AddCurveData(keys, values, null);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增指定关键字数组曲线的一组数据，注意该关键字的曲线必须存在，否则无效，一个数据对应一个数组
|
|
|
/// </summary>
|
|
|
/// <param name="axisText">自定义的横轴坐标数据</param>
|
|
|
/// <param name="keys">曲线的关键字数组</param>
|
|
|
/// <param name="values">数组值</param>
|
|
|
// Token: 0x06000238 RID: 568 RVA: 0x0001EE1A File Offset: 0x0001D01A
|
|
|
public void AddCurveData(string axisText, string[] keys, float[] values)
|
|
|
{
|
|
|
this.AddCurveData(axisText, keys, values, null);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增指定关键字数组曲线的一组数据，注意该关键字的曲线必须存在，否则无效，一个数据对应一个数组
|
|
|
/// </summary>
|
|
|
/// <param name="keys">曲线的关键字数组</param>
|
|
|
/// <param name="values">数组值</param>
|
|
|
/// <param name="markTexts">标记的文本信息</param>
|
|
|
// Token: 0x06000239 RID: 569 RVA: 0x0001EE28 File Offset: 0x0001D028
|
|
|
public void AddCurveData(string[] keys, float[] values, string[] markTexts)
|
|
|
{
|
|
|
bool flag = keys == null;
|
|
|
if (flag)
|
|
|
{
|
|
|
throw new ArgumentNullException("keys");
|
|
|
}
|
|
|
bool flag2 = values == null;
|
|
|
if (flag2)
|
|
|
{
|
|
|
throw new ArgumentNullException("values");
|
|
|
}
|
|
|
bool flag3 = markTexts == null;
|
|
|
if (flag3)
|
|
|
{
|
|
|
markTexts = new string[keys.Length];
|
|
|
}
|
|
|
bool flag4 = keys.Length != values.Length;
|
|
|
if (flag4)
|
|
|
{
|
|
|
throw new Exception("两个参数的数组长度不一致。");
|
|
|
}
|
|
|
bool flag5 = keys.Length != markTexts.Length;
|
|
|
if (flag5)
|
|
|
{
|
|
|
throw new Exception("两个参数的数组长度不一致。");
|
|
|
}
|
|
|
for (int i = 0; i < keys.Length; i++)
|
|
|
{
|
|
|
this.AddCurveData(keys[i], new float[]
|
|
|
{
|
|
|
values[i]
|
|
|
}, new string[]
|
|
|
{
|
|
|
markTexts[i]
|
|
|
}, false);
|
|
|
}
|
|
|
this.AddCurveTime(1);
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增指定关键字数组曲线的一组数据，注意该关键字的曲线必须存在，否则无效，一个数据对应一个数组
|
|
|
/// </summary>
|
|
|
/// <param name="axisText">自定义的横轴坐标数据</param>
|
|
|
/// <param name="keys">曲线的关键字数组</param>
|
|
|
/// <param name="values">数组值</param>
|
|
|
/// <param name="markTexts">标记的文本信息</param>
|
|
|
// Token: 0x0600023A RID: 570 RVA: 0x0001EEF4 File Offset: 0x0001D0F4
|
|
|
public void AddCurveData(string axisText, string[] keys, float[] values, string[] markTexts)
|
|
|
{
|
|
|
bool flag = keys == null;
|
|
|
if (flag)
|
|
|
{
|
|
|
throw new ArgumentNullException("keys");
|
|
|
}
|
|
|
bool flag2 = values == null;
|
|
|
if (flag2)
|
|
|
{
|
|
|
throw new ArgumentNullException("values");
|
|
|
}
|
|
|
bool flag3 = markTexts == null;
|
|
|
if (flag3)
|
|
|
{
|
|
|
markTexts = new string[keys.Length];
|
|
|
}
|
|
|
bool flag4 = keys.Length != values.Length;
|
|
|
if (flag4)
|
|
|
{
|
|
|
throw new Exception("两个参数的数组长度不一致。");
|
|
|
}
|
|
|
bool flag5 = keys.Length != markTexts.Length;
|
|
|
if (flag5)
|
|
|
{
|
|
|
throw new Exception("两个参数的数组长度不一致。");
|
|
|
}
|
|
|
for (int i = 0; i < keys.Length; i++)
|
|
|
{
|
|
|
this.AddCurveData(keys[i], new float[]
|
|
|
{
|
|
|
values[i]
|
|
|
}, new string[]
|
|
|
{
|
|
|
markTexts[i]
|
|
|
}, false);
|
|
|
}
|
|
|
this.AddCurveTime(1, axisText);
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 设置一条曲线是否是可见的，如果该曲线不存在，则无效。
|
|
|
/// </summary>
|
|
|
/// <param name="key">关键字</param>
|
|
|
/// <param name="visible">是否可见</param>
|
|
|
// Token: 0x0600023B RID: 571 RVA: 0x0001EFC4 File Offset: 0x0001D1C4
|
|
|
public void SetCurveVisible(string key, bool visible)
|
|
|
{
|
|
|
bool flag = this.data_list.ContainsKey(key);
|
|
|
if (flag)
|
|
|
{
|
|
|
HslCurveItem hslCurveItem = this.data_list[key];
|
|
|
hslCurveItem.Visible = visible;
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 设置多条曲线是否是可见的，如果该曲线不存在，则无效。
|
|
|
/// </summary>
|
|
|
/// <param name="keys">关键字</param>
|
|
|
/// <param name="visible">是否可见</param>
|
|
|
// Token: 0x0600023C RID: 572 RVA: 0x0001F000 File Offset: 0x0001D200
|
|
|
public void SetCurveVisible(string[] keys, bool visible)
|
|
|
{
|
|
|
foreach (string key in keys)
|
|
|
{
|
|
|
bool flag = this.data_list.ContainsKey(key);
|
|
|
if (flag)
|
|
|
{
|
|
|
HslCurveItem hslCurveItem = this.data_list[key];
|
|
|
hslCurveItem.Visible = visible;
|
|
|
}
|
|
|
}
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取当前曲线的字典信息，所有的曲线都在这里面，可以进行一些自由的控制
|
|
|
/// </summary>
|
|
|
/// <returns>包含所有曲线的词典信息</returns>
|
|
|
// Token: 0x0600023D RID: 573 RVA: 0x0001F055 File Offset: 0x0001D255
|
|
|
public Dictionary<string, HslCurveItem> GetAllCurve()
|
|
|
{
|
|
|
return this.data_list;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增一条左侧的辅助线，使用默认的文本颜色
|
|
|
/// </summary>
|
|
|
/// <param name="value">数据值</param>
|
|
|
// Token: 0x0600023E RID: 574 RVA: 0x0001F060 File Offset: 0x0001D260
|
|
|
public AuxiliaryLine AddLeftAuxiliary(float value)
|
|
|
{
|
|
|
return this.AddLeftAuxiliary(value, this.ColorLinesAndText);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增一条左侧的辅助线，使用指定的颜色
|
|
|
/// </summary>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <param name="lineColor">线条颜色</param>
|
|
|
// Token: 0x0600023F RID: 575 RVA: 0x0001F080 File Offset: 0x0001D280
|
|
|
public AuxiliaryLine AddLeftAuxiliary(float value, Color lineColor)
|
|
|
{
|
|
|
return this.AddLeftAuxiliary(value, lineColor, 1f, true);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增一条左侧的辅助线
|
|
|
/// </summary>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <param name="lineColor">线条颜色</param>
|
|
|
/// <param name="lineThickness">线条宽度</param>
|
|
|
/// <param name="isDashLine">是否是虚线</param>
|
|
|
// Token: 0x06000240 RID: 576 RVA: 0x0001F0A0 File Offset: 0x0001D2A0
|
|
|
public AuxiliaryLine AddLeftAuxiliary(float value, Color lineColor, float lineThickness, bool isDashLine)
|
|
|
{
|
|
|
return this.AddAuxiliary(value, lineColor, lineThickness, isDashLine, true);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增一条右侧的辅助线，使用默认的文本颜色
|
|
|
/// </summary>
|
|
|
/// <param name="value">数据值</param>
|
|
|
// Token: 0x06000241 RID: 577 RVA: 0x0001F0C0 File Offset: 0x0001D2C0
|
|
|
public AuxiliaryLine AddRightAuxiliary(float value)
|
|
|
{
|
|
|
return this.AddRightAuxiliary(value, this.ColorLinesAndText);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增一条右侧的辅助线，使用指定的颜色
|
|
|
/// </summary>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <param name="lineColor">线条颜色</param>
|
|
|
// Token: 0x06000242 RID: 578 RVA: 0x0001F0E0 File Offset: 0x0001D2E0
|
|
|
public AuxiliaryLine AddRightAuxiliary(float value, Color lineColor)
|
|
|
{
|
|
|
return this.AddRightAuxiliary(value, lineColor, 1f, true);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增一条右侧的辅助线
|
|
|
/// </summary>
|
|
|
/// <param name="value">数据值</param>
|
|
|
/// <param name="lineColor">线条颜色</param>
|
|
|
/// <param name="lineThickness">线条宽度</param>
|
|
|
/// <param name="isDashLine">是否是虚线的信息</param>
|
|
|
// Token: 0x06000243 RID: 579 RVA: 0x0001F100 File Offset: 0x0001D300
|
|
|
public AuxiliaryLine AddRightAuxiliary(float value, Color lineColor, float lineThickness, bool isDashLine)
|
|
|
{
|
|
|
return this.AddAuxiliary(value, lineColor, lineThickness, isDashLine, false);
|
|
|
}
|
|
|
|
|
|
// Token: 0x06000244 RID: 580 RVA: 0x0001F120 File Offset: 0x0001D320
|
|
|
private AuxiliaryLine AddAuxiliary(float value, Color lineColor, float lineThickness, bool isDashLine, bool isLeft)
|
|
|
{
|
|
|
AuxiliaryLine auxiliaryLine = new AuxiliaryLine
|
|
|
{
|
|
|
Value = value,
|
|
|
LineColor = lineColor,
|
|
|
PenDash = new Pen(lineColor)
|
|
|
{
|
|
|
DashStyle = DashStyle.Custom,
|
|
|
DashPattern = new float[]
|
|
|
{
|
|
|
5f,
|
|
|
5f
|
|
|
}
|
|
|
},
|
|
|
PenSolid = new Pen(lineColor),
|
|
|
IsDashStyle = isDashLine,
|
|
|
IsLeftFrame = isLeft,
|
|
|
LineThickness = lineThickness,
|
|
|
LineTextBrush = new SolidBrush(lineColor)
|
|
|
};
|
|
|
this.auxiliary_lines.Add(auxiliaryLine);
|
|
|
base.Invalidate();
|
|
|
return auxiliaryLine;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除所有的指定值的辅助曲线，包括左边的和右边的
|
|
|
/// </summary>
|
|
|
/// <param name="value">移除的数据值</param>
|
|
|
// Token: 0x06000245 RID: 581 RVA: 0x0001F1C8 File Offset: 0x0001D3C8
|
|
|
public void RemoveAuxiliary(float value)
|
|
|
{
|
|
|
int num = 0;
|
|
|
for (int i = this.auxiliary_lines.Count - 1; i >= 0; i--)
|
|
|
{
|
|
|
bool flag = this.auxiliary_lines[i].Value == value;
|
|
|
if (flag)
|
|
|
{
|
|
|
this.auxiliary_lines[i].Dispose();
|
|
|
this.auxiliary_lines.RemoveAt(i);
|
|
|
num++;
|
|
|
}
|
|
|
}
|
|
|
bool flag2 = num > 0;
|
|
|
if (flag2)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除一个指定的辅助对象
|
|
|
/// </summary>
|
|
|
/// <param name="auxiliary">移除的数据值</param>
|
|
|
// Token: 0x06000246 RID: 582 RVA: 0x0001F248 File Offset: 0x0001D448
|
|
|
public void RemoveAuxiliary(AuxiliaryLine auxiliary)
|
|
|
{
|
|
|
bool flag = this.auxiliary_lines.Remove(auxiliary);
|
|
|
if (flag)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除所有的辅助线
|
|
|
/// </summary>
|
|
|
// Token: 0x06000247 RID: 583 RVA: 0x0001F270 File Offset: 0x0001D470
|
|
|
public void RemoveAllAuxiliary()
|
|
|
{
|
|
|
int count = this.auxiliary_lines.Count;
|
|
|
this.auxiliary_lines.Clear();
|
|
|
bool flag = count > 0;
|
|
|
if (flag)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增一条辅助标签
|
|
|
/// </summary>
|
|
|
/// <param name="auxiliaryLable">描述的标签值</param>
|
|
|
// Token: 0x06000248 RID: 584 RVA: 0x0001F2A5 File Offset: 0x0001D4A5
|
|
|
public void AddAuxiliaryLabel(AuxiliaryLable auxiliaryLable)
|
|
|
{
|
|
|
this.auxiliary_Labels.Add(auxiliaryLable);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除指定的辅助标签
|
|
|
/// </summary>
|
|
|
/// <param name="auxiliaryLable">等待删除的对象</param>
|
|
|
// Token: 0x06000249 RID: 585 RVA: 0x0001F2B8 File Offset: 0x0001D4B8
|
|
|
public void RemoveAuxiliaryLable(AuxiliaryLable auxiliaryLable)
|
|
|
{
|
|
|
bool flag = this.auxiliary_Labels.Remove(auxiliaryLable);
|
|
|
if (flag)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除所有的辅助标签
|
|
|
/// </summary>
|
|
|
// Token: 0x0600024A RID: 586 RVA: 0x0001F2E0 File Offset: 0x0001D4E0
|
|
|
public void RemoveAllAuxiliaryLable()
|
|
|
{
|
|
|
int count = this.auxiliary_Labels.Count;
|
|
|
this.auxiliary_Labels.Clear();
|
|
|
bool flag = count > 0;
|
|
|
if (flag)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增一个标记的文本信息
|
|
|
/// </summary>
|
|
|
/// <param name="markText">文本标记信息</param>
|
|
|
// Token: 0x0600024B RID: 587 RVA: 0x0001F318 File Offset: 0x0001D518
|
|
|
public void AddMarkText(HslMarkText markText)
|
|
|
{
|
|
|
this.hslMarkTexts.Add(markText);
|
|
|
bool flag = this.data_list.Count > 0;
|
|
|
if (flag)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除一个标记的文本信息
|
|
|
/// </summary>
|
|
|
/// <param name="markText">文本标记信息</param>
|
|
|
// Token: 0x0600024C RID: 588 RVA: 0x0001F350 File Offset: 0x0001D550
|
|
|
public void RemoveMarkText(HslMarkText markText)
|
|
|
{
|
|
|
this.hslMarkTexts.Remove(markText);
|
|
|
bool flag = this.data_list.Count > 0;
|
|
|
if (flag)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 移除所有的标记的文本信息
|
|
|
/// </summary>
|
|
|
// Token: 0x0600024D RID: 589 RVA: 0x0001F388 File Offset: 0x0001D588
|
|
|
public void RemoveAllMarkText()
|
|
|
{
|
|
|
this.hslMarkTexts.Clear();
|
|
|
bool flag = this.data_list.Count > 0;
|
|
|
if (flag)
|
|
|
{
|
|
|
base.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 鼠标移动的信息
|
|
|
/// </summary>
|
|
|
/// <param name="e"></param>
|
|
|
// Token: 0x0600024E RID: 590 RVA: 0x0001F3C0 File Offset: 0x0001D5C0
|
|
|
protected override void OnMouseMove(MouseEventArgs e)
|
|
|
{
|
|
|
base.OnMouseMove(e);
|
|
|
bool flag = false;
|
|
|
foreach (KeyValuePair<string, HslCurveItem> keyValuePair in this.data_list)
|
|
|
{
|
|
|
bool flag2 = keyValuePair.Value.TitleRegion.Contains(e.Location);
|
|
|
if (flag2)
|
|
|
{
|
|
|
flag = true;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
this.Cursor = (flag ? Cursors.Hand : Cursors.Arrow);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 鼠标点击的信息
|
|
|
/// </summary>
|
|
|
/// <param name="e"></param>
|
|
|
// Token: 0x0600024F RID: 591 RVA: 0x0001F45C File Offset: 0x0001D65C
|
|
|
protected override void OnMouseDown(MouseEventArgs e)
|
|
|
{
|
|
|
base.OnMouseDown(e);
|
|
|
foreach (KeyValuePair<string, HslCurveItem> keyValuePair in this.data_list)
|
|
|
{
|
|
|
bool flag = keyValuePair.Value.TitleRegion.Contains(e.Location);
|
|
|
if (flag)
|
|
|
{
|
|
|
keyValuePair.Value.LineRenderVisiable = !keyValuePair.Value.LineRenderVisiable;
|
|
|
base.Invalidate();
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 重绘控件的基本外观
|
|
|
/// </summary>
|
|
|
/// <param name="e">重绘事件</param>
|
|
|
// Token: 0x06000250 RID: 592 RVA: 0x0001F500 File Offset: 0x0001D700
|
|
|
protected override void OnPaint(PaintEventArgs e)
|
|
|
{
|
|
|
Graphics graphics = e.Graphics;
|
|
|
graphics.SmoothingMode = SmoothingMode.HighQuality;
|
|
|
graphics.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
|
|
|
this.PaintHslControls(graphics, base.Width, base.Height);
|
|
|
base.OnPaint(e);
|
|
|
}
|
|
|
|
|
|
/// <inheritdoc cref="M:HslControls.HslArrow.PaintHslControls(System.Drawing.Graphics,System.Single,System.Single)" />
|
|
|
// Token: 0x06000251 RID: 593 RVA: 0x0001F544 File Offset: 0x0001D744
|
|
|
public void PaintHslControls(Graphics g, int width, int height)
|
|
|
{
|
|
|
bool flag = !true;
|
|
|
if (!flag)
|
|
|
{
|
|
|
bool flag2 = this.BackColor != Color.Transparent;
|
|
|
if (flag2)
|
|
|
{
|
|
|
g.Clear(this.BackColor);
|
|
|
}
|
|
|
int num = height - this.upDown - this.upDown;
|
|
|
bool flag3 = width < 120 || height < 60;
|
|
|
if (!flag3)
|
|
|
{
|
|
|
Point[] array = new Point[]
|
|
|
{
|
|
|
new Point(this.leftRight - 1, this.upDown - 8),
|
|
|
new Point(this.leftRight - 1, height - this.upDown),
|
|
|
new Point(width - this.leftRight, height - this.upDown),
|
|
|
new Point(width - this.leftRight, this.upDown - 8)
|
|
|
};
|
|
|
g.DrawLine(this.pen_normal, array[1], array[2]);
|
|
|
g.DrawLine(this.referenceAxisLeft.GetPen(), array[0], array[1]);
|
|
|
bool flag4 = this.isRenderRightCoordinate;
|
|
|
if (flag4)
|
|
|
{
|
|
|
g.DrawLine(this.referenceAxisRight.GetPen(), array[2], array[3]);
|
|
|
}
|
|
|
bool flag5 = !string.IsNullOrEmpty(this.value_title);
|
|
|
if (flag5)
|
|
|
{
|
|
|
g.DrawString(this.value_title, this.font_size9, this.brush_deep, new Rectangle(0, 0, width - 1, 20), this.format_center);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
bool flag6 = this.data_list.Count > 0;
|
|
|
if (flag6)
|
|
|
{
|
|
|
float num2 = (float)(this.leftRight + 10);
|
|
|
foreach (KeyValuePair<string, HslCurveItem> keyValuePair in this.data_list)
|
|
|
{
|
|
|
bool visible = keyValuePair.Value.Visible;
|
|
|
if (visible)
|
|
|
{
|
|
|
Pen pen = keyValuePair.Value.LineRenderVisiable ? new Pen(keyValuePair.Value.LineColor) : new Pen(Color.FromArgb(80, keyValuePair.Value.LineColor));
|
|
|
g.DrawLine(pen, num2, (float)(this.upDown / 2 - 1), num2 + 30f, (float)(this.upDown / 2 - 1));
|
|
|
g.DrawEllipse(pen, num2 + 8f, (float)(this.upDown / 2 - 8), 14f, 14f);
|
|
|
pen.Dispose();
|
|
|
SolidBrush solidBrush = keyValuePair.Value.LineRenderVisiable ? new SolidBrush(keyValuePair.Value.LineColor) : new SolidBrush(Color.FromArgb(80, keyValuePair.Value.LineColor));
|
|
|
g.DrawString(keyValuePair.Key, this.Font, solidBrush, new RectangleF(num2 + 35f, (float)(this.upDown / 2 - 9), 120f, 18f), this.format_left);
|
|
|
keyValuePair.Value.TitleRegion = new RectangleF(num2, 2f, 60f, 18f);
|
|
|
solidBrush.Dispose();
|
|
|
num2 += (float)this.curveNameWidth;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
for (int i = 0; i < this.auxiliary_Labels.Count; i++)
|
|
|
{
|
|
|
bool flag7 = !string.IsNullOrEmpty(this.auxiliary_Labels[i].Text);
|
|
|
if (flag7)
|
|
|
{
|
|
|
int num3 = (this.auxiliary_Labels[i].LocationX > 1f) ? ((int)this.auxiliary_Labels[i].LocationX) : ((int)(this.auxiliary_Labels[i].LocationX * (float)width));
|
|
|
int num4 = (int)g.MeasureString(this.auxiliary_Labels[i].Text, this.Font).Width + 3;
|
|
|
Point[] points = new Point[]
|
|
|
{
|
|
|
new Point(num3, 11),
|
|
|
new Point(num3 + 10, 20),
|
|
|
new Point(num3 + num4 + 10, 20),
|
|
|
new Point(num3 + num4 + 10, 0),
|
|
|
new Point(num3 + 10, 0),
|
|
|
new Point(num3, 11)
|
|
|
};
|
|
|
g.FillPolygon(this.auxiliary_Labels[i].TextBack, points);
|
|
|
g.DrawString(this.auxiliary_Labels[i].Text, this.Font, this.auxiliary_Labels[i].TextBrush, new Rectangle(num3 + 7, 0, num4 + 3, 20), this.format_center);
|
|
|
}
|
|
|
}
|
|
|
HslHelper.PaintTriangle(g, this.referenceAxisLeft.Brush, new Point(this.leftRight - 1, this.upDown - 8), 4, GraphDirection.Upward);
|
|
|
bool flag8 = this.isRenderRightCoordinate;
|
|
|
if (flag8)
|
|
|
{
|
|
|
HslHelper.PaintTriangle(g, this.referenceAxisRight.Brush, new Point(width - this.leftRight, this.upDown - 8), 4, GraphDirection.Upward);
|
|
|
}
|
|
|
bool flag9 = !string.IsNullOrEmpty(this.referenceAxisLeft.Unit);
|
|
|
if (flag9)
|
|
|
{
|
|
|
g.DrawString(this.referenceAxisLeft.Unit, this.font_size9, this.referenceAxisLeft.Brush, new RectangleF(0f, 0f, (float)(this.leftRight - 4), (float)(this.upDown - 5)), this.format_right);
|
|
|
}
|
|
|
bool flag10 = this.isRenderRightCoordinate && !string.IsNullOrEmpty(this.referenceAxisRight.Unit);
|
|
|
if (flag10)
|
|
|
{
|
|
|
g.DrawString(this.referenceAxisRight.Unit, this.font_size9, this.referenceAxisRight.Brush, new RectangleF((float)(width - this.leftRight + 4), 0f, (float)(this.leftRight - 4), (float)(this.upDown - 5)), this.format_left);
|
|
|
}
|
|
|
for (int j = 0; j < this.auxiliary_lines.Count; j++)
|
|
|
{
|
|
|
bool isLeftFrame = this.auxiliary_lines[j].IsLeftFrame;
|
|
|
if (isLeftFrame)
|
|
|
{
|
|
|
this.auxiliary_lines[j].PaintValue = HslHelper.ComputePaintLocationY(this.referenceAxisLeft, (float)num, this.auxiliary_lines[j].Value) + (float)this.upDown;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
this.auxiliary_lines[j].PaintValue = HslHelper.ComputePaintLocationY(this.referenceAxisRight, (float)num, this.auxiliary_lines[j].Value) + (float)this.upDown;
|
|
|
}
|
|
|
}
|
|
|
for (int k = 0; k <= this.value_Segment; k++)
|
|
|
{
|
|
|
float value = (float)((double)k * (double)(this.referenceAxisLeft.Max - this.referenceAxisLeft.Min) / (double)this.value_Segment + (double)this.referenceAxisLeft.Min);
|
|
|
float num5 = HslHelper.ComputePaintLocationY(this.referenceAxisLeft.Max, this.referenceAxisLeft.Min, (float)num, value) + (float)this.upDown;
|
|
|
bool flag11 = this.IsNeedPaintDash(num5);
|
|
|
if (flag11)
|
|
|
{
|
|
|
g.DrawLine(this.referenceAxisLeft.GetPen(), (float)(this.leftRight - 4), num5, (float)(this.leftRight - 1), num5);
|
|
|
RectangleF layoutRectangle = new RectangleF(0f, num5 - 9f, (float)(this.leftRight - 4), 20f);
|
|
|
g.DrawString(HslHelper.GetFormatString(this.referenceAxisLeft.Format, value, false), this.font_size9, this.referenceAxisLeft.Brush, layoutRectangle, this.format_right);
|
|
|
bool flag12 = this.isRenderRightCoordinate;
|
|
|
if (flag12)
|
|
|
{
|
|
|
float value2 = (float)((double)k * (double)(this.referenceAxisRight.Max - this.referenceAxisRight.Min) / (double)this.value_Segment + (double)this.referenceAxisRight.Min);
|
|
|
g.DrawLine(this.referenceAxisRight.GetPen(), (float)(width - this.leftRight + 1), num5, (float)(width - this.leftRight + 4), num5);
|
|
|
layoutRectangle.Location = new PointF((float)(width - this.leftRight + 4), num5 - 9f);
|
|
|
g.DrawString(HslHelper.GetFormatString(this.referenceAxisRight.Format, value2, false), this.font_size9, this.referenceAxisRight.Brush, layoutRectangle, this.format_left);
|
|
|
}
|
|
|
bool flag13 = k > 0 && this.value_IsRenderDashLine;
|
|
|
if (flag13)
|
|
|
{
|
|
|
g.DrawLine(this.pen_dash, (float)this.leftRight, num5, (float)(width - this.leftRight), num5);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
bool flag14 = this.value_IsRenderDashLine;
|
|
|
if (flag14)
|
|
|
{
|
|
|
bool flag15 = this.value_IsAbscissaStrech;
|
|
|
if (flag15)
|
|
|
{
|
|
|
float num6 = (float)(width - this.leftRight * 2) * 1f / (float)(this.value_StrechDataCountMax - 1);
|
|
|
int num7 = this.CalculateDataCountByOffect(num6);
|
|
|
for (int l = 0; l < this.value_StrechDataCountMax; l += num7)
|
|
|
{
|
|
|
bool flag16 = l > 0 && l < this.value_StrechDataCountMax - 1;
|
|
|
if (flag16)
|
|
|
{
|
|
|
g.DrawLine(this.pen_dash, (float)l * num6 + (float)this.leftRight, (float)this.upDown, (float)l * num6 + (float)this.leftRight, (float)(height - this.upDown - 1));
|
|
|
}
|
|
|
bool flag17 = this.data_text != null;
|
|
|
if (flag17)
|
|
|
{
|
|
|
bool flag18 = l < this.data_text.Length && (float)l * num6 + (float)this.leftRight < (float)(this.data_text.Length - 1) * num6 + (float)this.leftRight - 40f;
|
|
|
if (flag18)
|
|
|
{
|
|
|
Rectangle r = new Rectangle((int)((float)l * num6), height - this.upDown + 1, this.leftRight * 2, this.upDown);
|
|
|
g.DrawString(this.data_text[l], this.font_size9, this.brush_deep, r, this.format_center);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
string[] array2 = this.data_text;
|
|
|
bool flag19 = array2 != null && array2.Length > 1;
|
|
|
if (flag19)
|
|
|
{
|
|
|
bool flag20 = this.data_text.Length < this.value_StrechDataCountMax;
|
|
|
if (flag20)
|
|
|
{
|
|
|
g.DrawLine(this.pen_dash, (float)(this.data_text.Length - 1) * num6 + (float)this.leftRight, (float)this.upDown, (float)(this.data_text.Length - 1) * num6 + (float)this.leftRight, (float)(height - this.upDown - 1));
|
|
|
}
|
|
|
Rectangle r2 = new Rectangle((int)((float)(this.data_text.Length - 1) * num6 + (float)this.leftRight) - this.leftRight, height - this.upDown + 1, this.leftRight * 2, this.upDown);
|
|
|
g.DrawString(this.data_text[this.data_text.Length - 1], this.font_size9, this.brush_deep, r2, this.format_center);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
int num8 = width - 2 * this.leftRight + 1;
|
|
|
bool flag21 = this.value_IntervalAbscissaText > 0;
|
|
|
if (flag21)
|
|
|
{
|
|
|
for (int m = this.leftRight; m < width - this.leftRight; m += this.value_IntervalAbscissaText)
|
|
|
{
|
|
|
bool flag22 = m != this.leftRight;
|
|
|
if (flag22)
|
|
|
{
|
|
|
g.DrawLine(this.pen_dash, m, this.upDown, m, height - this.upDown - 1);
|
|
|
}
|
|
|
bool flag23 = this.data_text != null;
|
|
|
if (flag23)
|
|
|
{
|
|
|
int num9 = (num8 > this.data_text.Length) ? this.data_text.Length : num8;
|
|
|
bool flag24 = m - this.leftRight < this.data_text.Length;
|
|
|
if (flag24)
|
|
|
{
|
|
|
bool flag25 = num9 - (m - this.leftRight) > 40;
|
|
|
if (flag25)
|
|
|
{
|
|
|
bool flag26 = this.data_text.Length <= num8;
|
|
|
if (flag26)
|
|
|
{
|
|
|
Rectangle r3 = new Rectangle(m - this.leftRight, height - this.upDown + 1, this.leftRight * 2, this.upDown);
|
|
|
g.DrawString(this.data_text[m - this.leftRight], this.font_size9, this.brush_deep, r3, this.format_center);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Rectangle r4 = new Rectangle(m - this.leftRight, height - this.upDown + 1, this.leftRight * 2, this.upDown);
|
|
|
g.DrawString(this.data_text[m - this.leftRight + this.data_text.Length - num8], this.font_size9, this.brush_deep, r4, this.format_center);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
string[] array3 = this.data_text;
|
|
|
bool flag27 = array3 != null && array3.Length > 1;
|
|
|
if (flag27)
|
|
|
{
|
|
|
bool flag28 = this.data_text.Length < num8;
|
|
|
if (flag28)
|
|
|
{
|
|
|
g.DrawLine(this.pen_dash, this.data_text.Length + this.leftRight - 1, this.upDown, this.data_text.Length + this.leftRight - 1, height - this.upDown - 1);
|
|
|
Rectangle r5 = new Rectangle(this.data_text.Length + this.leftRight - 1 - this.leftRight, height - this.upDown + 1, this.leftRight * 2, this.upDown);
|
|
|
g.DrawString(this.data_text[this.data_text.Length - 1], this.font_size9, this.brush_deep, r5, this.format_center);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
Rectangle r6 = new Rectangle(width - this.leftRight - this.leftRight, height - this.upDown + 1, this.leftRight * 2, this.upDown);
|
|
|
g.DrawString(this.data_text[this.data_text.Length - 1], this.font_size9, this.brush_deep, r6, this.format_center);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
for (int n = 0; n < this.auxiliary_lines.Count; n++)
|
|
|
{
|
|
|
bool isLeftFrame2 = this.auxiliary_lines[n].IsLeftFrame;
|
|
|
if (isLeftFrame2)
|
|
|
{
|
|
|
g.DrawLine(this.auxiliary_lines[n].GetPen(), (float)(this.leftRight - 4), this.auxiliary_lines[n].PaintValue, (float)(this.leftRight - 1), this.auxiliary_lines[n].PaintValue);
|
|
|
RectangleF layoutRectangle2 = new RectangleF(0f, this.auxiliary_lines[n].PaintValue - 9f, (float)(this.leftRight - 4), 20f);
|
|
|
g.DrawString(HslHelper.GetFormatString(this.referenceAxisLeft.Format, this.auxiliary_lines[n].Value, false), this.font_size9, this.auxiliary_lines[n].LineTextBrush, layoutRectangle2, this.format_right);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
g.DrawLine(this.auxiliary_lines[n].GetPen(), (float)(width - this.leftRight + 1), this.auxiliary_lines[n].PaintValue, (float)(width - this.leftRight + 4), this.auxiliary_lines[n].PaintValue);
|
|
|
RectangleF layoutRectangle3 = new RectangleF((float)(width - this.leftRight + 4), this.auxiliary_lines[n].PaintValue - 9f, (float)(this.leftRight - 4), 20f);
|
|
|
g.DrawString(HslHelper.GetFormatString(this.referenceAxisRight.Format, this.auxiliary_lines[n].Value, false), this.font_size9, this.auxiliary_lines[n].LineTextBrush, layoutRectangle3, this.format_left);
|
|
|
}
|
|
|
g.DrawLine(this.auxiliary_lines[n].GetPen(), (float)this.leftRight, this.auxiliary_lines[n].PaintValue, (float)(width - this.leftRight), this.auxiliary_lines[n].PaintValue);
|
|
|
}
|
|
|
bool flag29 = this.value_IsAbscissaStrech;
|
|
|
if (flag29)
|
|
|
{
|
|
|
foreach (HslMarkText hslMarkText in this.hslMarkTexts)
|
|
|
{
|
|
|
foreach (KeyValuePair<string, HslCurveItem> keyValuePair2 in this.data_list)
|
|
|
{
|
|
|
bool flag30 = !keyValuePair2.Value.Visible;
|
|
|
if (!flag30)
|
|
|
{
|
|
|
bool flag31 = !keyValuePair2.Value.LineRenderVisiable;
|
|
|
if (!flag31)
|
|
|
{
|
|
|
bool flag32 = keyValuePair2.Key != hslMarkText.CurveKey;
|
|
|
if (!flag32)
|
|
|
{
|
|
|
float[] data = keyValuePair2.Value.Data;
|
|
|
bool flag33 = data != null && data.Length > 1;
|
|
|
if (flag33)
|
|
|
{
|
|
|
float num10 = (float)(width - this.leftRight * 2) * 1f / (float)(this.value_StrechDataCountMax - 1);
|
|
|
bool flag34 = hslMarkText.Index >= 0 && hslMarkText.Index < keyValuePair2.Value.Data.Length;
|
|
|
if (flag34)
|
|
|
{
|
|
|
PointF center = new PointF((float)this.leftRight + (float)hslMarkText.Index * num10, HslHelper.ComputePaintLocationY((keyValuePair2.Value.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Max : this.referenceAxisRight.Max, (keyValuePair2.Value.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Min : this.referenceAxisRight.Min, (float)num, keyValuePair2.Value.Data[hslMarkText.Index]) + (float)this.upDown);
|
|
|
MarkTextPositionStyle markTextPosition = (hslMarkText.PositionStyle == MarkTextPositionStyle.Auto) ? HslMarkText.CalculateDirectionFromDataIndex(keyValuePair2.Value.Data, hslMarkText.Index) : hslMarkText.PositionStyle;
|
|
|
HslCurveHelper.DrawHslMarkTextPoint(g, hslMarkText, center, this.Font, markTextPosition);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
foreach (HslCurveItem hslCurveItem in this.data_list.Values)
|
|
|
{
|
|
|
bool flag35 = !hslCurveItem.Visible;
|
|
|
if (!flag35)
|
|
|
{
|
|
|
bool flag36 = !hslCurveItem.LineRenderVisiable;
|
|
|
if (!flag36)
|
|
|
{
|
|
|
float[] data2 = hslCurveItem.Data;
|
|
|
bool flag37 = data2 != null && data2.Length > 1;
|
|
|
if (flag37)
|
|
|
{
|
|
|
float num11 = (float)(width - this.leftRight * 2) * 1f / (float)(this.value_StrechDataCountMax - 1);
|
|
|
List<PointF> list = new List<PointF>(hslCurveItem.Data.Length);
|
|
|
for (int num12 = 0; num12 < hslCurveItem.Data.Length; num12++)
|
|
|
{
|
|
|
bool flag38 = !float.IsNaN(hslCurveItem.Data[num12]);
|
|
|
if (flag38)
|
|
|
{
|
|
|
PointF pointF = new PointF
|
|
|
{
|
|
|
X = (float)this.leftRight + (float)num12 * num11,
|
|
|
Y = HslHelper.ComputePaintLocationY((hslCurveItem.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Max : this.referenceAxisRight.Max, (hslCurveItem.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Min : this.referenceAxisRight.Min, (float)num, hslCurveItem.Data[num12]) + (float)this.upDown
|
|
|
};
|
|
|
list.Add(pointF);
|
|
|
bool flag39 = !string.IsNullOrEmpty(hslCurveItem.MarkText[num12]);
|
|
|
if (flag39)
|
|
|
{
|
|
|
using (Brush brush = new SolidBrush(hslCurveItem.LineColor))
|
|
|
{
|
|
|
g.FillEllipse(brush, new RectangleF(pointF.X - 3f, pointF.Y - 3f, 6f, 6f));
|
|
|
MarkTextPositionStyle markTextPosition2 = HslMarkText.CalculateDirectionFromDataIndex(hslCurveItem.Data, num12);
|
|
|
HslCurveHelper.DrawTextByPoint(g, hslCurveItem.MarkText[num12], pointF, this.Font, brush, markTextPosition2, 5);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
HslCurveHelper.DrawLineCore(g, hslCurveItem, list, this.pointsRadius, -1f);
|
|
|
list.Clear();
|
|
|
}
|
|
|
}
|
|
|
HslCurveHelper.DrawLineCore(g, hslCurveItem, list, this.pointsRadius, -1f);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
foreach (HslMarkText hslMarkText2 in this.hslMarkTexts)
|
|
|
{
|
|
|
foreach (KeyValuePair<string, HslCurveItem> keyValuePair3 in this.data_list)
|
|
|
{
|
|
|
bool flag40 = !keyValuePair3.Value.Visible;
|
|
|
if (!flag40)
|
|
|
{
|
|
|
bool flag41 = !keyValuePair3.Value.LineRenderVisiable;
|
|
|
if (!flag41)
|
|
|
{
|
|
|
bool flag42 = keyValuePair3.Key != hslMarkText2.CurveKey;
|
|
|
if (!flag42)
|
|
|
{
|
|
|
float[] data3 = keyValuePair3.Value.Data;
|
|
|
bool flag43 = data3 != null && data3.Length > 1;
|
|
|
if (flag43)
|
|
|
{
|
|
|
bool flag44 = hslMarkText2.Index >= 0 && hslMarkText2.Index < keyValuePair3.Value.Data.Length;
|
|
|
if (flag44)
|
|
|
{
|
|
|
PointF center2 = new PointF((float)(this.leftRight + hslMarkText2.Index), HslHelper.ComputePaintLocationY((keyValuePair3.Value.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Max : this.referenceAxisRight.Max, (keyValuePair3.Value.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Min : this.referenceAxisRight.Min, (float)num, keyValuePair3.Value.Data[hslMarkText2.Index]) + (float)this.upDown);
|
|
|
MarkTextPositionStyle markTextPosition3 = (hslMarkText2.PositionStyle == MarkTextPositionStyle.Auto) ? HslMarkText.CalculateDirectionFromDataIndex(keyValuePair3.Value.Data, hslMarkText2.Index) : hslMarkText2.PositionStyle;
|
|
|
HslCurveHelper.DrawHslMarkTextPoint(g, hslMarkText2, center2, this.Font, markTextPosition3);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
foreach (HslCurveItem hslCurveItem2 in this.data_list.Values)
|
|
|
{
|
|
|
bool flag45 = !hslCurveItem2.Visible;
|
|
|
if (!flag45)
|
|
|
{
|
|
|
bool flag46 = !hslCurveItem2.LineRenderVisiable;
|
|
|
if (!flag46)
|
|
|
{
|
|
|
float[] data4 = hslCurveItem2.Data;
|
|
|
bool flag47 = data4 != null && data4.Length > 1;
|
|
|
if (flag47)
|
|
|
{
|
|
|
int num13 = width - 2 * this.leftRight + 1;
|
|
|
List<PointF> list2 = new List<PointF>(hslCurveItem2.Data.Length);
|
|
|
bool flag48 = hslCurveItem2.Data.Length <= num13;
|
|
|
if (flag48)
|
|
|
{
|
|
|
for (int num14 = 0; num14 < hslCurveItem2.Data.Length; num14++)
|
|
|
{
|
|
|
bool flag49 = !float.IsNaN(hslCurveItem2.Data[num14]);
|
|
|
if (flag49)
|
|
|
{
|
|
|
PointF pointF2 = new PointF
|
|
|
{
|
|
|
X = (float)(this.leftRight + num14),
|
|
|
Y = HslHelper.ComputePaintLocationY((hslCurveItem2.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Max : this.referenceAxisRight.Max, (hslCurveItem2.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Min : this.referenceAxisRight.Min, (float)num, hslCurveItem2.Data[num14]) + (float)this.upDown
|
|
|
};
|
|
|
list2.Add(pointF2);
|
|
|
this.DrawMarkPoint(g, hslCurveItem2.MarkText[num14], pointF2, hslCurveItem2.LineColor, HslMarkText.CalculateDirectionFromDataIndex(hslCurveItem2.Data, num14));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
HslCurveHelper.DrawLineCore(g, hslCurveItem2, list2, this.pointsRadius, -1f);
|
|
|
list2.Clear();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
for (int num15 = 0; num15 < num13; num15++)
|
|
|
{
|
|
|
int num16 = num15 + hslCurveItem2.Data.Length - num13;
|
|
|
bool flag50 = !float.IsNaN(hslCurveItem2.Data[num16]);
|
|
|
if (flag50)
|
|
|
{
|
|
|
PointF pointF3 = new PointF
|
|
|
{
|
|
|
X = (float)(this.leftRight + num15),
|
|
|
Y = HslHelper.ComputePaintLocationY((hslCurveItem2.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Max : this.referenceAxisRight.Max, (hslCurveItem2.ReferenceAxisIndex == 0) ? this.referenceAxisLeft.Min : this.referenceAxisRight.Min, (float)num, hslCurveItem2.Data[num16]) + (float)this.upDown
|
|
|
};
|
|
|
list2.Add(pointF3);
|
|
|
this.DrawMarkPoint(g, hslCurveItem2.MarkText[num16], pointF3, hslCurveItem2.LineColor, HslMarkText.CalculateDirectionFromDataIndex(hslCurveItem2.Data, num16));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
HslCurveHelper.DrawLineCore(g, hslCurveItem2, list2, this.pointsRadius, -1f);
|
|
|
list2.Clear();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
HslCurveHelper.DrawLineCore(g, hslCurveItem2, list2, this.pointsRadius, -1f);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Token: 0x06000252 RID: 594 RVA: 0x00020FF4 File Offset: 0x0001F1F4
|
|
|
private void DrawMarkPoint(Graphics g, string markText, PointF center, Color color, MarkTextPositionStyle markTextPosition)
|
|
|
{
|
|
|
bool flag = !string.IsNullOrEmpty(markText);
|
|
|
if (flag)
|
|
|
{
|
|
|
using (Brush brush = new SolidBrush(color))
|
|
|
{
|
|
|
this.DrawMarkPoint(g, markText, center, brush, markTextPosition);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Token: 0x06000253 RID: 595 RVA: 0x00021048 File Offset: 0x0001F248
|
|
|
private void DrawMarkPoint(Graphics g, string markText, PointF center, Brush brush, MarkTextPositionStyle markTextPosition)
|
|
|
{
|
|
|
bool flag = !string.IsNullOrEmpty(markText);
|
|
|
if (flag)
|
|
|
{
|
|
|
g.FillEllipse(brush, new RectangleF(center.X - 3f, center.Y - 3f, 6f, 6f));
|
|
|
HslCurveHelper.DrawTextByPoint(g, markText, center, this.Font, brush, markTextPosition, 5);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Token: 0x06000254 RID: 596 RVA: 0x000210AC File Offset: 0x0001F2AC
|
|
|
private bool IsNeedPaintDash(float paintValue)
|
|
|
{
|
|
|
for (int i = 0; i < this.auxiliary_lines.Count; i++)
|
|
|
{
|
|
|
bool flag = Math.Abs(this.auxiliary_lines[i].PaintValue - paintValue) < (float)this.font_size9.Height;
|
|
|
if (flag)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
// Token: 0x06000255 RID: 597 RVA: 0x0002110C File Offset: 0x0001F30C
|
|
|
private int CalculateDataCountByOffect(float offect)
|
|
|
{
|
|
|
bool flag = this.value_IntervalAbscissaText > 0;
|
|
|
int result;
|
|
|
if (flag)
|
|
|
{
|
|
|
result = this.value_IntervalAbscissaText;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
bool flag2 = offect > 40f;
|
|
|
if (flag2)
|
|
|
{
|
|
|
result = 1;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
offect = 40f / offect;
|
|
|
result = (int)Math.Ceiling((double)offect);
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 清理所有正在使用的资源。
|
|
|
/// </summary>
|
|
|
/// <param name="disposing">如果应释放托管资源，为 true；否则为 false。</param>
|
|
|
// Token: 0x06000256 RID: 598 RVA: 0x00021158 File Offset: 0x0001F358
|
|
|
protected override void Dispose(bool disposing)
|
|
|
{
|
|
|
bool flag = disposing && this.components != null;
|
|
|
if (flag)
|
|
|
{
|
|
|
this.components.Dispose();
|
|
|
}
|
|
|
base.Dispose(disposing);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 设计器支持所需的方法 - 不要修改
|
|
|
/// 使用代码编辑器修改此方法的内容。
|
|
|
/// </summary>
|
|
|
// Token: 0x06000257 RID: 599 RVA: 0x00021190 File Offset: 0x0001F390
|
|
|
private void InitializeComponent()
|
|
|
{
|
|
|
base.SuspendLayout();
|
|
|
base.AutoScaleMode = AutoScaleMode.None;
|
|
|
this.BackColor = Color.Transparent;
|
|
|
base.Name = "HslCurve";
|
|
|
base.Size = new Size(417, 205);
|
|
|
base.ResumeLayout(false);
|
|
|
}
|
|
|
|
|
|
// Token: 0x040000EE RID: 238
|
|
|
private const int value_count_max = 4096;
|
|
|
|
|
|
// Token: 0x040000EF RID: 239
|
|
|
private int value_Segment = 5;
|
|
|
|
|
|
// Token: 0x040000F0 RID: 240
|
|
|
private bool value_IsAbscissaStrech = false;
|
|
|
|
|
|
// Token: 0x040000F1 RID: 241
|
|
|
private int value_StrechDataCountMax = 300;
|
|
|
|
|
|
// Token: 0x040000F2 RID: 242
|
|
|
private bool value_IsRenderDashLine = true;
|
|
|
|
|
|
// Token: 0x040000F3 RID: 243
|
|
|
private string textFormat = "HH:mm";
|
|
|
|
|
|
// Token: 0x040000F4 RID: 244
|
|
|
private int value_IntervalAbscissaText = 100;
|
|
|
|
|
|
// Token: 0x040000F5 RID: 245
|
|
|
private Random random = null;
|
|
|
|
|
|
// Token: 0x040000F6 RID: 246
|
|
|
private string value_title = "";
|
|
|
|
|
|
// Token: 0x040000F7 RID: 247
|
|
|
private ReferenceAxis referenceAxisLeft;
|
|
|
|
|
|
// Token: 0x040000F8 RID: 248
|
|
|
private ReferenceAxis referenceAxisRight;
|
|
|
|
|
|
// Token: 0x040000F9 RID: 249
|
|
|
private int leftRight = 50;
|
|
|
|
|
|
// Token: 0x040000FA RID: 250
|
|
|
private int upDown = 25;
|
|
|
|
|
|
// Token: 0x040000FB RID: 251
|
|
|
private Dictionary<string, HslCurveItem> data_list = null;
|
|
|
|
|
|
// Token: 0x040000FC RID: 252
|
|
|
private string[] data_text = null;
|
|
|
|
|
|
// Token: 0x040000FD RID: 253
|
|
|
private List<AuxiliaryLine> auxiliary_lines;
|
|
|
|
|
|
// Token: 0x040000FE RID: 254
|
|
|
private List<AuxiliaryLable> auxiliary_Labels;
|
|
|
|
|
|
// Token: 0x040000FF RID: 255
|
|
|
private List<HslMarkText> hslMarkTexts;
|
|
|
|
|
|
// Token: 0x04000100 RID: 256
|
|
|
private Font font_size9 = null;
|
|
|
|
|
|
// Token: 0x04000101 RID: 257
|
|
|
private Brush brush_deep = null;
|
|
|
|
|
|
// Token: 0x04000102 RID: 258
|
|
|
private Pen pen_normal = null;
|
|
|
|
|
|
// Token: 0x04000103 RID: 259
|
|
|
private Pen pen_dash = null;
|
|
|
|
|
|
// Token: 0x04000104 RID: 260
|
|
|
private Color color_normal = Color.DeepPink;
|
|
|
|
|
|
// Token: 0x04000105 RID: 261
|
|
|
private Color color_deep = Color.DimGray;
|
|
|
|
|
|
// Token: 0x04000106 RID: 262
|
|
|
private Color color_dash = Color.Gray;
|
|
|
|
|
|
// Token: 0x04000107 RID: 263
|
|
|
private Color color_mark_font = Color.DodgerBlue;
|
|
|
|
|
|
// Token: 0x04000108 RID: 264
|
|
|
private Brush brush_mark_font = Brushes.DodgerBlue;
|
|
|
|
|
|
// Token: 0x04000109 RID: 265
|
|
|
private StringFormat format_left = null;
|
|
|
|
|
|
// Token: 0x0400010A RID: 266
|
|
|
private StringFormat format_right = null;
|
|
|
|
|
|
// Token: 0x0400010B RID: 267
|
|
|
private StringFormat format_center = null;
|
|
|
|
|
|
// Token: 0x0400010C RID: 268
|
|
|
private bool isRenderRightCoordinate = true;
|
|
|
|
|
|
// Token: 0x0400010D RID: 269
|
|
|
private int curveNameWidth = 100;
|
|
|
|
|
|
// Token: 0x0400010E RID: 270
|
|
|
private int pointsRadius = 0;
|
|
|
|
|
|
/// <summary>
|
|
|
/// 必需的设计器变量。
|
|
|
/// </summary>
|
|
|
// Token: 0x0400010F RID: 271
|
|
|
private IContainer components = null;
|
|
|
}
|
|
|
}
|