private void Load()
{
// Check if the classes and properties have ben loaded
//while (!RequirementViewModelLocator.IsLoaded());
using (EDBEntities eDB = new EDBEntities())
{
foreach (tblObjectRequirement Rec in (from o in eDB.tblObjectRequirements where (o.Project_ID == Globals.Project_ID) select o))
{
ObjectRequirementModel objectRequirementItem = new ObjectRequirementModel
{
Project_ID = Rec.Project_ID,
Object_ID = Rec.Object_ID,
Requirement_ID = Rec.Requirement_ID,
RequirementType = Rec.RequirementType,
PreFATOk = Rec.PreFATOk,
FATOk = Rec.FATOk,
FATBy = Rec.FATBy,
FATDate = Rec.FATDate,
SATOk = Rec.SATOk,
SATBy = Rec.SATBy,
SATDate = Rec.SATDate,
IsChanged = false,
IsNew = false,
IsDeleted = false,
ChildRequirements = new TD.ObservableItemCollection <ObjectRequirementModel>()
};
var requirementItem = RequirementViewModelLocator.GetRequirementVM().GetRequirement(objectRequirementItem.Requirement_ID, null);
if (requirementItem != null)
{
objectRequirementItem.ArticleNo = requirementItem.ArticleNo;
objectRequirementItem.ArticleHeader = requirementItem.ArticleHeader;
objectRequirementItem.RequirementType_ID = requirementItem.RequirementType_ID;
foreach (var childItem in requirementItem.ChildRequirements)
{
ObjectRequirementModel item = new ObjectRequirementModel
{
Project_ID = childItem.Project_ID,
Object_ID = objectRequirementItem.Object_ID,
Requirement_ID = childItem.ID,
ArticleNo = childItem.ArticleNo,
ArticleHeader = childItem.ArticleHeader,
RequirementType = "Requirement",
RequirementType_ID = childItem.RequirementType_ID,
ChildRequirements = new TD.ObservableItemCollection <ObjectRequirementModel>()
};
objectRequirementItem.ChildRequirements.Add(item);
}
ObjectRequirements.Add(objectRequirementItem);
}
}
}
}
public void AssociateWithObject(TreeListViewRow destination)
{
try
{
// Associate all selected objects
foreach (var objectItem in ObjectViewModelLocator.GetObjectVM().SelectedItems)
{
// With all selected requirements (m:n)
foreach (var requirementItem in RequirementViewModelLocator.GetRequirementVM().SelectedItems)
{
ObjectRequirementModel objectRequirementItem = new ObjectRequirementModel
{
IsNew = true,
IsChanged = false,
IsDeleted = false,
Project_ID = Globals.Project_ID,
Object_ID = objectItem.ID,
Requirement_ID = requirementItem.ID,
RequirementType_ID = requirementItem.RequirementType_ID,
ArticleNo = requirementItem.ArticleNo,
ArticleHeader = requirementItem.ArticleHeader,
//RequirementType = Globals.DraggedItem.Type,
ChildRequirements = new TD.ObservableItemCollection <ObjectRequirementModel>(),
};
foreach (var childItem in requirementItem.ChildRequirements)
{
ObjectRequirementModel objectRequirementChildItem = new ObjectRequirementModel
{
IsNew = true,
IsChanged = false,
IsDeleted = false,
Project_ID = Globals.Project_ID,
Object_ID = objectRequirementItem.Object_ID,
Requirement_ID = childItem.ID,
RequirementType_ID = childItem.RequirementType_ID,
//objectFunctionalityChildItem.FunctionParent_ID = childItem.Parent_ID;
ArticleNo = childItem.ArticleNo,
ArticleHeader = childItem.ArticleHeader,
ChildRequirements = new TD.ObservableItemCollection <ObjectRequirementModel>()
};
objectRequirementItem.ChildRequirements.Add(objectRequirementChildItem);
}
;
ObjectRequirements.Add(objectRequirementItem);
}
}
}
catch (Exception ex)
{
RadWindow.Alert(ex.Message);
}
}
private void OnLoadInBackgroundCompleted(object sender, RunWorkerCompletedEventArgs e)
{
var backgroundWorker = sender as BackgroundWorker;
//Dispose events
backgroundWorker.DoWork -= this.OnLoadInBackground;
backgroundWorker.RunWorkerCompleted -= this.OnLoadInBackgroundCompleted;
// Create a collection that holds the functionalities of the selected object and add the filter event handler
// Note: the FilteredObjectFunctionalities collection is updated every time a new object is selected in the object tree
// (triggered in the setter of the SelectedItem property)
FilteredObjectRequirements = new CollectionViewSource {
Source = ObjectRequirements
};
FilteredObjectRequirements.Filter += ObjectFilter;
ObjectRequirements.ResumeNotifications();
}
// Initialize
void Start()
{
// Initialize property object by defining a new one
if (propertyObject == null)
{
Type typeComponent = objectComponent.GetType();
const BindingFlags flags = /*BindingFlags.NonPublic | */ BindingFlags.DeclaredOnly | BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static;
PropertyInfo[] properties = typeComponent.GetProperties(flags);
if (properties.Length > _generalIndex)
{
propertyObject = properties[_generalIndex];
}
}
// Initialize methods object by defining a new one
if (methodObject == null)
{
Type typeComponent = objectComponent.GetType();
const BindingFlags flags = /*BindingFlags.NonPublic | */ BindingFlags.DeclaredOnly | BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static;
MethodInfo[] methods = typeComponent.GetMethods(flags);
if (methods.Length > _generalIndex)
{
methodObject = methods[_generalIndex];
}
}
requirements = new ObjectRequirements();
// this is for blendshapes
GameObject objectTemp = this.gameObject;
meshTemp = objectTemp.GetComponent <SkinnedMeshRenderer>();
if (meshTemp != null)
{
Mesh mesh = GetComponent <SkinnedMeshRenderer>().sharedMesh;
if (_extra + 1 > mesh.blendShapeCount)
{
_extra = 0; // verify if we have enought blenshapes
}
}
}
private void CollissonCheck(Collision collision)
{
ObjectRequirements requirements = collision.transform.GetComponent <ObjectRequirements>();
if (requirements != null)
{
Physics.IgnoreCollision(collision.transform.GetComponent <BoxCollider>(), this.GetComponent <BoxCollider>(), requirements.IgnoreColissionAllowed(this));
Physics.IgnoreCollision(collision.transform.GetComponent <MeshCollider>(), this.GetComponent <BoxCollider>(), requirements.IgnoreColissionAllowed(this));
}
else
{
foreach (Vector3 direction in new[] { Vector3.forward, Vector3.back, Vector3.left, Vector3.right })
{
RaycastHit hit;
if (Physics.Raycast(this.transform.position, transform.TransformDirection(direction), out hit, 0.1f))
{
inputs = new bool[inputs.Length];
}
}
}
}
// Initialization
void Start()
{
if (propertyObject == null)
{
Type typeComponent = objectComponent.GetType();
const BindingFlags flags = /*BindingFlags.NonPublic | */ BindingFlags.DeclaredOnly | BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static;
PropertyInfo[] properties = typeComponent.GetProperties(flags);
if (properties.Length > _generalIndex)
{
propertyObject = properties[_generalIndex];
oldPropertyObject = propertyObject.GetValue(objectComponent, null);
}
}
if (methodObject == null)
{
Type typeComponent = objectComponent.GetType();
const BindingFlags flags = /*BindingFlags.NonPublic | */ BindingFlags.DeclaredOnly | BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static;
MethodInfo[] methods = typeComponent.GetMethods(flags);
if (methods.Length > _generalIndex)
{
methodObject = methods[_generalIndex];
}
// print (" This GameObject="+this.name+" | component=" + objectComponent+" | type="+typeComponent+" | prop="+propertyObject);
}
handler = FindObjectOfType(typeof(OSCManager)) as OSCManager;
requirements = new ObjectRequirements();
}
/// <summary>
/// Initialization
/// </summary>
void Start()
{
typeComponent = objectComponent.GetType();
oscAddress.Clear(); // cleaning the address list
OSC[] instancesOSC;
instancesOSC = FindObjectsOfType(typeof(OSC)) as OSC[];
GameObject oscGameobject;
oscGameobject = this.gameObject;
// Should remove this when _remoteString = true
// the issue is probably in Start() _remotestring is false, thus, transfer this to update() with a trigger
if (instancesOSC.Length > 0)
{
if (RCPortInPort != null)
{
foreach (OSC item in instancesOSC)
{
if (item.getPortIN() == RCPortInPort.getPortIN())
{
oscGameobject = item.gameObject;
}
}
oscReference = oscGameobject.GetComponent <OSC> ();
oscReference.SetAddressHandler(address, OnReceive);
oscReference.SetAllMessageHandler(OnReceiveAll);
}
}
else
{
if ((FindObjectsOfType(typeof(RemoteStrings)) as RemoteStrings[]).Length < 1)
{
Debug.Log("NO OSC or RemoteString!!! You have to drag a OSC behavior or RemoteString to initalize the plugin");
}
}
// Initialize property object by defining a new one
if (propertyObject == null)
{
Type typeComponent = objectComponent.GetType();
const BindingFlags flags = /*BindingFlags.NonPublic | */ BindingFlags.DeclaredOnly | BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static;
PropertyInfo[] properties = typeComponent.GetProperties(flags);
if (properties.Length > _generalIndex)
{
propertyObject = properties [_generalIndex];
}
}
// Initialize methods object by defining a new one
if (methodObject == null)
{
Type typeComponent = objectComponent.GetType();
const BindingFlags flags = /*BindingFlags.NonPublic | */ BindingFlags.DeclaredOnly | BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static;
MethodInfo[] methods = typeComponent.GetMethods(flags);
if (methods.Length > _generalIndex)
{
methodObject = methods [_generalIndex];
}
}
requirements = new ObjectRequirements();
// this is for blendshapes
GameObject objectTemp = this.gameObject;
meshTemp = objectTemp.GetComponent <SkinnedMeshRenderer> ();
if (meshTemp != null)
{
Mesh mesh = GetComponent <SkinnedMeshRenderer> ().sharedMesh;
if (_extra + 1 > mesh.blendShapeCount)
{
_extra = 0; // verify if we have enought blenshapes
}
}
localType = getTypeArguments();
}
public void Refresh()
{
ObjectRequirements.Clear();
Load();
FilteredObjectRequirements.View.Refresh();
}
private void OnLoadInBackground(object sender, DoWorkEventArgs e)
{
ObjectRequirements.SuspendNotifications();
TypeViewModelLocator.GetTypeVM();
Load();
}
/// <summary>
/// Initialization
/// </summary>
void Start()
{
if (propertyObject == null)
{
Type typeComponent = objectComponent.GetType();
const BindingFlags flags = /*BindingFlags.NonPublic | */ BindingFlags.DeclaredOnly | BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static;
PropertyInfo[] properties = typeComponent.GetProperties(flags);
if (properties.Length > _generalIndex)
{
propertyObject = properties[_generalIndex];
oldPropertyObject = propertyObject.GetValue(objectComponent, null);
}
}
if (methodObject == null)
{
Type typeComponent = objectComponent.GetType();
const BindingFlags flags = /*BindingFlags.NonPublic | */ BindingFlags.DeclaredOnly | BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static;
MethodInfo[] methods = typeComponent.GetMethods(flags);
if (methods.Length > _generalIndex)
{
methodObject = methods[_generalIndex];
}
}
if (fieldObject == null)
{
Type typeComponent = objectComponent.GetType();
const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.DeclaredOnly | BindingFlags.Public |
BindingFlags.Instance | BindingFlags.Static;
FieldInfo[] fields = typeComponent.GetFields(flags);
if (fields.Length > _generalIndex)
{
fieldObject = fields[_generalIndex];
}
}
OSC[] instancesOSC;
instancesOSC = FindObjectsOfType(typeof(OSC)) as OSC[];
GameObject oscGameobject;
oscGameobject = this.gameObject;
if (instancesOSC.Length > 0)
{
//i = 0;
foreach (OSC item in instancesOSC)
{
if ((OSCtransmitPort != null))
{
if (item.getPortOUT() == OSCtransmitPort.getPortOUT())
{
oscGameobject = item.gameObject;
oscReference = oscGameobject.GetComponent <OSC> ();
}
}
}
}
else
{
Debug.Log("NO OSC!!! You have to drag a OSC behavior to initalize the plugin");
}
requirements = new ObjectRequirements();
}
