/// <summary>
/// Gets all object aliases
/// </summary>
/// <param name="baseObject">Base object</param>
/// <param name="o">object</param>
/// <param name="list">List of aliases</param>
/// <param name="type">Type of alias</param>
public static void GetAllObjectAliases(IAssociatedObject baseObject, object o, List <string> list, object type)
{
IAssociatedObject ass = o as IAssociatedObject;
IObjectLabel l = ass.Object as IObjectLabel;
GetAllAliases(baseObject, l, list, type);
}
/// <summary>
/// Checks whether str has prefix of component name
/// </summary>
/// <param name="ao">Relative object</param>
/// <param name="obj">Object</param>
/// <param name="str">String to check</param>
/// <returns>The component and null otherwise</returns>
static public INamedComponent PrefixComponent(IAssociatedObject ao, object obj, string str)
{
if (!(obj is IAssociatedObject))
{
return(null);
}
IAssociatedObject ass = obj as IAssociatedObject;
if (!(ass.Object is INamedComponent))
{
return(null);
}
INamedComponent c = ass.Object as INamedComponent;
int n = str.LastIndexOf(".");
string s = str.Substring(0, n);
if (s.Equals(ao.GetRelativeName(ass)))
{
return(c);
}
else
{
return(null);
}
}
private void GetObjectsPrivate(IAssociatedObject ao, IList <ICategoryObject> objects, IList <ICategoryArrow> arrows)
{
{
if (ao is ICategoryObject)
{
objects.Add(ao as ICategoryObject);
}
if (ao is ICategoryArrow)
{
arrows.Add(ao as ICategoryArrow);
}
if (ao is IChildrenObject)
{
IChildrenObject co = ao as IChildrenObject;
IAssociatedObject[] ass = co.Children;
if (ass != null)
{
foreach (IAssociatedObject asso in ass)
{
if (asso != null)
{
GetObjects(asso, objects, arrows);
}
}
}
}
}
}
private FormFieldShape(FieldConsumer3D consumer)
: this()
{
IAssociatedObject ao = consumer as IAssociatedObject;
Set(ao.Object as IObjectLabel);
}
/// <summary>
/// Gets interface
/// </summary>
/// <typeparam name="T">Type</typeparam>
/// <param name="obj">Object</param>
/// <returns>Interface</returns>
public static T GetInterface <T>(this IAssociatedObject obj) where T : class
{
if (obj is T)
{
return(obj as T);
}
if (obj is IChildrenObject)
{
IChildrenObject co = obj as IChildrenObject;
IAssociatedObject[] ch = co.Children;
if (ch != null)
{
foreach (IAssociatedObject ob in ch)
{
if (ob != null)
{
T o = GetInterface <T>(ob);
if (o != null)
{
return(o);
}
}
}
}
}
return(null);
}
/// <summary>
/// The operation that performs after arrows setting
/// </summary>
public void PostSetArrow()
{
//aliases = new IAliasName[aliasNames.Count];
int i = 0;
List <IAliasName> lan = new List <IAliasName>();
foreach (string s in aliasNames)
{
IAliasName[] arr = this.FindAllAliasName(s, false);
lan.AddRange(arr);
}
aliases = lan.ToArray();
int nmea = 0;
for (i = 0; i < measurementsNames.Count; i++)
{
string name = measurementsNames[i] as string;
int n = name.LastIndexOf(".");
string m = name.Substring(0, n);
foreach (IMeasurements meas in measurements)
{
IAssociatedObject ao = meas as IAssociatedObject;
//INamedComponent nc = ao.Object as INamedComponent;
if (!m.Equals(this.GetRelativeName(ao)))
{
continue;
}
string suff = name.Substring(n + 1);
for (int j = 0; j < meas.Count; j++)
{
IMeasurement mea = meas[j];
if (!mea.Name.Equals(suff))
{
continue;
}
measurementsDitcionary[nmea] = mea;
++nmea;
}
}
}
for (i = 0; i < selectionNames.Count; i++)
{
string sn = selectionNames[i] as string;
foreach (IStructuredSelectionCollection s in selections)
{
IAssociatedObject ao = s as IAssociatedObject;
//INamedComponent nc = ao.Object as INamedComponent;
string name = this.GetRelativeName(ao); //nc.Name;
for (int j = 0; j < s.Count; j++)
{
if (!sn.Equals(name + "." + s[j].Name))
{
continue;
}
selectedSelections[i] = s[j];
}
}
}
Init();
}
private void Process(List <object> l, List <RelativeMeasurements> rm, IPosition position,
List <object> ladd, int priority, string reason)
{
Action <object> act = (object obj) => { };
if (position == null)
{
return;
}
IDataConsumer c = position.GetLabelObject <IDataConsumer>();
if (c != null)
{
if (c is IAssociatedObject)
{
IAssociatedObject ao = c as IAssociatedObject;
object o = ao.Object;
if (!ladd.Contains(o))
{
ladd.Add(o);
}
}
CreateDataConsumerCollection(c, ladd, act, priority, reason);
}
Process(l, rm, position.Parent, ladd, priority, reason);
}
/// <summary>
/// Creates transformer of associated object
/// </summary>
/// <param name="tr">Initial transformer</param>
/// <param name="obj">The object</param>
/// <returns>The transformer</returns>
static public Action <double[]> CreateTransformer(Action <double[]> tr, IAssociatedObject obj)
{
if (!(obj is IChildrenObject))
{
return(tr);
}
IChildrenObject ch = obj as IChildrenObject;
IAssociatedObject[] ao = ch.Children;
List <Action <double[]> > l = new List <Action <double[]> >();
foreach (IAssociatedObject ob in ao)
{
if (!(ob is IVectorTransformer))
{
continue;
}
IVectorTransformer t = ob as IVectorTransformer;
Action <double[]> tv = t.Transformer;
if (tv != null)
{
l.Add(tv);
}
}
if (l.Count == 0)
{
return(tr);
}
Action <double[]> trv = Sum(l.ToArray());
Action <double[]> tvr = tr + trv;
return(tvr);
}
/// <summary>
/// Gets additional feature
/// </summary>
/// <typeparam name="T">Feature type</typeparam>
/// <param name="factory">User interface factory</param>
/// <param name="obj">Obj</param>
/// <returns>Feature</returns>
static public object GetAdditionalFeature <T>(this IUIFactory factory, IAssociatedObject obj)
{
IUIFactory f = factory;
IUIFactory p = factory.Parent;
if (p != null)
{
f = p;
}
if (obj == null)
{
return(null);
}
if (obj is T)
{
return(f.GetAdditionalFeature <T>((T)obj));
}
if (obj is IChildrenObject) // If object has children
{
IAssociatedObject[] ao = (obj as IChildrenObject).Children;
foreach (IAssociatedObject aa in ao) // Searches additional feature among children
{
object ob = GetAdditionalFeature <T>(f, aa);
if (ob != null)
{
return(ob);
}
}
}
return(null);
}
/// <summary>
/// Sets measures to consumer
/// </summary>
/// <param name="consumer">The consumer</param>
/// <param name="measures">Names of measures</param>
/// <param name="measuresData">Measures</param>
public static void SetMeasurements(IDataConsumer consumer, List <string> measures, List <IMeasurement> measuresData)
{
measuresData.Clear();
IAssociatedObject ac = consumer as IAssociatedObject;
foreach (string ms in measures)
{
for (int i = 0; i < consumer.Count; i++)
{
IMeasurements m = consumer[i];
IAssociatedObject ao = m as IAssociatedObject;
string on = ac.GetRelativeName(ao) + ".";
for (int j = 0; j < m.Count; j++)
{
IMeasurement mea = m[j];
string s = on + mea.Name;
if (s.Equals(ms))
{
measuresData.Add(mea);
}
}
}
}
}
/// <summary>
/// Gets objects and arrows of associated object
/// </summary>
/// <param name="ao">The associated object</param>
/// <param name="objects">Objects</param>
/// <param name="arrows">Arrows</param>
protected virtual void GetObjects(IAssociatedObject ao, IList <ICategoryObject> objects, IList <ICategoryArrow> arrows)
{
if (ao is IObjectContainer)
{
IObjectContainer oc = ao as IObjectContainer;
IDesktop d = oc.Desktop;
IEnumerable <object> c = d.AllComponents;
foreach (object o in c)
{
if (o is IObjectLabel)
{
IObjectLabel ol = o as IObjectLabel;
GetObjects(ol.Object, objects, arrows);
}
if (o is IArrowLabel)
{
IArrowLabel al = o as IArrowLabel;
GetObjects(al.Arrow, objects, arrows);
}
}
}
else
{
GetObjectsPrivate(ao, objects, arrows);
}
}
/// <summary>
/// Finds measure by name
/// </summary>
/// <param name="name">Measure name</param>
/// <returns>The measure</returns>
protected IMeasurement Find(string name)
{
int n = name.LastIndexOf(".");
if (n < 0)
{
return(null);
}
string cn = name.Substring(0, n);
string suff = name.Substring(n + 1);
for (int i = 0; i < mea.Count; i++)
{
IMeasurements m = mea[i];
IAssociatedObject ao = m as IAssociatedObject;
string na = this.GetRelativeName(ao);
if (cn.Equals(na))
{
for (int j = 0; j < m.Count; j++)
{
IMeasurement ms = m[j];
if (suff.Equals(ms.Name))
{
return(ms);
}
}
}
}
return(null);
}
/// <summary>
/// Creates collection of components
/// </summary>
/// <param name="consumer">Data consumer</param>
/// <param name="list">List of objects</param>
/// <param name="action">Additional acton</param>
/// <param name="priority">Priority</param>
/// <param name="reason">Reason</param>
/// <returns>Collection of components</returns>
protected void CreateDataConsumerCollection(IDataConsumer consumer, List <object> list,
Action <object> action, int priority, string reason)
{
IList <object> ll = consumer.GetDependentObjects();
foreach (object o in ll)
{
if (o is INamedComponent)
{
action(o);
if (!list.Contains(o))
{
list.Add(o);
}
continue;
}
if (o is IAssociatedObject)
{
IAssociatedObject ao = o as IAssociatedObject;
object ob = ao.Object;
action(ob);
if (ob is INamedComponent)
{
if (!list.Contains(ob))
{
list.Add(ob);
}
continue;
}
}
}
}
/// <summary>
/// Creates Mesurements
/// </summary>
protected void CreateMesurements()
{
isLoaded = true;
measurements.Clear();
Dictionary<string, IMeasurement> d = this.GetAllMeasurementsByName((double)0);
List<string> l = new List<string>(d.Keys);
l.Sort();
medians = new double[l.Count];
condition = null;
IAssociatedObject ass = this;
if (ass.Object != null)
{
condition = this.FindMeasurement(conditionName, true);
}
Dictionary<string, IMeasurement> dp = new Dictionary<string, IMeasurement>();
int i = 0;
list = new List<double>[l.Count];
input = new IMeasurement[l.Count];
foreach (string key in d.Keys)
{
int[] p = new int[] { i };
string k = key.Replace('.', '_').Replace('/', '_');
IMeasurement m = new Measurement(
() =>
{
return medians[p[0]];
},
k);
measurements.Add(m);
list[i] = new List<double>();
input[i] = d[key];
++i;
}
}
/// <summary>
/// Accepts arguments
/// </summary>
private void AcceptArguments()
{
foreach (IMeasurements measurements in this.measurements)
{
IAssociatedObject cont = measurements as IAssociatedObject;
INamedComponent c = cont.Object as INamedComponent;
string name = c.Name;
for (int i = 0; i < measurements.Count; i++)
{
IMeasurement measure = measurements[i];
string p = name + "." + measure.Name;
for (int j = 0; j < 2; j++)
{
if (arguments[j].Equals(p))
{
input[j] = measure;
break;
}
}
}
}
hasDerivation = true;
for (int i = 0; i < input.Length; i++)
{
IDerivation der = input[i] as IDerivation;
if (der == null)
{
hasDerivation = false;
break;
}
}
}
/// <summary>
/// Gets Differential Equation Solver from object
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override IDifferentialEquationSolver GetDifferentialEquationSolver(object obj)
{
if (obj is IAssociatedObject)
{
IAssociatedObject ao = obj as IAssociatedObject;
AggregableWrapper agg =
ao.GetObject <AggregableWrapper>();
if (agg != null)
{
if (agg.Aggregate.Parent == null)
{
return(GetEquation(agg));
}
}
}
if (obj is DataPerformer.Portable.MeasurementsWrapper)
{
DataPerformer.Portable.MeasurementsWrapper m = obj as DataPerformer.Portable.MeasurementsWrapper;
for (int i = 0; i < m.Count; i++)
{
if (m[i] is AggregableWrapper)
{
AggregableWrapper agg =
m[i] as AggregableWrapper;
if (agg.Aggregate.Parent == null)
{
return(GetEquation(agg));
}
}
}
}
return(null);
}
internal PanelConsumer(IDataConsumer consumer, Dictionary <string, string> selected, object vars)
{
this.consumer = consumer;
obj = consumer as IAssociatedObject;
this.selected = selected;
this.vars = vars;
Init();
}
IPhysicalField IFieldFactory.GetField(IFieldConsumer consumer, object obj)
{
if (obj is IAssociatedObject)
{
IAssociatedObject ao = obj as IAssociatedObject;
object o = ao.GetObject <PhysicalField.Interfaces.IPhysicalField>();
}
return(null);
}
IFieldConsumer IFieldFactory.GetConsumer(object obj)
{
if (obj is IAssociatedObject)
{
IAssociatedObject ao = obj as IAssociatedObject;
return(ao.GetObject <IFieldConsumer>());
}
return(null);
}
/// <summary>
/// Gets names of providers
/// </summary>
/// <param name="consumer">Consumer</param>
/// <returns>Names of providers</returns>
public static IEnumerable <string> GetProviders(this IBitmapConsumer consumer)
{
IAssociatedObject ao = consumer as IAssociatedObject;
foreach (IBitmapProvider p in consumer.Providers)
{
yield return(ao.GetRelativeName(p as IAssociatedObject));
}
}
IAggregableMechanicalObject IAggregableMechanicalFactory.GetObject(object obj)
{
if (obj is IAssociatedObject)
{
IAssociatedObject ao = obj as IAssociatedObject;
return(ao.GetObject <IAggregableMechanicalObject>());
}
return(null);
}
/// <summary>
/// Gets all measurements of one dimension real array
/// </summary>
/// <param name="ao">Associated object</param>
/// <returns>Names of measurements</returns>
public static string[] GetOneDimensionRealArrays(this IAssociatedObject ao)
{
INamedComponent nc = null;
if (ao is INamedComponent)
{
nc = ao as INamedComponent;
}
else
{
nc = ao.Object as INamedComponent;
}
IDesktop desktop = nc.Root.Desktop;
if (desktop == null)
{
desktop = nc.Desktop;
}
if (desktop == null)
{
return(new string[0]);
}
List <string> l = new List <string>();
desktop.ForEach <IMeasurements>((IMeasurements m) =>
{
IAssociatedObject aob = m as IAssociatedObject;
INamedComponent ncm = aob.Object as INamedComponent;
string nm = ncm.GetName(desktop);
for (int i = 0; i < m.Count; i++)
{
IMeasurement mea = m[i];
if (mea == null)
{
continue;
}
object t = mea.Type;
if (!(t is ArrayReturnType))
{
continue;
}
ArrayReturnType art = t as ArrayReturnType;
Double a = 0;
if (!art.ElementType.Equals(a))
{
continue;
}
if (art.Dimension.Length != 1)
{
continue;
}
l.Add(nm + "." + mea.Name);
}
});
return(l.ToArray());
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="length">The length</param>
public FormLength(ILength length)
: this()
{
this.length = length;
IAssociatedObject ao = length as IAssociatedObject;
label = ao.Object as IObjectLabel;
UpdateFormUI();
textBoxLength.Text = length.Length + "";
}
/// <summary>
/// Gets associated control
/// </summary>
/// <param name="obj">Prototype</param>
/// <returns>The control</returns>
public static Control GetControl(this IAssociatedObject obj)
{
INamedComponent nc = obj.GetNamedComponent();
if (nc is Control)
{
return(nc as Control);
}
return(null);
}
/// <summary>
/// Try to get object of predefined type
/// </summary>
/// <typeparam name="T">The type</typeparam>
/// <param name="obj">The prototype</param>
/// <param name="message">The exception message</param>
/// <returns>The object of predefined type</returns>
public static T GetObject <T>(this IAssociatedObject obj, string message) where T : class
{
T a = GetObject <T>(obj);
if (a != null)
{
return(a);
}
throw new Exception(message);
}
public FormDeformed(IPosition p, IVisible v)
: this()
{
userControlDeformed.Set(p, v);
IAssociatedObject ao = p as IAssociatedObject;
label = ao.Object as IObjectLabel;
UpdateFormUI();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="obj">Base object</param>
/// <param name="measurements">Measurements</param>
/// <param name="vars">Variables</param>
/// <param name="selected">Selected measurements</param>
public PanelMeasurements(IAssociatedObject obj,
IMeasurements measurements, object vars, Dictionary <string, string> selected)
{
this.obj = obj;
this.measurements = measurements;
this.selected = selected;
init();
Vars = vars;
Selected = selected;
}
/// <summary>
/// The post load operation
/// </summary>
public override bool PostLoad()
{
//return base.PostLoad();
if (!isLoaded)
{
return(false);
}
if (isPostLoaded)
{
return(true);
}
desktop.SetObjectNames();
PureObjectLabel.SetLabels(desktop.Objects);
PureArrowLabel.SetLabels(desktop.Arrows);
IEnumerable <IArrowLabel> arrows = desktop.Arrows;
// SetParents(desktop);
IEnumerable <object> components = desktop.Components;
foreach (INamedComponent nc in components)
{
nc.Desktop = desktop;
//nc.Parent = Object as INamedComponent;
if (nc is IObjectLabel)
{
IObjectLabel ol = nc as IObjectLabel;
if (ol.Object is IObjectContainer)
{
IObjectContainer oc = ol.Object as IObjectContainer;
bool b = oc.PostLoad();
if (!b)
{
return(false);
}
}
}
}
foreach (IArrowLabel arrow in arrows)
{
arrow.Desktop = desktop;
ICategoryObject source = arrow.Arrow.Source;
if (source == null)
{
arrow.Arrow.Source = arrow.Source.Object;
}
ICategoryObject target = arrow.Arrow.Target;
if (target == null)
{
arrow.Arrow.Target = arrow.Target.Object;
}
IAssociatedObject ass = arrow.Arrow as IAssociatedObject;
ass.Object = arrow;
}
return(true);
}
/// <summary>
/// Finds object
/// </summary>
/// <typeparam name="T">Object type</typeparam>
/// <param name="obj">Object</param>
/// <returns>Found object</returns>
public static T Find <T>(this IAssociatedObject obj) where T : class
{
if (findObject != null)
{
object f = findObject[typeof(T), obj];
if (f != null)
{
return(f as T);
}
}
return(null);
}
/// <summary>
/// Post operation
/// </summary>
public override void Post()
{
uc.Writer = writer;
IAssociatedObject ao = this.Object;
object o = ao.Object;
if (o is UserControlLabel)
{
UserControlLabel ucl = o as UserControlLabel;
ucl.SetImage(Properties.Resources.SeverEvent.ToBitmap());
}
}
