public void Deserialize(NetworkManager networkManager, ElementDataBase elementData, UIBehaviour element)
{
ButtonData buttonData = elementData as ButtonData;
Button buttonElement = element as Button;
if (buttonElement)
{
ColorBlock colorBlock = buttonElement.colors;
colorBlock.normalColor = buttonData.normalColor.Deserialize();
buttonElement.colors = colorBlock;
if (networkManager)
{
buttonElement.onClick.RemoveAllListeners();
buttonElement.onClick.AddListener(() =>
{
InputMessage inputMessage = new InputMessage(InputMessageType.Button, buttonData.objectID);
networkManager.SendMessageToServer(inputMessage.Serialize());
if (AppSettings.Instance.Vibrate)
{
Handheld.Vibrate();
}
});
}
}
}
private void Serialize(ObjectData objectData, GameObject go, bool isRoot)
{
UIBehaviour[] layoutElements = go.GetComponents <UIBehaviour>();
objectData.Name = go.name;
objectData.ID = go.GetInstanceID();
foreach (UIBehaviour layoutElement in layoutElements)
{
ILayoutSerializer layoutSerializer = UIMirrorManager.Instance.GetLayoutSerializer(layoutElement.GetType());
if (layoutSerializer != null)
{
ElementDataBase elementData = layoutSerializer.Serialize(layoutElement as UIBehaviour);
objectData.elementsData.Add(elementData);
}
}
objectData.transformData = UIMirrorManager.Instance.TransformSerializer.Serialize(go.GetComponent <RectTransform>());
foreach (Transform child in go.transform)
{
ObjectData childData = new ObjectData();
Serialize(childData, child.gameObject, false);
objectData.childrenData.Add(childData);
}
}
/// <summary>
/// Creates new instance of user class wich represents a structure element.
/// </summary>
/// <param name="elementDataBase">Instance of base class for the element.</param>
/// <returns>New instance of user implementation of element class derived from cref="ElementDataBase".</returns>
public ElementDataBase CreateElementData(ElementDataBase elementDataBase)
{
switch (elementDataBase.Material)
{
case StructuralAssetClass.Concrete:
switch (elementDataBase.Category)
{
default:
break;
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
return(new ColumnElement(elementDataBase));
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
return(new BeamElement(elementDataBase));
/// <structural_toolkit_2015>
case Autodesk.Revit.DB.BuiltInCategory.OST_FloorAnalytical:
return(new FloorElement(elementDataBase));
case Autodesk.Revit.DB.BuiltInCategory.OST_FoundationSlabAnalytical:
return(new FloorElement(elementDataBase));
case Autodesk.Revit.DB.BuiltInCategory.OST_WallAnalytical:
return(new WallElement(elementDataBase));
/// </structural_toolkit_2015>
}
break;
case StructuralAssetClass.Metal:
break;
}
return(elementDataBase);
}
public void Deserialize(NetworkManager networkManager, ElementDataBase elementData, UIBehaviour element)
{
TextMeshProData textData = elementData as TextMeshProData;
TextMeshProUGUI textElement = element as TextMeshProUGUI;
if (textElement)
{
textElement.text = textData.text;
textElement.fontSize = textData.fontSize;
textElement.color = textData.colorData.Deserialize();
textElement.alignment = textData.alignment;
}
}
/// <summary>
/// Gives possibility to write data to Revit data base.
/// </summary>
/// <param name="listElementData">List of user element objects.</param>
/// <param name="parameters">User common parameters.</param>
/// <param name="data">Acces to cref="ServiceData".</param>
public void SaveToRevitDB(List <ObjectDataBase> listElementData, CommonParametersBase parameters, Autodesk.Revit.DB.CodeChecking.ServiceData data)
{
Autodesk.Revit.DB.ResultsBuilder.Storage.ResultsPackageBuilder builder = Autodesk.Revit.DB.CodeChecking.Storage.StorageService.GetStorageService().GetStorageDocument(data.Document).CalculationParamsManager.CalculationParams.GetOutputResultPackageBuilder(Server.Server.ID);
ForceResultsWriter resultsWriter = new ForceResultsWriter(data.Document, builder, Autodesk.Revit.DB.ResultsBuilder.UnitsSystem.Metric);
foreach (ObjectDataBase objectDataBase in listElementData)
{
ElementDataBase elementDataBase = objectDataBase as ElementDataBase;
switch (elementDataBase.Category)
{
default:
break;
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
{
//TBD - RB doesn't support relative coordinates as input
//Begin mod
//IList<double> vx = (from sec in elementDataBase.ListSectionData select (sec as LinearSection).GetCalcResultsInPt()[ResultTypeLinear.X_Rel ]).ToList();
bool isListForces = true;
foreach (LinearSection sec in elementDataBase.ListSectionData)
{
if (sec.ListInternalForces == null || sec.ListInternalForces.Count == 0)
{
isListForces = false;
break;
}
}
if (isListForces)
{
IList <double> xCoordinates = (from sec in elementDataBase.ListSectionData select(sec as LinearSection).GetCalcResultsInPoint()[ResultTypeLinear.X]).ToList();
//End Mod
resultsWriter.SetMeasurementForElement(elementDataBase.ElementId, AxisDirection.X, xCoordinates);
ResultTypeLinear[] resultTypesLinear = new ResultTypeLinear[] { ResultTypeLinear.Abottom, ResultTypeLinear.Atop, ResultTypeLinear.Aleft, ResultTypeLinear.Aright };
foreach (ResultTypeLinear forceType in resultTypesLinear)
{
ICollection <double> valuesInPoints = (from LinearSection section in elementDataBase.ListSectionData select section.GetCalcResultsInPoint()[forceType]).ToList();
resultsWriter.AddResultsForElement(elementDataBase.ElementId, forceType.GetResultType(), valuesInPoints);
}
}
}
break;
}
}
resultsWriter.StoreResultsInResultsBuilder("RCCalculationsResults");
//builder.Finish();
}
public void Deserialize(NetworkManager networkManager, ElementDataBase elementData, UIBehaviour element)
{
TextData textData = elementData as TextData;
Text textElement = element as Text;
if (textElement)
{
textElement.text = textData.text;
textElement.fontSize = textData.fontSize;
textElement.font = FontCache.GetFont(textData.fontName);
textElement.color = textData.colorData.Deserialize();
textElement.alignment = textData.alignment;
}
}
public void Deserialize(NetworkManager networkManager, ElementDataBase elementData, UIBehaviour element)
{
ImageData imageData = elementData as ImageData;
Image imageElement = element as Image;
if (imageElement)
{
imageElement.color = imageData.colorData.Deserialize();
if (imageElement.sprite == null)
{
imageElement.sprite = imageData.spriteData.Deserialize();
}
imageElement.type = imageData.type;
}
}
public void Deserialize(NetworkManager networkManager, ElementDataBase elementData, UIBehaviour element)
{
RawImageData imageData = elementData as RawImageData;
RawImage imageElement = element as RawImage;
if (imageElement)
{
imageElement.color = imageData.colorData.Deserialize();
if (imageElement.texture == null)
{
imageElement.texture = imageData.textureData.Deserialize();
}
imageElement.uvRect = imageData.uvRect.Deserialize();
}
}
/// <summary>
/// Filters list of elements due to e.g. a result status for calculation purposes.
/// </summary>
/// <param name="listElementData">List of user element objects.</param>
/// <returns>Filtered list of user element objects.</returns>
public List <ObjectDataBase> FilterElementForCalculation(List <ObjectDataBase> listElementData)
{
List <ObjectDataBase> listElementFiltered = new List <ObjectDataBase>();
foreach (ObjectDataBase obj in listElementData)
{
ElementDataBase elem = obj as ElementDataBase;
if (elem != null)
{
if (!elem.Status.IsError())
{
listElementFiltered.Add(elem);
}
}
}
return(listElementFiltered);
}
public void Deserialize(NetworkManager networkManager, ElementDataBase elementData, UIBehaviour element)
{
SliderData sliderData = elementData as SliderData;
Slider sliderElement = element as Slider;
if (sliderElement)
{
if (ignoreServerUpdates)
{
if (sentValue == sliderData.value)
{
ignoreServerUpdates = false;
}
}
else
{
ignoreCallback = true;
sliderElement.value = sliderData.value;
ignoreCallback = false;
ObjectCache.Bind <Graphic>(x => sliderElement.targetGraphic = x, sliderData.targetGraphic);
ObjectCache.Bind <RectTransform>(x => sliderElement.fillRect = x, sliderData.fillRect);
ObjectCache.Bind <RectTransform>(x => sliderElement.handleRect = x, sliderData.handleRect);
}
IgnoreTransformUpdates(sliderElement.fillRect);
IgnoreTransformUpdates(sliderElement.handleRect);
if (networkManager)
{
sliderElement.onValueChanged.AddListener((value) =>
{
if (ignoreCallback)
{
return;
}
sentValue = value;
InputMessage inputMessage = new InputMessage(InputMessageType.Slider, sliderData.ID, value);
networkManager.SendMessageToServer(inputMessage.Serialize());
ignoreServerUpdates = true;
});
}
}
}
/// <summary>
/// Creates new instance of user class wich represents a structure element.
/// </summary>
/// <param name="elementDataBase">Instance of base class for the element.</param>
/// <returns>New instance of user implementation of element class derived from cref="ElementDataBase".</returns>
public ElementDataBase CreateElementData(ElementDataBase elementDataBase)
{
switch (elementDataBase.Material)
{
case StructuralAssetClass.Concrete:
switch (elementDataBase.Category)
{
default:
break;
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
return(new ColumnElement(elementDataBase));
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
return(new BeamElement(elementDataBase));
}
break;
case StructuralAssetClass.Metal:
break;
}
return(elementDataBase);
}
public WallElement(ElementDataBase elementDataBase) : base(elementDataBase)
{
}
/// <summary>
/// Initializes a new instance of user's column object.
/// </summary>
/// <param name="elementDataBase">Instance of base element object with predefined parameters to copy.</param>
public ColumnElement(ElementDataBase elementDataBase)
: base(elementDataBase)
{
}
/// <summary>
/// Runs calculation\operations for cref="BeamElement".
/// </summary>
/// <param name="obj">cref="BeamElement".</param>
/// <returns>Result of calculation.</returns>
public bool Run(ObjectDataBase obj)
{
ElementDataBase elementData = obj as ElementDataBase;
if (obj != null)
{
BeamElement objBeam = obj as BeamElement;
if (objBeam != null)
{
CodeCheckingConcreteExample.Main.ResultBeam res = elementData.Result as CodeCheckingConcreteExample.Main.ResultBeam;
if (res != null)
{
double young = objBeam.Info.Material.Characteristics.YoungModulus.X;
double maxCoef = 0;
double stifCoef = 0.0;
double avrCoef = 0.0;
int sectionNo = 0;
foreach (SectionDataBase sd in elementData.ListSectionData)
{
BeamSection sec = sd as BeamSection;
if (sec != null)
{
if (sec.MinStiffness > Double.Epsilon)
{
CalcPointLinear calcPoint = sec.CalcPoint as CalcPointLinear;
double Iy = sec.Info.SectionsParams.AtThePoint(calcPoint.CoordRelative).Characteristics.Iy;
stifCoef = (Iy * young) / sec.MinStiffness;
}
else
{
stifCoef = 0;
break;
}
++sectionNo;
maxCoef = Math.Max(maxCoef, stifCoef);
avrCoef += stifCoef;
}
}
double finStiffnes = 0;
if (stifCoef > Double.Epsilon)
{
avrCoef /= sectionNo;
finStiffnes = 0.5 * (maxCoef + avrCoef);
}
else
{
objBeam.AddFormatedWarning(new ResultStatusMessage("Calculation of deflections was not performed."));
}
foreach (SectionDataBase sd in elementData.ListSectionData)
{
BeamSection sec = sd as BeamSection;
if (sec != null)
{
sec.StiffnesCoeff = finStiffnes;
}
}
}
}
}
return(true);
}
/// <summary>
/// Runs calculation\operations for cref="BeamElement" and cref="ColumnElement".
/// </summary>
/// <param name="obj">cref="BeamElement" object or cref="ColumnElement" object.</param>
/// <returns>Result of calculation.</returns>
public bool Run(ObjectDataBase obj)
{
ElementDataBase elementData = obj as ElementDataBase;
if (obj != null)
{
switch (elementData.Category)
{
default:
break;
case Autodesk.Revit.DB.BuiltInCategory.OST_ColumnAnalytical:
case Autodesk.Revit.DB.BuiltInCategory.OST_BeamAnalytical:
if (elementData.Result is ResultLinearElement)
{
CodeCheckingConcreteExample.Main.ResultLinearElement res = elementData.Result as ResultLinearElement;
if (res != null)
{
elementData.ListSectionData.ForEach(s => res.ValuesInPointsData.AddRange((s as LinearSection).GetCalcResultsInPoint().DataRaw));
}
UnitType xUnitType = ResultTypeLinear.X.GetUnitType();
DisplayUnitType xInternalDisplayUnitType = UnitsConverter.GetInternalUnit(xUnitType);
// add info
IEnumerable <IGrouping <String, Tuple <String, Double> > > infoInSec = elementData.ListSectionData.
SelectMany(lsd => (lsd as LinearSection).DesignInfo.Select(dw => new Tuple <String, Double>(dw, (lsd.CalcPoint as CalcPointLinear).CoordAbsolute))).
GroupBy(s => s.Item1);
// add warnings
IEnumerable <IGrouping <String, Tuple <String, Double> > > warningsInSec = elementData.ListSectionData.
SelectMany(lsd => (lsd as LinearSection).DesignWarning.Select(dw => new Tuple <String, Double>(dw, (lsd.CalcPoint as CalcPointLinear).CoordAbsolute))).
GroupBy(s => s.Item1);
// add errors
IEnumerable <IGrouping <String, Tuple <String, Double> > > errosInSec = elementData.ListSectionData.
SelectMany(lsd => (lsd as LinearSection).DesignError.Select(dw => new Tuple <String, Double>(dw, (lsd.CalcPoint as CalcPointLinear).CoordAbsolute))).
GroupBy(s => s.Item1);
if (errosInSec.Count() > 0)
{
getResultStatusMessage(errosInSec, xInternalDisplayUnitType).ForEach(s => elementData.AddFormatedError(s));
elementData.Status.Status = Status.Failed;
}
else
{
if (warningsInSec.Count() > 0)
{
getResultStatusMessage(warningsInSec, xInternalDisplayUnitType).ForEach(s => elementData.AddFormatedWarning(s));
if (Status.Failed != elementData.Status.Status)
{
elementData.Status.Status = Status.Warning;
}
}
if (infoInSec.Count() > 0)
{
getResultStatusMessage(infoInSec, xInternalDisplayUnitType).ForEach(s => elementData.AddFormatedInfo(s));
}
}
if (Autodesk.Revit.DB.CodeChecking.Storage.Status.Undefined == elementData.Status.Status)
{
elementData.Status.Status = Autodesk.Revit.DB.CodeChecking.Storage.Status.Succeed;
}
}
break;
}
}
return(true);
}
public FloorElement(ElementDataBase elementDataBase) : base(elementDataBase)
{
}
/// <summary>
/// Initializes a new instance of user's beam object.
/// </summary>
/// <param name="elementDataBase">Instance of base element object with predefined parameters to copy.</param>
public BeamElement(ElementDataBase elementDataBase)
: base(elementDataBase)
{
}
