internal override void Notify(MessageType msg, NamedElement element, object param)
{
base.Notify(msg, element, param);
Scales.Notify(msg, element, param);
Ranges.Notify(msg, element, param);
Pointers.Notify(msg, element, param);
}
void ISelectable.DrawSelection(GaugeGraphics g, bool designTimeSelection)
{
if (GetGauge() == null || GetScale() == null)
{
return;
}
Stack stack = new Stack();
for (NamedElement namedElement = GetGauge().ParentObject; namedElement != null; namedElement = (NamedElement)((IRenderable)namedElement).GetParentRenderable())
{
stack.Push(namedElement);
}
foreach (IRenderable item in stack)
{
g.CreateDrawRegion(item.GetBoundRect(g));
}
g.CreateDrawRegion(((IRenderable)GetGauge()).GetBoundRect(g));
using (GraphicsPath graphicsPath = GetPointerPath(g))
{
if (graphicsPath != null)
{
RectangleF bounds = graphicsPath.GetBounds();
g.DrawSelection(bounds, designTimeSelection, Common.GaugeCore.SelectionBorderColor, Common.GaugeCore.SelectionMarkerColor);
}
}
g.RestoreDrawRegion();
foreach (IRenderable item2 in stack)
{
_ = item2;
g.RestoreDrawRegion();
}
}
internal override void Notify(MessageType msg, NamedElement element, object param)
{
base.Notify(msg, element, param);
switch (msg)
{
case MessageType.NamedElementRemove:
if (element is ScaleBase)
{
ScaleBase scaleBase2 = (ScaleBase)element;
if (scaleBase2.Name == scaleName && scaleBase2.ParentElement == ParentElement && scaleName != "Default")
{
scaleName = string.Empty;
}
}
break;
case MessageType.NamedElementRename:
if (element is ScaleBase)
{
ScaleBase scaleBase = (ScaleBase)element;
if (scaleBase.Name == scaleName && scaleBase.ParentElement == ParentElement)
{
scaleName = (string)param;
}
}
break;
}
Data.Notify(msg, element, param);
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList arrayList = new ArrayList();
if (context != null && context.Instance != null)
{
NamedElement namedElement = null;
if (context.Instance is NamedElement)
{
namedElement = (NamedElement)context.Instance;
}
if (context.Instance is IList && ((IList)context.Instance).Count > 0)
{
namedElement = (NamedElement)((IList)context.Instance)[0];
}
if (namedElement != null && namedElement.Common != null)
{
foreach (InputValue value in namedElement.Common.GaugeCore.Values)
{
arrayList.Add(value.Name);
foreach (CalculatedValue calculatedValue in value.CalculatedValues)
{
arrayList.Add(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", calculatedValue.InputValueObj.Name, calculatedValue.Name));
}
}
}
}
arrayList.Add("(none)");
return(new StandardValuesCollection(arrayList));
}
internal void SetByNameCheck(string name, NamedElement element)
{
if (!SetByName(name, element))
{
throw new ArgumentException(Utils.SRGetStr("ExceptionElementNotFound", elementType.Name, name, GetType().Name));
}
}
internal bool IsParentElementValid(IRenderable r, object startObject, bool raiseException)
{
string parentRenderableName = r.GetParentRenderableName();
if (parentRenderableName != string.Empty && parentRenderableName != "(none)")
{
NamedElement element = GetElement(parentRenderableName);
if (element != null)
{
if (element == startObject)
{
if (raiseException)
{
throw new ApplicationException(Utils.SRGetStr("ExceptionCircularReference"));
}
return(false);
}
if (!(element is IRenderable))
{
if (raiseException)
{
throw new ApplicationException(Utils.SRGetStr("ExceptionParentNotRenderable", parentRenderableName));
}
return(false);
}
return(IsParentElementValid((IRenderable)element, startObject, raiseException));
}
if (raiseException)
{
throw new ApplicationException(Utils.SRGetStr("ExceptionInvalidParent", parentRenderableName));
}
return(false);
}
return(true);
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList arrayList = new ArrayList();
if (context != null && context.Instance != null)
{
NamedElement namedElement = null;
if (context.Instance is CalculatedValue)
{
namedElement = (CalculatedValue)context.Instance;
}
if (namedElement == null && context.Instance is Array)
{
Array array = (Array)context.Instance;
if (array.Length > 0 && array.GetValue(0) is CalculatedValue)
{
namedElement = (CalculatedValue)array.GetValue(0);
}
}
if (namedElement != null && namedElement.Collection != null)
{
arrayList.Add(namedElement.Collection.parent.Name);
foreach (NamedElement item in namedElement.Collection)
{
if (item.Name != namedElement.Name)
{
arrayList.Add(item.Name);
}
}
}
}
return(new StandardValuesCollection(arrayList));
}
private void CheckForTypeDublicatesAndName(object value)
{
if (!IsCorrectType(value))
{
throw new NotSupportedException(Utils.SRGetStr("ExceptionInvalidObjectType", GetCollectionName(), elementType.Name));
}
if (value is int && base.List.IndexOf(value) != -1)
{
throw new NotSupportedException(Utils.SRGetStr("ExceptionDuplicateObjectFailed", GetCollectionName()));
}
NamedElement namedElement = (NamedElement)value;
if (namedElement.Name == null || namedElement.Name == string.Empty)
{
if (base.Count == 0)
{
namedElement.Name = GetDefaultElementName(namedElement);
}
else
{
namedElement.Name = GenerateUniqueName(namedElement);
}
}
else if (!IsUniqueName(namedElement.Name))
{
throw new ArgumentException(Utils.SRGetStr("ExceptionDuplicateNameFailed"));
}
}
public virtual object Clone()
{
NamedCollection namedCollection = (NamedCollection)GetType().GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0].Invoke(new object[2]
{
parent,
common
});
namedCollection.parent = parent;
namedCollection.common = common;
namedCollection.elementType = elementType;
IEnumerator enumerator = GetEnumerator();
try
{
while (enumerator.MoveNext())
{
NamedElement namedElement = (NamedElement)((ICloneable)enumerator.Current).Clone();
namedCollection.InnerList.Add(namedElement);
namedElement.collection = namedCollection;
}
return(namedCollection);
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
internal override void IsValidNameCheck(string name, NamedElement element)
{
base.IsValidNameCheck(name, element);
if (parent is ValueBase && ((ValueBase)parent).Name.Equals(name, StringComparison.Ordinal))
{
throw new NotSupportedException(Utils.SRGetStr("ExceptionListUniqueName", GetType().Name));
}
}
internal override void Notify(MessageType msg, NamedElement element, object param)
{
base.Notify(msg, element, param);
if (msg == MessageType.DataInvalidated)
{
((IValueConsumer)this).Refresh();
}
}
public void StartHotRegion(NamedElement obj)
{
IImageMapProvider imageMapProvider = obj as IImageMapProvider;
if (imageMapProvider != null)
{
RenderingObject.BeginSelection(imageMapProvider.GetHref(), imageMapProvider.GetToolTip());
}
}
internal NamedElement GetByNameCheck(string name)
{
NamedElement byName = GetByName(name);
if (byName == null)
{
throw new ArgumentException(Utils.SRGetStr("ExceptionElementNotFound", elementType.Name, name, GetType().Name));
}
return(byName);
}
internal virtual string GetElementNameFormat(NamedElement el)
{
string text = el.DefaultName;
if (text == string.Empty)
{
text = el.GetType().Name;
}
return(text + "{0}");
}
internal bool SetByName(string name, NamedElement element)
{
int index = GetIndex(name);
if (index != -1)
{
base.List[index] = element;
return(true);
}
return(false);
}
private void ConnectToParent(bool exact)
{
if (Common != null && !Common.GaugeCore.isInitializing)
{
if (parent == string.Empty)
{
parentSystem = null;
return;
}
Common.ObjectLinker.IsParentElementValid(this, this, exact);
parentSystem = Common.ObjectLinker.GetElement(parent);
}
}
internal virtual void IsValidNameCheck(string name, NamedElement element)
{
if (name == null || name == string.Empty)
{
throw new ArgumentException(Utils.SRGetStr("ExceptionEmptyNameFailed", elementType.Name));
}
NamedElement byName = GetByName(name);
if (byName != null && byName != element)
{
throw new NotSupportedException(Utils.SRGetStr("ExceptionDuplicateNameFailed"));
}
}
internal string GenerateUniqueName(NamedElement element)
{
string elementNameFormat = GetElementNameFormat(element);
for (int i = base.Count + 1; i < int.MaxValue; i++)
{
string text = string.Format(CultureInfo.InvariantCulture, elementNameFormat, i);
if (IsUniqueName(text))
{
return(text);
}
}
throw new ApplicationException(Utils.SRGetStr("ExceptionGenerateNameFailed"));
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList arrayList = new ArrayList();
if (context != null && context.Instance != null)
{
NamedElement namedElement = null;
if (context.Instance is NamedElement)
{
namedElement = (NamedElement)context.Instance;
}
if (namedElement != null && namedElement.Common != null)
{
arrayList = namedElement.Common.ObjectLinker.GetObjectNames(namedElement);
}
}
arrayList.Add("(none)");
return(new StandardValuesCollection(arrayList));
}
internal override void Notify(MessageType msg, NamedElement element, object param)
{
base.Notify(msg, element, param);
switch (msg)
{
case MessageType.NamedElementRemove:
if (parentSystem == element)
{
Parent = string.Empty;
}
break;
case MessageType.NamedElementRename:
if (parentSystem == element)
{
parent = element.GetNameAsParent((string)param);
}
break;
}
}
internal virtual void Notify(MessageType msg, NamedElement element, object param)
{
IEnumerator enumerator = GetEnumerator();
try
{
while (enumerator.MoveNext())
{
((NamedElement)enumerator.Current).Notify(msg, element, param);
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
internal virtual void PointerValueChanged(DataAttributes data)
{
double num = Math.Min(startValue, endValue);
double num2 = Math.Max(startValue, endValue);
if (Common == null)
{
return;
}
bool playbackMode = false;
if (((IValueConsumer)data).GetProvider() != null)
{
playbackMode = ((IValueConsumer)data).GetProvider().GetPlayBackMode();
}
NamedElement pointer = (NamedElement)data.Parent;
RangeDataState dataState = GetDataState(data);
double num3 = data.Value;
if (data.IsPercentBased)
{
num3 = data.GetValueInPercents();
}
if (!dataState.IsInRange && num3 >= num && num3 <= num2)
{
dataState.IsInRange = true;
OnValueRangeEnter(this, new ValueRangeEventArgs(num3, data.DateValueStamp, Name, playbackMode, pointer));
if (!(inRangeTimeout > 0.0))
{
dataState.IsTimerExceed = true;
}
}
if (dataState.IsInRange && (double.IsNaN(num3) || num3 < num || num3 > num2))
{
dataState.IsInRange = false;
dataState.IsTimerExceed = false;
OnValueRangeLeave(this, new ValueRangeEventArgs(num3, data.DateValueStamp, Name, playbackMode, pointer));
_ = inRangeTimeout;
_ = 0.0;
}
}
void ISelectable.DrawSelection(GaugeGraphics g, bool designTimeSelection)
{
Stack stack = new Stack();
for (NamedElement namedElement = ParentObject; namedElement != null; namedElement = (NamedElement)((IRenderable)namedElement).GetParentRenderable())
{
stack.Push(namedElement);
}
foreach (IRenderable item in stack)
{
g.CreateDrawRegion(item.GetBoundRect(g));
}
g.CreateDrawRegion(((IRenderable)this).GetBoundRect(g));
g.DrawSelection(g.GetAbsoluteRectangle(new RectangleF(0f, 0f, 100f, 100f)), designTimeSelection, Common.GaugeCore.SelectionBorderColor, Common.GaugeCore.SelectionMarkerColor);
g.RestoreDrawRegion();
foreach (IRenderable item2 in stack)
{
_ = item2;
g.RestoreDrawRegion();
}
}
internal override void Notify(MessageType msg, NamedElement element, object param)
{
base.Notify(msg, element, param);
if (msg != MessageType.NamedElementRemove)
{
return;
}
ArrayList arrayList = new ArrayList();
foreach (DataAttributes key in inRangeTable.Keys)
{
if (key.Parent == element)
{
arrayList.Add(key);
}
}
for (int i = 0; i < arrayList.Count; i++)
{
inRangeTable.Remove(arrayList[i]);
}
arrayList.Clear();
}
void ISelectable.DrawSelection(GaugeGraphics g, bool designTimeSelection)
{
Stack stack = new Stack();
for (NamedElement namedElement = base.ParentObject; namedElement != null; namedElement = (NamedElement)((IRenderable)namedElement).GetParentRenderable())
{
stack.Push(namedElement);
}
foreach (IRenderable item in stack)
{
g.CreateDrawRegion(item.GetBoundRect(g));
}
g.CreateDrawRegion(((IRenderable)this).GetBoundRect(g));
RectangleF frameRectangle = base.Frame.GetFrameRectangle(g);
g.DrawSelection(frameRectangle, -3f / g.Graphics.PageScale, designTimeSelection, Common.GaugeCore.SelectionBorderColor, Common.GaugeCore.SelectionMarkerColor);
g.RestoreDrawRegion();
foreach (IRenderable item2 in stack)
{
_ = item2;
g.RestoreDrawRegion();
}
}
public override StandardValuesCollection GetStandardValues(ITypeDescriptorContext context)
{
ArrayList arrayList = new ArrayList();
if (context != null && context.Instance != null)
{
NamedElement namedElement = null;
NamedCollection namedCollection = null;
if (context.Instance is NamedElement)
{
namedElement = (NamedElement)context.Instance;
}
if (context.Instance is IList && ((IList)context.Instance).Count > 0)
{
namedElement = (NamedElement)((IList)context.Instance)[0];
}
if (namedElement != null && namedElement.Common != null && namedElement.ParentElement != null)
{
if (namedElement.ParentElement is CircularGauge)
{
namedCollection = ((CircularGauge)namedElement.ParentElement).Scales;
}
if (namedElement.ParentElement is LinearGauge)
{
namedCollection = ((LinearGauge)namedElement.ParentElement).Scales;
}
}
if (namedCollection != null)
{
foreach (NamedElement item in namedCollection)
{
arrayList.Add(item.Name);
}
}
}
return(new StandardValuesCollection(arrayList));
}
void ISelectable.DrawSelection(GaugeGraphics g, bool designTimeSelection)
{
if (GetGauge() == null)
{
return;
}
Stack stack = new Stack();
for (NamedElement namedElement = GetGauge().ParentObject; namedElement != null; namedElement = (NamedElement)((IRenderable)namedElement).GetParentRenderable())
{
stack.Push(namedElement);
}
foreach (IRenderable item in stack)
{
g.CreateDrawRegion(item.GetBoundRect(g));
}
g.CreateDrawRegion(((IRenderable)GetGauge()).GetBoundRect(g));
SetDrawRegion(g);
Gap gap = new Gap(GetRadius());
gap.SetOffset(Placement.Cross, Width);
gap.SetBase();
if (MajorTickMark.Visible)
{
gap.SetOffsetBase(MajorTickMark.Placement, MajorTickMark.Length);
if (MajorTickMark.Placement == Placement.Outside)
{
gap.Outside = Math.Max(gap.Outside, MajorTickMark.DistanceFromScale + MajorTickMark.Length + Width / 2f);
gap.Inside = Math.Max(gap.Inside, 0f - MajorTickMark.DistanceFromScale);
}
else if (MajorTickMark.Placement == Placement.Cross)
{
gap.Outside = Math.Max(gap.Outside, 0f - MajorTickMark.DistanceFromScale + MajorTickMark.Length / 2f);
gap.Inside = Math.Max(gap.Inside, MajorTickMark.DistanceFromScale + MajorTickMark.Length / 2f);
}
else
{
gap.Outside = Math.Max(gap.Outside, 0f - MajorTickMark.DistanceFromScale);
gap.Inside = Math.Max(gap.Inside, MajorTickMark.DistanceFromScale + MajorTickMark.Length + Width / 2f);
}
}
if (MinorTickMark.Visible)
{
gap.SetOffsetBase(MinorTickMark.Placement, MinorTickMark.Length);
if (MinorTickMark.Placement == Placement.Outside)
{
gap.Outside = Math.Max(gap.Outside, MinorTickMark.DistanceFromScale + MinorTickMark.Length + Width / 2f);
gap.Inside = Math.Max(gap.Inside, 0f - MinorTickMark.DistanceFromScale);
}
else if (MinorTickMark.Placement == Placement.Cross)
{
gap.Outside = Math.Max(gap.Outside, 0f - MinorTickMark.DistanceFromScale + MinorTickMark.Length / 2f);
gap.Inside = Math.Max(gap.Inside, MinorTickMark.DistanceFromScale + MinorTickMark.Length / 2f);
}
else
{
gap.Outside = Math.Max(gap.Outside, 0f - MinorTickMark.DistanceFromScale);
gap.Inside = Math.Max(gap.Inside, MinorTickMark.DistanceFromScale + MinorTickMark.Length + Width / 2f);
}
}
if (LabelStyle.Visible)
{
if (LabelStyle.Placement == Placement.Outside)
{
gap.Outside = Math.Max(gap.Outside, LabelStyle.DistanceFromScale + (float)LabelStyle.Font.Height + Width / 2f);
gap.Inside = Math.Max(gap.Inside, 0f - LabelStyle.DistanceFromScale);
}
else if (LabelStyle.Placement == Placement.Cross)
{
gap.Outside = Math.Max(gap.Outside, 0f - LabelStyle.DistanceFromScale + (float)LabelStyle.Font.Height / 2f);
gap.Inside = Math.Max(gap.Inside, LabelStyle.DistanceFromScale + (float)LabelStyle.Font.Height / 2f);
}
else
{
gap.Outside = Math.Max(gap.Outside, 0f - LabelStyle.DistanceFromScale);
gap.Inside = Math.Max(gap.Inside, LabelStyle.DistanceFromScale + (float)LabelStyle.Font.Height + Width / 2f);
}
}
float angularMargin = 4f;
float num = 5f;
using (GraphicsPath graphicsPath = GetBarPath(gap.Inside + num, gap.Outside + num, angularMargin))
{
if (graphicsPath != null)
{
PointF[] selectionMarkers = GetSelectionMarkers(g, gap.Inside + num, gap.Outside + num, angularMargin);
g.DrawRadialSelection(g, graphicsPath, selectionMarkers, designTimeSelection, Common.GaugeCore.SelectionBorderColor, Common.GaugeCore.SelectionMarkerColor);
}
}
g.RestoreDrawRegion();
g.RestoreDrawRegion();
foreach (IRenderable item2 in stack)
{
_ = item2;
g.RestoreDrawRegion();
}
}
internal LinearGaugeCollection(NamedElement parent, CommonElements common)
: base(parent, common)
{
elementType = typeof(LinearGauge);
}
internal override string GetElementNameFormat(NamedElement el)
{
return("Gauge{0}");
}
internal GaugeLabelCollection(NamedElement parent, CommonElements common)
: base(parent, common)
{
elementType = typeof(GaugeLabel);
}
