Annamaria Sassi
864 lines
29 KiB
C#
864 lines
29 KiB
C#
using Egw.Window.Data;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data.SqlTypes;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
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 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 Events
|
|
|
|
public event EventHandler<OnReqShapeEventArgs> OnReqShape = delegate { };
|
|
public event EventHandler<OnReqHwOptEventArgs> OnReqHwOption = delegate { };
|
|
|
|
#endregion Public Events
|
|
|
|
#region Public Properties
|
|
|
|
public bool bIsMeasureGlass
|
|
{
|
|
get
|
|
{
|
|
return m_bIsMeasureGlass;
|
|
}
|
|
set
|
|
{
|
|
m_bIsMeasureGlass = value;
|
|
}
|
|
}
|
|
|
|
public bool bIsPercentage
|
|
{
|
|
get
|
|
{
|
|
return m_bIsPercentage;
|
|
}
|
|
}
|
|
|
|
public bool bIsSashVertical
|
|
{
|
|
get
|
|
{
|
|
return m_bIsSashVertical;
|
|
}
|
|
set
|
|
{
|
|
m_bIsSashVertical = value;
|
|
}
|
|
}
|
|
|
|
public List<Hardware> HardwareList
|
|
{
|
|
get
|
|
{
|
|
return m_HardwareList;
|
|
}
|
|
}
|
|
|
|
public List<AGBOption> HwOptionList
|
|
{
|
|
get
|
|
{
|
|
return m_HwdOptionList;
|
|
}
|
|
}
|
|
|
|
public List<Joint> JointList
|
|
{
|
|
get
|
|
{
|
|
return m_JointList;
|
|
}
|
|
set
|
|
{
|
|
m_JointList = value;
|
|
}
|
|
}
|
|
|
|
public int nSashQty
|
|
{
|
|
get
|
|
{
|
|
return m_SashList.Count > 0 ? m_SashList.Count : 1;
|
|
}
|
|
set
|
|
{
|
|
if (value >= 0 && value <= 4)
|
|
{
|
|
if (value > 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 / (value + 1 - nSashQty);
|
|
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++)
|
|
{
|
|
SashList.Add(new SashDimension(dNewDimension, true, this, SplitIndex + 1));
|
|
}
|
|
}
|
|
else if (value < m_SashList.Count)
|
|
{
|
|
if (value > 0)
|
|
{
|
|
double dLastDimension = 0;
|
|
for (var SplitIndex = m_SashList.Count - 1; SplitIndex >= value; SplitIndex += -1)
|
|
{
|
|
dLastDimension += m_SashList[SplitIndex].dDimension;
|
|
SashList.RemoveAt(SplitIndex);
|
|
}
|
|
dLastDimension += m_SashList[SashList.Count - 1].dDimension;
|
|
SashList[SashList.Count - 1].SetDimension(dLastDimension);
|
|
if (value == 1)
|
|
SashList.First().SetHasHandle(true);
|
|
}
|
|
else
|
|
{
|
|
SashList.RemoveAt(0);
|
|
}
|
|
}
|
|
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 < AreaList.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
|
|
Fill newFill = Fill.CreateFill(AreaList[1], FillTypes.GLASS);
|
|
//Fill newFill = new Fill(AreaList[1], ParentWindow);
|
|
//newFill.SetFillType(FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
AreaList[AreaList.Count - 1].AreaList.Add(newFill);
|
|
}
|
|
// Se tolgo anta
|
|
else
|
|
{
|
|
for (int SplitIndex = SashList.Count; SplitIndex <= AreaList.Count() - 1; SplitIndex++)
|
|
{
|
|
AreaList.Remove(AreaList[AreaList.Count - 1]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ReqRefreshShape();
|
|
RefreshHardwareOptionList();
|
|
SetFirstHardware();
|
|
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
|
}
|
|
}
|
|
|
|
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
|
|
{
|
|
// Controllo che il valore inserito sia positivo
|
|
if (value >= 0)
|
|
{
|
|
m_nSashBottomRailQty = value;
|
|
if (m_nSashBottomRailQty > 0)
|
|
{
|
|
m_bSashBottomRail = true;
|
|
}
|
|
else
|
|
{
|
|
m_bSashBottomRail = false;
|
|
}
|
|
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
|
}
|
|
}
|
|
|
|
public Hardware SelHardware
|
|
{
|
|
get
|
|
{
|
|
return m_SelHardware;
|
|
}
|
|
set
|
|
{
|
|
m_SelHardware = value;
|
|
ReqRefreshHwOption();
|
|
}
|
|
}
|
|
|
|
public string SelHardwareFromId
|
|
{
|
|
get
|
|
{
|
|
return m_SelHardware.Id;
|
|
}
|
|
set
|
|
{
|
|
m_SelHardware = m_HardwareList.FirstOrDefault(x => !string.IsNullOrEmpty(value) && x.Id.Equals(value)) ?? new Hardware("", "", "", Enums.OpeningTypes.Null, "", 0, 0);
|
|
ReqRefreshHwOption();
|
|
ParentWindow.OnUpdatePreview(ParentWindow.sSerialized());
|
|
}
|
|
}
|
|
|
|
public OrientationSash SelOrientationSashType
|
|
{
|
|
get
|
|
{
|
|
return m_SelOrientationSashType;
|
|
}
|
|
set
|
|
{
|
|
m_SelOrientationSashType = value;
|
|
}
|
|
}
|
|
|
|
public int SelOrientationSashTypeIndex
|
|
{
|
|
get
|
|
{
|
|
return IdNameStruct.IndFromId((int)m_SelOrientationSashType, m_OrientationSashTypeList);
|
|
}
|
|
set
|
|
{
|
|
m_SelOrientationSashType = (OrientationSash)IdNameStruct.IdFromInd(value, m_OrientationSashTypeList);
|
|
if (value == 0)
|
|
{
|
|
m_bIsSashVertical = true;
|
|
}
|
|
else
|
|
{
|
|
m_bIsSashVertical = false;
|
|
}
|
|
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
|
}
|
|
}
|
|
|
|
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);
|
|
newSash.SetSelFamilyHardwareFromIndex(SelHardware.Id);
|
|
newSash.ReqRefreshShape();
|
|
newSash.RefreshHardwareOptionList();
|
|
newSash.SetSelHardware(SelHardware);
|
|
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 JointList)
|
|
{
|
|
Joint newJoint = item.Copy();
|
|
newSash.JointList.Add(newJoint);
|
|
}
|
|
foreach (var item in AreaList)
|
|
{
|
|
Area newArea = item.Copy(newSash);
|
|
newSash.AreaList.Add(newArea);
|
|
}
|
|
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();
|
|
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)
|
|
)
|
|
.ToList();
|
|
if (rawList != null && rawList.Count > 0)
|
|
{
|
|
m_HardwareList = new List<Hardware>(rawList);
|
|
}
|
|
else
|
|
{
|
|
m_HardwareList = new List<Hardware>();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Remove()
|
|
{
|
|
ParentArea.AreaList.Remove(this);
|
|
Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
ParentArea.AreaList.Add(newFill);
|
|
m_ParentWindow.OnUpdatePreview(m_ParentWindow.sSerialized());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Richiesta calcolo shape corrente
|
|
/// </summary>
|
|
public void ReqRefreshShape()
|
|
{
|
|
if (m_HardwareCompleteList != null && m_HardwareCompleteList.Count > 0)
|
|
{
|
|
m_HardwareList.Clear();
|
|
// reset shape corrente
|
|
m_CurrShape = "";
|
|
|
|
// chiamata evento calcolo shape: gruppo da calcolare
|
|
OnReqShapePreview(m_ParentWindow.sSerialized(), GroupId);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Richiesta calcolo hardware option list
|
|
/// </summary>
|
|
public void ReqRefreshHwOption()
|
|
{
|
|
HwOptionList.Clear();
|
|
// chiamata evento calcolo opzioni hardware
|
|
OnReqHwOptionPreview(m_ParentWindow.sSerialized(), SelHardware.Id);
|
|
}
|
|
|
|
public void SetSelFamilyHardware(string sFamilyHw)
|
|
{
|
|
m_SelFamilyHardware = sFamilyHw;
|
|
// se ho la shape aggiorno elenco HW
|
|
if (!string.IsNullOrEmpty(m_CurrShape))
|
|
{
|
|
RefreshHardwareList();
|
|
}
|
|
RefreshHardwareOptionList();
|
|
SetFirstHardware();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiornamento HW List 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
|
|
.Where(x => x.Shape == m_CurrShape && x.SashQty == nSashQty && x.OpeningType == ConvertOpeningType())
|
|
.FirstOrDefault();
|
|
SetSelFamilyHardware(listHwValid.FamilyName);
|
|
}
|
|
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();
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Internal Methods
|
|
|
|
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);
|
|
for (var JointIndex = 0; JointIndex <= 3; JointIndex++)
|
|
newSash.JointList.Add(new Joint(newSash, JointIndex + 1, Joints.FULL_H));
|
|
newSash.SetSashBottomRail(false);
|
|
newSash.SetSashBottomRailQty(0);
|
|
newSash.SetSelFamilyHardware(Sash.s_FamilyHardwareList.First());
|
|
newSash.ReqRefreshShape();
|
|
newSash.RefreshHardwareOptionList();
|
|
newSash.SetFirstHardware();
|
|
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 OnReqShapePreview(string sJwd, int groupId)
|
|
{
|
|
OnReqShapeEventArgs e = new OnReqShapeEventArgs(sJwd, groupId);
|
|
EventHandler<OnReqShapeEventArgs> handler = OnReqShape;
|
|
if (handler != null)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
internal void OnReqHwOptionPreview(string sJwd, string codHw)
|
|
{
|
|
OnReqHwOptEventArgs e = new OnReqHwOptEventArgs(sJwd, codHw);
|
|
EventHandler<OnReqHwOptEventArgs> handler = OnReqHwOption;
|
|
if (handler != null)
|
|
{
|
|
handler(this, e);
|
|
}
|
|
}
|
|
|
|
internal void RefreshHardwareOptionList()
|
|
{
|
|
m_HwdOptionList.Clear();
|
|
}
|
|
|
|
internal override JsonArea Serialize()
|
|
{
|
|
if (nCounterGroup < GroupId)
|
|
Area.nCounterGroup = GroupId;
|
|
JsonSash JsonSash = new JsonSash(m_bIsSashVertical, m_SashType, m_bSashBottomRail, m_nSashBottomRailQty, m_SelHardware.Id, GroupId);
|
|
foreach (var SashDimension in SashList)
|
|
JsonSash.SashList.Add(SashDimension.Serialize());
|
|
foreach (var Joint in JointList)
|
|
JsonSash.JointList.Add(Joint.Serialize());
|
|
foreach (var Area in AreaList)
|
|
JsonSash.AreaList.Add(Area.Serialize());
|
|
return JsonSash;
|
|
}
|
|
|
|
internal void SetFirstHardware()
|
|
{
|
|
if (m_HardwareList.Count > 0)
|
|
{
|
|
m_SelHardware = m_HardwareList.First();
|
|
ReqRefreshHwOption();
|
|
}
|
|
}
|
|
|
|
internal void SetIsMeasureGlass(bool IsMeasureGlass)
|
|
{
|
|
m_bIsMeasureGlass = IsMeasureGlass;
|
|
}
|
|
|
|
internal void SetIsSashVertical(bool IsSashVertical)
|
|
{
|
|
m_bIsSashVertical = IsSashVertical;
|
|
if (IsSashVertical)
|
|
{
|
|
m_SelOrientationSashType = OrientationSash.VERTICAL;
|
|
}
|
|
else
|
|
{
|
|
m_SelOrientationSashType = OrientationSash.HORIZONTAL;
|
|
}
|
|
}
|
|
|
|
internal void SetHardwareOption(string OptionXml)
|
|
{
|
|
if (!string.IsNullOrEmpty(OptionXml))
|
|
{
|
|
ParametriOpzioni HwOptions = null;
|
|
XmlSerializer serializer = new XmlSerializer(typeof(ParametriOpzioni));
|
|
StringReader reader = new StringReader(OptionXml);
|
|
HwOptions = (ParametriOpzioni)serializer.Deserialize(reader);
|
|
if (HwOptions.Items != null)
|
|
{
|
|
m_HwdOptionList.Clear();
|
|
foreach (var HwOption in HwOptions.Items)
|
|
{
|
|
switch (HwOption.Tipo)
|
|
{
|
|
case "Text":
|
|
{
|
|
m_HwdOptionList.Add(new AGBOptionText(HwOption));
|
|
break;
|
|
}
|
|
case "List":
|
|
{
|
|
m_HwdOptionList.Add(new AGBOptionCombo(HwOption));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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++)
|
|
SashList.Add(new SashDimension(dNewDimension, true, this, SplitIndex + 1));
|
|
}
|
|
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)
|
|
{
|
|
string? item = "";
|
|
if (string.IsNullOrEmpty(m_SelFamilyHardware))
|
|
{
|
|
item = m_HardwareCompleteList
|
|
.Where(x => x.Id == codHardware)
|
|
.Select(x => x.FamilyName)
|
|
.FirstOrDefault();
|
|
SetSelFamilyHardware(item ?? "");
|
|
}
|
|
return SelFamilyHardware;
|
|
}
|
|
|
|
internal void SetSelHardware(Hardware value)
|
|
{
|
|
SelHardware = value;
|
|
}
|
|
|
|
internal void SetSelHardwareFromId(string sId)
|
|
{
|
|
if (m_HardwareList.Count == 0)
|
|
SelHardware = m_HardwareCompleteList.FirstOrDefault(x => x.Id.Equals(sId)) ?? new Hardware(CustomHwId, "", "", Enums.OpeningTypes.Null, "", 0, 0);
|
|
else
|
|
SelHardware = m_HardwareList.FirstOrDefault(x => x.Id.Equals(sId)) ?? new Hardware(CustomHwId, "", "", Enums.OpeningTypes.Null, "", 0, 0);
|
|
if (SelHardware.Id == "")
|
|
SelHardware = m_HardwareList.First();
|
|
ReqRefreshHwOption();
|
|
}
|
|
|
|
#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_bIsMeasureGlass;
|
|
|
|
private bool m_bIsPercentage = true;
|
|
|
|
private bool m_bIsSashVertical;
|
|
|
|
private bool m_bSashBottomRail;
|
|
|
|
private string m_CurrShape = "";
|
|
private List<Hardware> m_HardwareList = new List<Hardware>();
|
|
|
|
private List<AGBOption> m_HwdOptionList = new List<AGBOption>();
|
|
|
|
private List<Joint> m_JointList = new List<Joint>();
|
|
|
|
private int m_nSashBottomRailQty;
|
|
|
|
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;
|
|
private OrientationSash m_SelOrientationSashType;
|
|
|
|
#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
|
|
}
|
|
} |