Annamaria Sassi
1210 lines
50 KiB
C#
1210 lines
50 KiB
C#
using Egw.Window.Data;
|
|
using System.Xml.Serialization;
|
|
using WebWindowComplex.Json;
|
|
using static WebWindowComplex.Json.WindowConst;
|
|
|
|
namespace WebWindowComplex.Models
|
|
{
|
|
public class Sash : Area
|
|
{
|
|
#region Public Fields
|
|
|
|
// Lista hardware completa passata dal chiamante del componente
|
|
public static List<Hardware> m_HardwareCompleteList = new List<Hardware>();
|
|
|
|
// Lista famiglia hardware completa passata dal chiamante del componente
|
|
public static List<string> s_FamilyHardwareList = new List<string>();
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
public Sash(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
|
|
{
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
/// <summary>
|
|
/// Dimensione solo luce
|
|
/// true --> dimensione solo luce
|
|
/// false --> dimensione totale
|
|
/// </summary>
|
|
public bool bIsDimensionLight
|
|
{
|
|
get
|
|
{
|
|
return m_IsbDimensionLight;
|
|
}
|
|
set
|
|
{
|
|
if (m_IsbDimensionLight != value)
|
|
{
|
|
m_IsbDimensionLight = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool bIsSashVertical
|
|
{
|
|
get
|
|
{
|
|
return m_bIsSashVertical;
|
|
}
|
|
set
|
|
{
|
|
m_bIsSashVertical = value;
|
|
}
|
|
}
|
|
|
|
//public SashArcElement? SashArcElem
|
|
//{
|
|
// get
|
|
// {
|
|
// return m_SashArcElement;
|
|
// }
|
|
// set
|
|
// {
|
|
// m_SashArcElement = value!;
|
|
// }
|
|
//}
|
|
public List<ElementDimension> BottomRailElemDimList
|
|
{
|
|
get => m_BottomRailElemDimList;
|
|
set => m_BottomRailElemDimList = value;
|
|
}
|
|
public List<Hardware> HardwareList
|
|
{
|
|
get
|
|
{
|
|
return m_HardwareList;
|
|
}
|
|
}
|
|
|
|
public List<AGBOption> HwOptionList
|
|
{
|
|
get
|
|
{
|
|
return m_HwOptionList;
|
|
}
|
|
}
|
|
|
|
public Dictionary<string, string> SelHwOptionList
|
|
{
|
|
get
|
|
{
|
|
return m_SelHwOptionList;
|
|
}
|
|
}
|
|
|
|
public int nSashQty
|
|
{
|
|
get
|
|
{
|
|
return m_SashList.Count > 0 ? m_SashList.Count : 1;
|
|
}
|
|
set
|
|
{
|
|
if (value > 0 && value <= 3)
|
|
{
|
|
Frame frame = (Frame)ParentWindow.AreaList.First();
|
|
double widthTot = 0;
|
|
if (bIsDimensionLight)
|
|
{
|
|
foreach (var item in m_SashList)
|
|
widthTot = widthTot + item.dDimension;
|
|
}
|
|
else
|
|
{
|
|
widthTot = CalculateWidthSashGroup(frame, frame.DimensionList.Where(x => x.sName == "Width").First().dDimension, new AreaFound(-1, false)).m_Dimension;
|
|
}
|
|
if (value > m_SashList.Count)
|
|
{
|
|
// recupero larghezza ultimo
|
|
double dLastDimension = widthTot;
|
|
double dNewDimension = widthTot;
|
|
if (m_SashList.Count > 0)
|
|
{
|
|
dLastDimension = m_SashList[m_SashList.Count - 1].dDimension;
|
|
if (m_SashList[m_SashList.Count - 1].MeasureType.Equals(MeasureTypes.PROPORTIONAL))
|
|
dNewDimension = 1;
|
|
else if (m_SashList[m_SashList.Count - 1].MeasureType is MeasureTypes.PERCENTAGE)
|
|
dNewDimension = dLastDimension / (value + 1 - nSashQty);
|
|
else
|
|
{
|
|
if (bIsDimensionLight)
|
|
dNewDimension = (dLastDimension - m_SashList.Last().ElementDimensionList.ElementAt(1).dDimension
|
|
- m_SashList.Last().ElementDimensionList.Last().dDimension
|
|
+ Window.m_ParameterList.GetValueOrDefault("Sash_Active_Overlap"))/2;
|
|
else
|
|
dNewDimension = dLastDimension / (value + 1 - nSashQty)
|
|
+ (Window.m_ParameterList.GetValueOrDefault("Sash_Active_Overlap"))/2;
|
|
}
|
|
m_SashList[m_SashList.Count - 1].SetDimension(dNewDimension);
|
|
}
|
|
else
|
|
dNewDimension = dLastDimension / (value + 1 - nSashQty);
|
|
// aggiungo area Sash di default
|
|
for (var SplitIndex = m_SashList.Count; SplitIndex <= value - 1; SplitIndex++)
|
|
{
|
|
var addSashDim = new SashDimension(dNewDimension, m_SashList[m_SashList.Count - 1].MeasureType, this, SplitIndex + 1);
|
|
for (int i = 1; i <= 4; i++)
|
|
{
|
|
addSashDim.JointList.Add(new Joint(this, i, Joints.FULL_V));
|
|
}
|
|
SashList.Add(addSashDim);
|
|
}
|
|
if (m_CurrShape == "FullArc" ||
|
|
m_CurrShape == "Arc" ||
|
|
m_CurrShape == "SemiFullArc" ||
|
|
m_CurrShape == "SemiArc")
|
|
{
|
|
if (SashList.ElementAt(value - 2) != null)
|
|
SashList.ElementAt(value - 2)!.JointList.ElementAt(2).SelJointTypeIndex = (int)Joints.FULL_V;
|
|
if (SashList.LastOrDefault() != null)
|
|
SashList.LastOrDefault()!.JointList.ElementAt(2).SelJointTypeIndex = (int)Joints.ANGLED;
|
|
}
|
|
}
|
|
else if (value < m_SashList.Count)
|
|
{
|
|
if (value > 0)
|
|
{
|
|
double dLastDimension = 0;
|
|
SashDimension itemDelete = new SashDimension(0, MeasureTypes.NULL, this, 0);
|
|
double deleteDim = 0;
|
|
double splitDelete = 0;
|
|
for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= value; SplitIndex += -1)
|
|
{
|
|
itemDelete = m_SashList[SplitIndex];
|
|
if(itemDelete.SelMeasureType is MeasureTypes.ABSOLUTE)
|
|
{
|
|
if (bIsDimensionLight)
|
|
splitDelete = m_SashList[m_SashList.Count - 2].ElementDimensionList.ElementAt(1).dDimension
|
|
+ m_SashList.Last().ElementDimensionList.Last().dDimension
|
|
- m_SashList.Last().ElementDimensionList.Last().dOverlap;
|
|
else
|
|
splitDelete = - m_SashList.Last().ElementDimensionList.Last().dOverlap;
|
|
}
|
|
SashList.RemoveAt(SplitIndex);
|
|
}
|
|
if (!itemDelete.SelMeasureType.Equals(m_SashList[SashList.Count - 1].SelMeasureType))
|
|
{
|
|
AreaDimension ad = new AreaDimension(itemDelete.dDimension, itemDelete.SelMeasureType, itemDelete.Parent);
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in SashList)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
|
|
}
|
|
deleteDim = ad.ConvertDimension(adList, itemDelete.SelMeasureType, m_SashList[SashList.Count - 1].SelMeasureType, widthTot, m_SashList.IndexOf(itemDelete));
|
|
}
|
|
else
|
|
{
|
|
deleteDim = itemDelete.dDimension;
|
|
}
|
|
dLastDimension = deleteDim + m_SashList[SashList.Count - 1].dDimension + splitDelete;
|
|
if(SashList[SashList.Count - 1].SelMeasureType is MeasureTypes.PROPORTIONAL && SashList.Count == 1)
|
|
SashList[SashList.Count - 1].SetDimension(1);
|
|
else
|
|
SashList[SashList.Count - 1].SetDimension(dLastDimension);
|
|
if (value == 1)
|
|
SashList.First().SetHasHandle(true);
|
|
}
|
|
else
|
|
{
|
|
SashList.RemoveAt(0);
|
|
}
|
|
if (m_CurrShape == "FullArc" ||
|
|
m_CurrShape == "Arc" ||
|
|
m_CurrShape == "SemiFullArc" ||
|
|
m_CurrShape == "SemiArc")
|
|
{
|
|
if (SashList.LastOrDefault() != null)
|
|
{
|
|
SashList.LastOrDefault()!.JointList.ElementAt(2).SelJointTypeIndex = (int)Joints.ANGLED;
|
|
}
|
|
}
|
|
}
|
|
if (m_SashList.Count == 0)
|
|
{
|
|
Area child = AreaList.First();
|
|
// Se nella singola anta ho uno split
|
|
if (!(child is Fill))
|
|
{
|
|
child = child.AreaList.First().AreaList.First();
|
|
}
|
|
child.SetParentArea(this.ParentArea);
|
|
this.ParentArea.AreaList.Remove(this);
|
|
this.ParentArea.AreaList.Add(child);
|
|
}
|
|
// Se ho singola anta
|
|
else if (m_SashList.Count == 1)
|
|
{
|
|
// Metto come padre dell'area nello splitted l'anta stessa
|
|
List<Area> ContentArea = new List<Area>();
|
|
ContentArea.Add(AreaList.First().AreaList.First());
|
|
ContentArea.First().SetParentArea(this);
|
|
AreaList.Clear();
|
|
AreaList.Add(ContentArea.First());
|
|
}
|
|
else
|
|
{
|
|
// Se aggiungo ante
|
|
if (SashList.Count > AreaList.Count)
|
|
{
|
|
List<Area> ContentArea = new List<Area>();
|
|
// Salvo in ContentArea il sottoalbero delle singole aree che mantengo
|
|
if (AreaList.Count >= 1 & SashList.Count > AreaList.Count)
|
|
{
|
|
foreach (Area area in AreaList)
|
|
{
|
|
if (area is Splitted)
|
|
ContentArea.Add(area.AreaList.First());
|
|
else
|
|
ContentArea.Add(area);
|
|
}
|
|
AreaList.Clear();
|
|
}
|
|
for (int SplitIndex = AreaList.Count; SplitIndex <= SashList.Count - 1; SplitIndex++)
|
|
{
|
|
AreaList.Add(Splitted.CreateSplitted(this));
|
|
}
|
|
// Riaggiungo i sottoalberi che avevo salvato
|
|
for (int i = 0; i <= ContentArea.Count - 1; i++)
|
|
{
|
|
if (AreaList.Count == 2)
|
|
{
|
|
ContentArea[i].SetParentArea(AreaList[i]);
|
|
}
|
|
AreaList[i].AreaList.Add(ContentArea[i]);
|
|
}
|
|
// Aggiungo all'ultimo Splitted l'area di vetro
|
|
for(int k = ContentArea.Count; k <= AreaList.Count - 1; k++)
|
|
{
|
|
Fill newFill = Fill.CreateFill(AreaList[k], FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
AreaList[k].AreaList.Add(newFill);
|
|
}
|
|
}
|
|
// Se tolgo anta
|
|
else
|
|
{
|
|
for (int SplitIndex = SashList.Count; SplitIndex <= AreaList.Count() - 1; SplitIndex++)
|
|
{
|
|
AreaList.Remove(AreaList[AreaList.Count - 1]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (int i = 0; i < AreaList.Count; i++)
|
|
{
|
|
double width = SashList.ElementAt(i).dDimension;
|
|
if(SashList.ElementAt(i).ElementDimensionList.Count > 0 && !bIsDimensionLight)
|
|
width = width - SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
|
|
- SashList.ElementAt(i).ElementDimensionList.Last().dDimension;
|
|
AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), width, "Width");
|
|
}
|
|
}
|
|
RefreshHardwareList();
|
|
ClearHardwareOptionList();
|
|
SetFirstHardware();
|
|
}
|
|
}
|
|
|
|
public OrientationSash OrientationSashType
|
|
{
|
|
get
|
|
{
|
|
return (OrientationSash)m_SelOrientationSashType;
|
|
}
|
|
}
|
|
|
|
public List<IdNameStruct> OrientationSashTypeList
|
|
{
|
|
get
|
|
{
|
|
return m_OrientationSashTypeList;
|
|
}
|
|
}
|
|
|
|
public bool SashBottomRail
|
|
{
|
|
get
|
|
{
|
|
return m_bSashBottomRail;
|
|
}
|
|
set
|
|
{
|
|
m_bSashBottomRail = value;
|
|
}
|
|
}
|
|
|
|
public int SashBottomRailQty
|
|
{
|
|
get
|
|
{
|
|
return m_nSashBottomRailQty;
|
|
}
|
|
set
|
|
{
|
|
if (value >= 0)
|
|
{
|
|
if (value > m_nSashBottomRailQty)
|
|
{
|
|
// Aggiungo un element
|
|
BottomRailElemDimList.Add(new ElementDimension(this, BottomRailElemDimList.Count + 1, 78));
|
|
BottomRailElemDimList.Last().SetNameElement("Sash_Fill_Rail");
|
|
BottomRailElemDimList.Last().SetMinDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimMin"));
|
|
BottomRailElemDimList.Last().SetMaxDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimMax"));
|
|
BottomRailElemDimList.Last().SetDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimStd"));
|
|
BottomRailElemDimList.Last().SetOverlapElement(Window.m_ParameterList.GetValueOrDefault("Sash_BottomRail_Overlap"));
|
|
if (value > 1 && BottomRailElemDimList.Count - 2 >= 0)
|
|
{
|
|
BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).SetNameElement("Sash_Rail");
|
|
BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).SetMinDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).sName + "_DimMin"));
|
|
BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).SetMaxDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).sName + "_DimMax"));
|
|
BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).SetDimension(BottomRailElemDimList.ElementAt(BottomRailElemDimList.Count - 2).dDimension);
|
|
}
|
|
}
|
|
else if (value < m_nSashBottomRailQty)
|
|
{
|
|
// Elimino gli element
|
|
for (int i = BottomRailElemDimList.Count - 1; i == value; i--)
|
|
BottomRailElemDimList.RemoveAt(i);
|
|
if (value >= 1)
|
|
{
|
|
BottomRailElemDimList.Last().SetNameElement("Sash_Fill_Rail");
|
|
BottomRailElemDimList.Last().SetMinDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimMin"));
|
|
BottomRailElemDimList.Last().SetMaxDimension(Window.m_ParameterList.GetValueOrDefault(BottomRailElemDimList.Last().sName + "_DimMax"));
|
|
BottomRailElemDimList.Last().SetDimension(BottomRailElemDimList.Last().dDimension);
|
|
}
|
|
}
|
|
m_nSashBottomRailQty = value;
|
|
if (m_nSashBottomRailQty > 0)
|
|
{
|
|
m_bSashBottomRail = true;
|
|
}
|
|
else
|
|
{
|
|
m_bSashBottomRail = false;
|
|
}
|
|
Frame frame = ParentWindow.AreaList.First();
|
|
if (frame.AreaList.Count > 0 && frame != null)
|
|
frame.SearchAreaList(frame, frame.AvailHeightArea(), "Height");
|
|
//ParentWindow.AreaList.First().SearchAreaList(ParentWindow.AreaList.First(), ParentWindow.AreaList.First().AvailHeightArea(), "Height");
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<SashDimension> SashList
|
|
{
|
|
get
|
|
{
|
|
return m_SashList;
|
|
}
|
|
set
|
|
{
|
|
m_SashList = value;
|
|
}
|
|
}
|
|
|
|
public SashTypes SashType
|
|
{
|
|
get
|
|
{
|
|
return m_SashType;
|
|
}
|
|
set
|
|
{
|
|
m_SashType = value;
|
|
}
|
|
}
|
|
|
|
public string SelFamilyHardware
|
|
{
|
|
get
|
|
{
|
|
return m_SelFamilyHardware;
|
|
}
|
|
set
|
|
{
|
|
SetSelFamilyHardware(value);
|
|
}
|
|
}
|
|
|
|
public Hardware SelHardware
|
|
{
|
|
get
|
|
{
|
|
return m_SelHardware!;
|
|
}
|
|
set
|
|
{
|
|
m_SelHardware = value;
|
|
if (HwOptionList.Count != 0)
|
|
{
|
|
ClearHardwareOptionList();
|
|
}
|
|
}
|
|
}
|
|
|
|
public string SelHardwareFromId
|
|
{
|
|
get
|
|
{
|
|
return m_SelHardware!.Id;
|
|
}
|
|
set
|
|
{
|
|
m_SelHardware = m_HardwareList.FirstOrDefault(x => !string.IsNullOrEmpty(value) && x.Id.Equals(value)) ?? new Hardware(CustomHwId, "", "", Enums.OpeningTypes.Null, "", 0, 0);
|
|
HwOptionList.Clear();
|
|
if (SelHardware.Id == CustomHwId)
|
|
{
|
|
SelHwOptionList.Clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
public OrientationSash SelOrientationSashType
|
|
{
|
|
get
|
|
{
|
|
return m_SelOrientationSashType;
|
|
}
|
|
set
|
|
{
|
|
m_SelOrientationSashType = value;
|
|
}
|
|
}
|
|
|
|
public int SelOrientationSashTypeIndex
|
|
{
|
|
get
|
|
{
|
|
return (int)m_SelOrientationSashType;
|
|
}
|
|
set
|
|
{
|
|
m_SelOrientationSashType = (OrientationSash)value;
|
|
if (value == 0)
|
|
{
|
|
m_bIsSashVertical = true;
|
|
}
|
|
else
|
|
{
|
|
m_bIsSashVertical = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public string SashShape
|
|
{
|
|
get => m_CurrShape;
|
|
set => m_CurrShape = value;
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
public override Sash Copy(Area newParentArea)
|
|
{
|
|
Sash newSash = new Sash(newParentArea, m_ParentWindow);
|
|
AddCounterGroup();
|
|
newSash.SetGroupId(nCounterGroup);
|
|
newSash.SetAreaType(AreaType);
|
|
// Imposta la quantità di ante e definisce SashDimension di ogni anta ai valori di default
|
|
newSash.SetSashQty(nSashQty);
|
|
newSash.SetIsSashVertical(bIsSashVertical);
|
|
newSash.SetOrientationSashType(OrientationSashType);
|
|
newSash.SetSashBottomRailQty(SashBottomRailQty);
|
|
for (int i = 0; i < SashList.Count; i++)
|
|
{
|
|
//Cancello SashDimension di default e aggiungo la copia
|
|
newSash.SashList.RemoveAt(i);
|
|
SashDimension newSashDim = SashList[i].Copy();
|
|
newSash.SashList.Insert(i, newSashDim);
|
|
}
|
|
foreach (var item in AreaList)
|
|
{
|
|
Area newArea = item.Copy(newSash);
|
|
newSash.AreaList.Add(newArea);
|
|
}
|
|
newSash.SetSelFamilyHardwareFromIndex(m_SelHardware!.Id);
|
|
newSash.SetSelHardwareFromId(CustomHwId);
|
|
//if (ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.ARC ||
|
|
// ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.DOUBLEARC ||
|
|
// ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.ARC_FULL ||
|
|
// ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.THREECENTERARC)
|
|
// newSash.SashArcElem = new SashArcElement(newSash, ParentWindow, 10, true);
|
|
//else
|
|
// newSash.SashArcElem = null;
|
|
return newSash;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update valori ammissibili x HW list
|
|
/// </summary>
|
|
public void RefreshHardwareList()
|
|
{
|
|
if (m_HardwareCompleteList != null && m_HardwareCompleteList.Count > 0)
|
|
{
|
|
m_HardwareList.Clear();
|
|
Enums.OpeningTypes sOpeningType = ConvertOpeningType();
|
|
if (string.IsNullOrEmpty(m_SelFamilyHardware))
|
|
m_SelFamilyHardware = s_FamilyHardwareList.FirstOrDefault() ?? "";
|
|
int sashPosition = 1;
|
|
if (nSashQty > 2 && !(SashList.First().bHasHandle || SashList.Last().bHasHandle))
|
|
sashPosition = 2;
|
|
var iComp = StringComparison.InvariantCultureIgnoreCase;
|
|
var rawList = m_HardwareCompleteList
|
|
.Where(x => x.Id == "000000" ||
|
|
(!string.IsNullOrEmpty(m_SelFamilyHardware) &&
|
|
x.FamilyName.Equals(m_SelFamilyHardware, iComp) &&
|
|
x.SashQty == nSashQty &&
|
|
x.Shape.Equals(m_CurrShape, iComp) &&
|
|
x.OpeningType == sOpeningType &&
|
|
x.SashPosition == sashPosition)
|
|
)
|
|
.ToList() ?? new List<Hardware>();
|
|
if(rawList.Count == 0 || rawList == null)
|
|
{
|
|
Hardware hw = new Hardware(CustomHwId, m_SelFamilyHardware, "Custom", sOpeningType, m_CurrShape, nSashQty, 1);
|
|
rawList = new List<Hardware>();
|
|
rawList.Add(hw);
|
|
}
|
|
m_HardwareList = new List<Hardware>(rawList);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per rimuovere l'intero sash group
|
|
/// </summary>
|
|
public void Remove()
|
|
{
|
|
ParentArea.AreaList.Remove(this);
|
|
Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
ParentArea.AreaList.Add(newFill);
|
|
}
|
|
|
|
public void SetSelFamilyHardware(string sFamilyHw)
|
|
{
|
|
m_SelFamilyHardware = sFamilyHw;
|
|
// se ho la shape aggiorno elenco HW
|
|
if (!string.IsNullOrEmpty(m_CurrShape))
|
|
{
|
|
RefreshHardwareList();
|
|
}
|
|
SetFirstHardware();
|
|
if (HwOptionList.Count != 0)
|
|
ClearHardwareOptionList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiornamento HW List e Hw selezionato conseguente a ricezione nuova Shape
|
|
/// </summary>
|
|
/// <param name="newShape"></param>
|
|
public void UpdateShape(string newShape)
|
|
{
|
|
m_CurrShape = newShape;
|
|
// la famiglia hw è vuota seleziono il primo hardware valido e utilizzo la sua famiglia
|
|
if(string.IsNullOrEmpty(m_SelFamilyHardware) || m_SelFamilyHardware == "")
|
|
{
|
|
var listHwValid = Sash.m_HardwareCompleteList
|
|
.FirstOrDefault(x => x.Shape == m_CurrShape &&
|
|
x.SashQty == nSashQty &&
|
|
x.OpeningType == ConvertOpeningType()
|
|
);
|
|
if(listHwValid == null)
|
|
{
|
|
var familyHwValid = Sash.m_HardwareCompleteList
|
|
.Select(x => x.FamilyName)
|
|
.First();
|
|
SelHardwareFromId = "000000";
|
|
ClearHardwareOptionList();
|
|
}
|
|
else
|
|
{
|
|
SetSelFamilyHardware(listHwValid.FamilyName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
RefreshHardwareList();
|
|
// se il vecchio hw selezionato non va più bene viene selezionato il primo della lista
|
|
if (!HardwareList.Contains(m_SelHardware!) || m_SelHardware!.Shape != m_CurrShape)
|
|
{
|
|
SetFirstHardware();
|
|
ClearHardwareOptionList();
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Internal Methods
|
|
|
|
internal void SetIsDimensionLight(bool DimensionLight)
|
|
{
|
|
m_IsbDimensionLight = DimensionLight;
|
|
}
|
|
|
|
internal static Sash CreateSash(Area Area)
|
|
{
|
|
Sash newSash = new Sash(Area, Area.ParentWindow);
|
|
AddCounterGroup();
|
|
newSash.SetGroupId(nCounterGroup);
|
|
newSash.SetAreaType(AreaTypes.SASH);
|
|
newSash.SetSashQty(1);
|
|
newSash.SetOrientationSashType(OrientationSash.VERTICAL);
|
|
newSash.SetIsSashVertical(true);
|
|
foreach(var sashDim in newSash.SashList)
|
|
{
|
|
for (var JointIndex = 0; JointIndex <= 3; JointIndex++)
|
|
sashDim.JointList.Add(new Joint(newSash, JointIndex + 1, Joints.FULL_V));
|
|
}
|
|
newSash.SetSashBottomRail(false);
|
|
newSash.SetSashBottomRailQty(0);
|
|
newSash.SetSelFamilyHardware(Sash.s_FamilyHardwareList.First());
|
|
newSash.ClearHardwareOptionList();
|
|
newSash.SetFirstHardware();
|
|
//newSash.SashArcElem = null;
|
|
return newSash;
|
|
}
|
|
|
|
//internal OpeningSides GetOpeningSide(Openings OpeningType)
|
|
//{
|
|
// switch (OpeningType)
|
|
// {
|
|
// case Openings.TURNONLY_LEFT:
|
|
// case Openings.TILTTURN_LEFT:
|
|
// case Openings.TILTONLY_TOP:
|
|
// case Openings.COMPLANARSLIDE_LEFT:
|
|
// case Openings.LIFTSLIDE_LEFT:
|
|
// {
|
|
// return OpeningSides.LEFT;
|
|
// }
|
|
|
|
// case Openings.TURNONLY_RIGHT:
|
|
// case Openings.TILTTURN_RIGHT:
|
|
// case Openings.TILTONLY_BOTTOM:
|
|
// case Openings.COMPLANARSLIDE_RIGHT:
|
|
// case Openings.LIFTSLIDE_RIGHT:
|
|
// {
|
|
// return OpeningSides.RIGHT;
|
|
// }
|
|
|
|
// default:
|
|
// {
|
|
// return OpeningSides.NULL;
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
internal Enums.OpeningTypes GetOpeningType(Openings OpeningType)
|
|
{
|
|
switch (OpeningType)
|
|
{
|
|
case Openings.TURNONLY_LEFT:
|
|
case Openings.TURNONLY_RIGHT:
|
|
{
|
|
return Enums.OpeningTypes.TurnOnly;
|
|
}
|
|
|
|
case Openings.TILTTURN_LEFT:
|
|
case Openings.TILTTURN_RIGHT:
|
|
{
|
|
return Enums.OpeningTypes.TiltTurn;
|
|
}
|
|
|
|
case Openings.TILTONLY_TOP:
|
|
case Openings.TILTONLY_BOTTOM:
|
|
{
|
|
return Enums.OpeningTypes.TiltOnly;
|
|
}
|
|
|
|
case Openings.PIVOT:
|
|
{
|
|
return Enums.OpeningTypes.Pivot;
|
|
}
|
|
|
|
case Openings.FIXED:
|
|
{
|
|
return Enums.OpeningTypes.Fixed;
|
|
}
|
|
|
|
case Openings.COMPLANARSLIDE_LEFT:
|
|
case Openings.COMPLANARSLIDE_RIGHT:
|
|
{
|
|
return Enums.OpeningTypes.ComplanarSlide;
|
|
}
|
|
|
|
case Openings.LIFTSLIDE_LEFT:
|
|
case Openings.LIFTSLIDE_RIGHT:
|
|
{
|
|
return Enums.OpeningTypes.LiftSlide;
|
|
}
|
|
|
|
default:
|
|
{
|
|
return Enums.OpeningTypes.Null;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void ClearHardwareOptionList()
|
|
{
|
|
m_HwOptionList.Clear();
|
|
}
|
|
|
|
internal override JsonArea Serialize(bool hideHw)
|
|
{
|
|
if (nCounterGroup < GroupId)
|
|
Area.nCounterGroup = GroupId;
|
|
string currHwId = hideHw ? CustomHwId : m_SelHardware!.Id;
|
|
JsonSash JsonSash = new JsonSash(m_bIsSashVertical, m_SashType, m_bSashBottomRail, m_nSashBottomRailQty, currHwId, GroupId, bIsDimensionLight);
|
|
foreach (var SashDimension in SashList)
|
|
JsonSash.SashList.Add(SashDimension.Serialize());
|
|
foreach (var BottomRailDim in BottomRailElemDimList)
|
|
JsonSash.BottomRailElemDimList.Add(BottomRailDim.Serialize());
|
|
if (HwOptionList.Count > 0)
|
|
{
|
|
foreach (var HwOption in HwOptionList)
|
|
JsonSash.HwOptionList.Add(HwOption.Serialize());
|
|
}
|
|
//else if(currHwId != "000000")
|
|
//{
|
|
// foreach (var HwOption in SelHwOptionList)
|
|
// JsonSash.HwOptionList.Add(new JsonHwOption(HwOption.Key, HwOption.Value));
|
|
//}
|
|
//if (SashArcElem != null)
|
|
// JsonSash.ArcElement = SashArcElem.Serialize();
|
|
//else
|
|
// JsonSash.ArcElement = null;
|
|
foreach (var Area in AreaList)
|
|
JsonSash.AreaList.Add(Area.Serialize(hideHw));
|
|
return JsonSash;
|
|
}
|
|
|
|
//internal void SetSashArcElem(SashArcElement arcElement)
|
|
//{
|
|
// m_SashArcElement = arcElement;
|
|
//}
|
|
|
|
internal void SetFirstHardware()
|
|
{
|
|
if (m_HardwareList.Count > 0)
|
|
{
|
|
m_SelHardware = m_HardwareList.First();
|
|
}
|
|
}
|
|
|
|
internal void SetIsSashVertical(bool IsSashVertical)
|
|
{
|
|
m_bIsSashVertical = IsSashVertical;
|
|
if (IsSashVertical)
|
|
{
|
|
m_SelOrientationSashType = OrientationSash.VERTICAL;
|
|
}
|
|
else
|
|
{
|
|
m_SelOrientationSashType = OrientationSash.HORIZONTAL;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per impostare opzioni hardware da xml
|
|
/// </summary>
|
|
/// <param name="OptionXml"></param>
|
|
internal void SetHardwareOption(string OptionXml)
|
|
{
|
|
if (!string.IsNullOrEmpty(OptionXml))
|
|
{
|
|
ParametriOpzioni? HwOptions = new ParametriOpzioni();
|
|
XmlSerializer serializer = new XmlSerializer(typeof(ParametriOpzioni));
|
|
StringReader reader = new StringReader(OptionXml);
|
|
HwOptions = (ParametriOpzioni?)serializer.Deserialize(reader);
|
|
if (HwOptions != null && HwOptions.Items != null)
|
|
{
|
|
m_HwOptionList.Clear();
|
|
foreach (var HwOption in HwOptions.Items)
|
|
{
|
|
switch (HwOption.Tipo)
|
|
{
|
|
case "Text":
|
|
{
|
|
m_HwOptionList.Add(new AGBOptionText(HwOption));
|
|
break;
|
|
}
|
|
case "List":
|
|
{
|
|
m_HwOptionList.Add(new AGBOptionCombo(HwOption));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (SelHwOptionList.Count > 0)
|
|
{
|
|
foreach (var HwOption in HwOptionList)
|
|
{
|
|
// Ricerca dell'opzioni nei valori già selezionati
|
|
var selHwOption = (SelHwOptionList.Where(x => x.Key == HwOption.sName).FirstOrDefault()).Value;
|
|
if (selHwOption != null)
|
|
{
|
|
switch (HwOption.Type)
|
|
{
|
|
case HwOptionTypes.COMBO:
|
|
{
|
|
AGBOptionCombo OptCombo = (AGBOptionCombo)HwOption;
|
|
var selValue = OptCombo.ValueList.Where(x => x.sValue == selHwOption).FirstOrDefault();
|
|
if (selValue != null)
|
|
OptCombo.sValue = selValue;
|
|
else
|
|
OptCombo.sValue = OptCombo.ValueList.First();
|
|
break;
|
|
}
|
|
case HwOptionTypes.TEXT:
|
|
{
|
|
AGBOptionText OptText = (AGBOptionText)HwOption;
|
|
if(OptText.ValueList.FirstOrDefault(x => x.Equals(selHwOption)) != null || OptText.sName.Equals("HMan"))
|
|
OptText.sValue = selHwOption;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SelHwOptionList.Add(HwOption.sName, HwOption.sDescription);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void SetOrientationSashType(OrientationSash value)
|
|
{
|
|
m_SelOrientationSashType = value;
|
|
}
|
|
|
|
internal void SetSashBottomRail(bool bBottomRail)
|
|
{
|
|
m_bSashBottomRail = bBottomRail;
|
|
}
|
|
|
|
internal void SetSashBottomRailQty(int nBottomRailQty)
|
|
{
|
|
m_nSashBottomRailQty = nBottomRailQty;
|
|
}
|
|
|
|
internal void SetSashQty(int Qty)
|
|
{
|
|
if (Qty >= 0 && Qty <= 4)
|
|
{
|
|
if (Qty > m_SashList.Count)
|
|
{
|
|
// recupero larghezza ultimo
|
|
double dLastDimension = 100;
|
|
double dNewDimension = 100;
|
|
if (m_SashList.Count > 0)
|
|
{
|
|
dLastDimension = m_SashList[m_SashList.Count - 1].dDimension;
|
|
dNewDimension = dLastDimension / (Qty + 1 - nSashQty);
|
|
m_SashList[m_SashList.Count - 1].dDimension = dNewDimension;
|
|
}
|
|
else
|
|
dNewDimension = dLastDimension / (Qty + 1 - nSashQty);
|
|
// aggiungo area Sash di default
|
|
for (var SplitIndex = m_SashList.Count; SplitIndex <= Qty - 1; SplitIndex++)
|
|
{
|
|
SashDimension newSashDim = new SashDimension(dNewDimension, MeasureTypes.PERCENTAGE, this, SplitIndex + 1);
|
|
SashList.Add(newSashDim);
|
|
}
|
|
}
|
|
else if (Qty < m_SashList.Count)
|
|
{
|
|
for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= Qty; SplitIndex += -1)
|
|
SashList.RemoveAt(SplitIndex);
|
|
}
|
|
}
|
|
}
|
|
|
|
//internal void SetSashType(SashTypes SashType)
|
|
//{
|
|
// m_SashType = SashType;
|
|
//}
|
|
|
|
internal string SetSelFamilyHardwareFromIndex(string codHardware)
|
|
{
|
|
if(codHardware != "000000")
|
|
{
|
|
string? item = "";
|
|
if (string.IsNullOrEmpty(m_SelFamilyHardware))
|
|
{
|
|
item = m_HardwareCompleteList
|
|
.Where(x => x.Id == codHardware)
|
|
.Select(x => x.FamilyName)
|
|
.FirstOrDefault();
|
|
SetSelFamilyHardware(item ?? "");
|
|
}
|
|
}
|
|
return m_SelFamilyHardware;
|
|
}
|
|
|
|
internal void SetSelHardwareFromId(string sId)
|
|
{
|
|
if (m_HardwareList.Count == 0)
|
|
m_SelHardware = m_HardwareCompleteList.FirstOrDefault(x => x.Id.Equals(sId)) ?? new Hardware(CustomHwId, "", "", Enums.OpeningTypes.Null, "", 0, 0);
|
|
else
|
|
m_SelHardware = m_HardwareList.FirstOrDefault(x => x.Id.Equals(sId)) ?? new Hardware(CustomHwId, "", "", Enums.OpeningTypes.Null, "", 0, 0);
|
|
if (SelHardware.Id == "")
|
|
m_SelHardware = m_HardwareList.First();
|
|
if (SelHardware.Id == CustomHwId)
|
|
{
|
|
HwOptionList.Clear();
|
|
SelHwOptionList.Clear();
|
|
}
|
|
}
|
|
|
|
internal AreaFound CalculateWidthSashGroup(Area area, double width, AreaFound res)
|
|
{
|
|
for (int i = 0; i < area.AreaList.Count; i++)
|
|
{
|
|
if (area.Equals(this))
|
|
{
|
|
res.m_Dimension = width;
|
|
res.m_Found = true;
|
|
return res;
|
|
}
|
|
Area item = area.AreaList[i];
|
|
if (area is Split split)
|
|
{
|
|
if (split.SplitVertList.Count > 0)
|
|
{
|
|
double dim = width;
|
|
double widthGlass = width;
|
|
foreach (var elem in split.ElemDimVertList)
|
|
{
|
|
widthGlass = widthGlass - elem.dDimension;
|
|
}
|
|
switch (split.SplitVertList.ElementAt(i).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
dim = split.SplitVertList.ElementAt(i).dDimension;
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
|
|
AreaDimension ad = new AreaDimension(split.SplitVertList.ElementAt(i).dDimension, split.SplitVertList.ElementAt(i).SelMeasureType, split.SplitVertList.ElementAt(i).Parent);
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in split.SplitVertList)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
|
|
}
|
|
dim = ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, widthGlass);
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
dim = split.SplitVertList.ElementAt(i).dDimension * widthGlass / 100;
|
|
break;
|
|
}
|
|
}
|
|
if (split.ParentArea is Frame frame && split.AreaList.ElementAt(i).AreaList.First() is Sash sash)
|
|
dim = dim + sash.SashList.First().ElementDimensionList.Last().dOverlap
|
|
+ sash.SashList.Last().ElementDimensionList.ElementAt(1).dOverlap;
|
|
res = CalculateWidthSashGroup(item, dim, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
else
|
|
{
|
|
double dim = width;
|
|
if (split.SplitHorizList.Count > 0 && split.AreaList.ElementAt(i).AreaList.First() is Sash sash)
|
|
{
|
|
dim = dim + sash.SashList.First().ElementDimensionList.Last().dOverlap
|
|
+ sash.SashList.Last().ElementDimensionList.ElementAt(1).dOverlap;
|
|
}
|
|
res = CalculateWidthSashGroup(item, dim, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
}
|
|
else if (area is Sash sash)
|
|
{
|
|
switch (sash.SashList.ElementAt(i).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
res = CalculateWidthSashGroup(item, sash.SashList.ElementAt(i).dDimension, res);
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
SashDimension anta = sash.SashList.ElementAt(i);
|
|
AreaDimension ad = new AreaDimension(anta.dDimension, anta.SelMeasureType, anta.Parent);
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in sash.SashList)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
|
|
}
|
|
res = CalculateWidthSashGroup(item, ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, width), res);
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
res = CalculateWidthSashGroup(item, sash.SashList.ElementAt(i).dDimension * width / 100, res);
|
|
break;
|
|
}
|
|
}
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
else
|
|
{
|
|
res = CalculateWidthSashGroup(item, width, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
internal AreaFound CalculateHeightSashGroup(Area area, double height, AreaFound res)
|
|
{
|
|
for (int i = 0; i < area.AreaList.Count; i++)
|
|
{
|
|
if (area.Equals(this))
|
|
{
|
|
res.m_Dimension = height;
|
|
res.m_Found = true;
|
|
return res;
|
|
}
|
|
Area item = area.AreaList[i];
|
|
if (area is Split split)
|
|
{
|
|
if (split.SplitVertList.Count > 0)
|
|
{
|
|
double dim = height;
|
|
res = CalculateHeightSashGroup(item, dim, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
else
|
|
{
|
|
double dim = height;
|
|
double widthGlass = height;
|
|
int minSubArea = split.ElemDimHorizList.Min(x => x.nSubArea);
|
|
foreach (var elem in split.ElemDimHorizList.Where(x => x.nSubArea == minSubArea))
|
|
{
|
|
widthGlass = widthGlass - elem.dDimension;
|
|
}
|
|
switch (split.SplitHorizList.ElementAt(i).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
dim = split.SplitHorizList.ElementAt(i).dDimension;
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
|
|
AreaDimension ad = new AreaDimension(split.SplitHorizList.ElementAt(i).dDimension, split.SplitHorizList.ElementAt(i).SelMeasureType, split.SplitHorizList.ElementAt(i).Parent);
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in split.SplitHorizList)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
|
|
}
|
|
dim = ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, widthGlass);
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
dim = split.SplitHorizList.ElementAt(i).dDimension * widthGlass / 100;
|
|
break;
|
|
}
|
|
}
|
|
if (split.ParentArea is Frame frame && split.AreaList.ElementAt(i).AreaList.First() is Sash sash)
|
|
dim = dim + sash.SashList.First().ElementDimensionList.First().dOverlap
|
|
+ sash.SashList.First().ElementDimensionList.ElementAt(sash.SashList.First().ElementDimensionList.Count - 2).dOverlap;
|
|
res = CalculateHeightSashGroup(item, dim, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
res = CalculateHeightSashGroup(item, height, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
#endregion Internal Methods
|
|
|
|
#region Private Fields
|
|
|
|
/// <summary>
|
|
/// Codice HW custom x gestione casi non risolvibili di selezione
|
|
/// </summary>
|
|
private const string CustomHwId = "000000";
|
|
|
|
private bool m_bIsSashVertical;
|
|
|
|
private bool m_bSashBottomRail;
|
|
|
|
private string m_CurrShape = "";
|
|
private List<Hardware> m_HardwareList = new List<Hardware>();
|
|
private List<AGBOption> m_HwOptionList = new List<AGBOption>();
|
|
private Dictionary<string, string> m_SelHwOptionList = new Dictionary<string, string>();
|
|
|
|
private int m_nSashBottomRailQty;
|
|
private List<ElementDimension> m_BottomRailElemDimList = new List<ElementDimension>();
|
|
private List<IdNameStruct> m_OrientationSashTypeList = new List<IdNameStruct>
|
|
{
|
|
new IdNameStruct((int)OrientationSash.VERTICAL, "Vertical"),
|
|
new IdNameStruct((int)OrientationSash.HORIZONTAL, "Horizontal"),
|
|
};
|
|
|
|
private List<SashDimension> m_SashList = new List<SashDimension>();
|
|
private SashTypes m_SashType;
|
|
private string m_SelFamilyHardware = "";
|
|
private Hardware? m_SelHardware = null;
|
|
private OrientationSash m_SelOrientationSashType;
|
|
//private SashArcElement m_SashArcElement;
|
|
|
|
private bool m_IsbDimensionLight = false;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Methods
|
|
|
|
private Enums.OpeningTypes ConvertOpeningType()
|
|
{
|
|
var answ = Enums.OpeningTypes.Null;
|
|
if (m_SashList.Count > 1)
|
|
{
|
|
for (int i = 0; i < m_SashList.Count; i++)
|
|
{
|
|
if (m_SashList[i].bHasHandle)
|
|
{
|
|
answ = GetOpeningType(m_SashList[i].OpeningType);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
answ = GetOpeningType(m_SashList.First().OpeningType);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |