Annamaria Sassi
544 lines
23 KiB
C#
544 lines
23 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using WebWindowTest.Json;
|
|
using static WebWindowTest.Json.WindowConst;
|
|
|
|
namespace WebWindowTest.Models
|
|
{
|
|
public class Split : Area
|
|
{
|
|
#region Public Constructors
|
|
|
|
public Split(Area ParentArea, Window ParentWindow) : base(ParentArea, ParentWindow)
|
|
{
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
//public bool bIsPercentage
|
|
//{
|
|
// get
|
|
// {
|
|
// return m_bIsPercentage;
|
|
// }
|
|
//}
|
|
|
|
public bool bSplitStartVert
|
|
{
|
|
get
|
|
{
|
|
return m_bSplitStartVert;
|
|
}
|
|
set
|
|
{
|
|
m_bSplitStartVert = value;
|
|
}
|
|
}
|
|
|
|
public int nSplitQtyHoriz
|
|
{
|
|
get
|
|
{
|
|
return m_SplitHorizList.Count > 0 ? m_SplitHorizList.Count - 1 : 0;
|
|
}
|
|
set
|
|
{
|
|
if(value >= 0 && value < 6)
|
|
{
|
|
if (value == 0)
|
|
{
|
|
for (var SplitIndex = m_SplitHorizList.Count - 1; SplitIndex >= value; SplitIndex += -1)
|
|
m_SplitHorizList.RemoveAt(SplitIndex);
|
|
if (nSplitQtyVert == 0)
|
|
{
|
|
ParentArea.AreaList.Remove(this);
|
|
Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
ParentArea.AreaList.Add(newFill);
|
|
}
|
|
else
|
|
SetSplitShape(SplitShapes.VERTICAL);
|
|
}
|
|
else
|
|
{
|
|
double heightTot = CalculateHeightArea(ParentWindow.AreaList.First(), HeightFrame());
|
|
// Ricalcolo dimensioni aggiungendo split
|
|
if (value > m_SplitHorizList.Count - 1)
|
|
{
|
|
// recupero larghezza ultimo
|
|
double dLastDimension = heightTot;
|
|
double dNewDimension = heightTot;
|
|
if (m_SplitHorizList.Count > 0)
|
|
{
|
|
dLastDimension = m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension;
|
|
dNewDimension = dLastDimension / (value + 1 - nSplitQtyHoriz);
|
|
if (m_SplitHorizList[m_SplitHorizList.Count - 1].MeasureType.Equals(MeasureTypes.PROPORTIONAL))
|
|
dNewDimension = 1;
|
|
m_SplitHorizList[m_SplitHorizList.Count - 1].SetDimension(dNewDimension);
|
|
}
|
|
else
|
|
dNewDimension = dLastDimension / (value + 1 - nSplitQtyHoriz);
|
|
// aggiungo area Split di default
|
|
for (var SplitIndex = m_SplitHorizList.Count; SplitIndex <= value; SplitIndex++)
|
|
m_SplitHorizList.Add(new SplitDimension(dNewDimension, m_SplitHorizList[m_SplitHorizList.Count - 1].MeasureType, true, this, false));
|
|
}
|
|
// Ricalcolo dimensioni rimuovendo split
|
|
else
|
|
{
|
|
double dLastDimension = 0;
|
|
for (var SplitIndex = m_SplitHorizList.Count - 1; SplitIndex >= value + 1; SplitIndex += -1)
|
|
{
|
|
dLastDimension += m_SplitHorizList[SplitIndex].dDimension;
|
|
m_SplitHorizList.RemoveAt(SplitIndex);
|
|
}
|
|
dLastDimension += m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension;
|
|
m_SplitHorizList[m_SplitHorizList.Count - 1].SetDimension(dLastDimension);
|
|
}
|
|
// Controllo quanti split verticali ci sono
|
|
int nVert = m_SplitVertList.Count > 0 ? m_SplitVertList.Count : 1;
|
|
// Se aggiungo split devo aggiungere vetro nell'area splitted aggiunta
|
|
for (var SplitIndex = AreaList.Count; SplitIndex <= (m_SplitHorizList.Count * nVert) - 1; SplitIndex++)
|
|
{
|
|
AreaList.Add(Splitted.CreateSplitted(this));
|
|
Fill newFill = Fill.CreateFill(AreaList[SplitIndex], FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
AreaList[AreaList.Count - 1].AreaList.Add(newFill);
|
|
}
|
|
// Se ho più di uno split, elimino l'ultimo
|
|
if (AreaList.Count > 2)
|
|
{
|
|
int nAreaList = AreaList.Count - 1;
|
|
for (var SplitIndex = (m_SplitHorizList.Count * nVert); SplitIndex <= nAreaList; SplitIndex++)
|
|
{
|
|
AreaList.Remove(AreaList[AreaList.Count - 1]);
|
|
}
|
|
}
|
|
// Se elimino l'unico split presente
|
|
else
|
|
{
|
|
Splitted s = (Splitted)AreaList[0];
|
|
s.SetParentArea(ParentArea);
|
|
ParentArea.AreaList.Add(s);
|
|
ParentArea.AreaList.Remove(this);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public int nSplitQtyVert
|
|
{
|
|
get
|
|
{
|
|
return m_SplitVertList.Count > 0 ? m_SplitVertList.Count - 1 : 0;
|
|
}
|
|
set
|
|
{
|
|
if (value >= 0 && value < 6)
|
|
{
|
|
if (value == 0)
|
|
{
|
|
for (var SplitIndex = m_SplitVertList.Count - 1; SplitIndex >= value; SplitIndex += -1)
|
|
m_SplitVertList.RemoveAt(SplitIndex);
|
|
if (nSplitQtyHoriz == 0)
|
|
{
|
|
ParentArea.AreaList.Remove(this);
|
|
Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
ParentArea.AreaList.Add(newFill);
|
|
}
|
|
else
|
|
SetSplitShape(SplitShapes.HORIZONTAL);
|
|
}
|
|
else
|
|
{
|
|
double widthTot = CalculateWidthArea(ParentWindow.AreaList.First(), ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Width").First().dDimension);
|
|
// Ricalcolo dimensioni aggiungendo split
|
|
if (value > m_SplitVertList.Count - 1)
|
|
{
|
|
// recupero larghezza ultimo
|
|
double dLastDimension = widthTot;
|
|
double dNewDimension = widthTot;
|
|
if (m_SplitVertList.Count > 0)
|
|
{
|
|
dLastDimension = m_SplitVertList[m_SplitVertList.Count - 1].dDimension;
|
|
dNewDimension = dLastDimension / (value + 1 - nSplitQtyVert);
|
|
if (m_SplitVertList[m_SplitVertList.Count - 1].MeasureType.Equals(MeasureTypes.PROPORTIONAL))
|
|
dNewDimension = 1;
|
|
m_SplitVertList[m_SplitVertList.Count - 1].SetDimension(dNewDimension);
|
|
}
|
|
else
|
|
dNewDimension = dLastDimension / (value + 1 - nSplitQtyVert);
|
|
// aggiungo area Split di default
|
|
for (var SplitIndex = m_SplitVertList.Count; SplitIndex <= value; SplitIndex++)
|
|
m_SplitVertList.Add(new SplitDimension(dNewDimension, m_SplitVertList[m_SplitVertList.Count - 1].MeasureType, true, this, true));
|
|
}
|
|
else if (value == 0)
|
|
{
|
|
m_SplitVertList.RemoveAt(1);
|
|
m_SplitVertList.RemoveAt(0);
|
|
}
|
|
// Ricalcolo dimensioni rimuovendo split
|
|
else
|
|
{
|
|
int countProportional = m_SplitVertList.Count(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL));
|
|
if(m_SplitVertList.Last().MeasureType.Equals(MeasureTypes.PROPORTIONAL) && countProportional - 1 == 1)
|
|
{
|
|
m_SplitVertList.RemoveAt(m_SplitVertList.Count() - 1);
|
|
m_SplitVertList.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).FirstOrDefault().SetDimension(1);
|
|
}
|
|
else
|
|
{
|
|
double dLastDimension = 0;
|
|
for (var SplitIndex = m_SplitVertList.Count - 1; SplitIndex >= value + 1; SplitIndex += -1)
|
|
{
|
|
dLastDimension += m_SplitVertList[SplitIndex].dDimension;
|
|
m_SplitVertList.RemoveAt(SplitIndex);
|
|
}
|
|
dLastDimension += m_SplitVertList[m_SplitVertList.Count - 1].dDimension;
|
|
m_SplitVertList[m_SplitVertList.Count - 1].SetDimension(dLastDimension);
|
|
}
|
|
}
|
|
// Controllo quanti split orizzontali ci sono
|
|
int nHoriz = m_SplitHorizList.Count > 0 ? m_SplitHorizList.Count : 1;
|
|
// Se aggiungo split devo aggiungere vetro nell'area splitted aggiunta
|
|
for (var SplitIndex = AreaList.Count; SplitIndex <= (m_SplitVertList.Count * nHoriz) - 1; SplitIndex++)
|
|
{
|
|
AreaList.Add(Splitted.CreateSplitted(this));
|
|
Fill newFill = Fill.CreateFill(AreaList[SplitIndex], FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
AreaList[AreaList.Count - 1].AreaList.Add(newFill);
|
|
}
|
|
// Se ho più di uno split, elimino l'ultimo
|
|
if (AreaList.Count > 2)
|
|
{
|
|
int nAreaList = AreaList.Count - 1;
|
|
for (var SplitIndex = (m_SplitVertList.Count * nHoriz); SplitIndex <= nAreaList; SplitIndex++)
|
|
{
|
|
AreaList.Remove(AreaList[AreaList.Count - 1]);
|
|
}
|
|
}
|
|
// Se elimino l'unico split presente
|
|
else
|
|
{
|
|
Splitted s = (Splitted)AreaList[0];
|
|
s.SetParentArea(ParentArea);
|
|
ParentArea.AreaList.Add(s);
|
|
ParentArea.AreaList.Remove(this);
|
|
}
|
|
}
|
|
if(SplitHorizList.Count > 0)
|
|
{
|
|
for (int i = 0; i < AreaList.Count; i++)
|
|
{
|
|
if(i < SplitHorizList.Count)
|
|
AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), SplitHorizList.ElementAt(i).dDimension, "Width");
|
|
}
|
|
}
|
|
if (SplitVertList.Count > 0)
|
|
{
|
|
for (int i = 0; i < AreaList.Count; i++)
|
|
{
|
|
if(i < SplitVertList.Count)
|
|
AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), SplitVertList.ElementAt(i).dDimension, "Height");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public int SelSplitShapeIndex
|
|
{
|
|
get
|
|
{
|
|
return (int)m_SelSplitShape;
|
|
}
|
|
set
|
|
{
|
|
SplitShapes OldSelShapeSplit = m_SelSplitShape;
|
|
m_SelSplitShape = (SplitShapes)value;
|
|
// Azzero quantità orizzontale e verticale
|
|
SetSplitQtyVert(0);
|
|
SetSplitQtyHoriz(0);
|
|
if (m_SelSplitShape == SplitShapes.VERTICAL)
|
|
{
|
|
// Inserisco valori di default
|
|
SetSplitQtyVert(1);
|
|
SetSplitStartVert(true);
|
|
}
|
|
else if (m_SelSplitShape == SplitShapes.HORIZONTAL)
|
|
{
|
|
// Inserisco valori di default
|
|
SetSplitQtyHoriz(1);
|
|
SetSplitStartVert(false);
|
|
}
|
|
else
|
|
{
|
|
// Inserisco valori di default
|
|
SetSplitQtyVert(1);
|
|
SetSplitQtyHoriz(1);
|
|
SetSplitStartVert(true);
|
|
}
|
|
if(OldSelShapeSplit == SplitShapes.GRID || m_SelSplitShape == SplitShapes.GRID)
|
|
{
|
|
// Cancello vecchio contenuto dello split
|
|
AreaList.Clear();
|
|
// Aggiungo area Splitted e vetro
|
|
int nVert = m_SplitVertList.Count > 0 ? m_SplitVertList.Count : 1;
|
|
int nHoriz = m_SplitHorizList.Count > 0 ? m_SplitHorizList.Count : 1;
|
|
for (var SplitIndex = 0; SplitIndex <= (nVert * nHoriz) - 1; SplitIndex++)
|
|
{
|
|
AreaList.Add(Splitted.CreateSplitted(this));
|
|
Fill newFill = Fill.CreateFill(AreaList[SplitIndex], FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
AreaList[SplitIndex].AreaList.Add(newFill);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<SplitDimension> SplitHorizList
|
|
{
|
|
get
|
|
{
|
|
return m_SplitHorizList;
|
|
}
|
|
set
|
|
{
|
|
m_SplitHorizList = value;
|
|
}
|
|
}
|
|
|
|
public List<SplitDimension> SplitPositionList
|
|
{
|
|
get
|
|
{
|
|
return m_SplitPositionList;
|
|
}
|
|
set
|
|
{
|
|
m_SplitPositionList = value;
|
|
}
|
|
}
|
|
|
|
public List<IdNameStruct> SplitShapeList
|
|
{
|
|
get
|
|
{
|
|
return m_SplitShapeList;
|
|
}
|
|
}
|
|
|
|
public List<SplitDimension> SplitVertList
|
|
{
|
|
get
|
|
{
|
|
return m_SplitVertList;
|
|
}
|
|
set
|
|
{
|
|
m_SplitVertList = value;
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
public override Split Copy(Area newParentArea)
|
|
{
|
|
Split newSplit = new Split(newParentArea, ParentWindow);
|
|
AddCounterGroup();
|
|
newSplit.SetGroupId(nCounterGroup);
|
|
newSplit.SetSplitStartVert(bSplitStartVert);
|
|
for (int i = 0; i < SplitVertList.Count; i++)
|
|
newSplit.SplitVertList.Add(SplitVertList[i].Copy());
|
|
for (int i = 0; i < SplitHorizList.Count; i++)
|
|
newSplit.SplitHorizList.Add(SplitHorizList[i].Copy());
|
|
//newSplit.SetSplitQtyVert(nSplitQtyVert);
|
|
//for (int i = 0; i < SplitVertList.Count; i++)
|
|
// newSplit.SplitVertList.ElementAt(i).SetDimension(SplitVertList.ElementAt(i).dDimension);
|
|
//newSplit.SetSplitQtyHoriz(nSplitQtyHoriz);
|
|
//for (int i = 0; i < SplitHorizList.Count; i++)
|
|
// newSplit.SplitHorizList.ElementAt(i).SetDimension(SplitHorizList.ElementAt(i).dDimension);
|
|
newSplit.SetSplitShape(SelSplitShape);
|
|
newSplit.SetAreaType(AreaType);
|
|
foreach (var item in AreaList)
|
|
{
|
|
Area a = item.Copy(newSplit);
|
|
newSplit.AreaList.Add(a);
|
|
}
|
|
return newSplit;
|
|
}
|
|
|
|
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());
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Internal Properties
|
|
|
|
internal SplitShapes SelSplitShape
|
|
{
|
|
get
|
|
{
|
|
return m_SelSplitShape;
|
|
}
|
|
}
|
|
|
|
#endregion Internal Properties
|
|
|
|
#region Internal Methods
|
|
|
|
internal static Split CreateSplit(Area Area, SplitShapes SplitShape)
|
|
{
|
|
Split Split = new Split(Area, Area.ParentWindow);
|
|
AddCounterGroup();
|
|
Split.SetGroupId(nCounterGroup);
|
|
Split.SetAreaType(AreaTypes.SPLIT);
|
|
Split.SetSplitShape(SplitShape);
|
|
return Split;
|
|
}
|
|
|
|
internal override JsonArea Serialize(bool hideHw)
|
|
{
|
|
if (nCounterGroup < GroupId)
|
|
Area.nCounterGroup = GroupId;
|
|
JsonSplit JsonSplit = new JsonSplit(m_SelSplitShape, GroupId);
|
|
//foreach (var SplitPosition in m_SplitPositionList)
|
|
// JsonSplit.SplitPositionList.Add(SplitPosition.Serialize());
|
|
JsonSplit.SplitStartVert = bSplitStartVert;
|
|
foreach (var SplitVert in m_SplitVertList)
|
|
JsonSplit.SplitVertList.Add(SplitVert.Serialize());
|
|
foreach (var SplitHoriz in m_SplitHorizList)
|
|
JsonSplit.SplitHorizList.Add(SplitHoriz.Serialize());
|
|
foreach (var Area in AreaList)
|
|
JsonSplit.AreaList.Add(Area.Serialize(hideHw));
|
|
return JsonSplit;
|
|
}
|
|
|
|
internal void SetSplitQtyHoriz(int QtyHoriz)
|
|
{
|
|
if (QtyHoriz > m_SplitHorizList.Count)
|
|
{
|
|
// recupero larghezza ultimo
|
|
double dLastDimension = 100;
|
|
double dNewDimension = 100;
|
|
if (m_SplitHorizList.Count > 0)
|
|
{
|
|
dLastDimension = m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension;
|
|
dNewDimension = dLastDimension / (QtyHoriz + 1 - nSplitQtyHoriz);
|
|
m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension = dNewDimension;
|
|
}
|
|
else
|
|
dNewDimension = dLastDimension / (QtyHoriz + 1 - nSplitQtyHoriz);
|
|
// aggiungo area Split di default
|
|
for (var SplitIndex = m_SplitHorizList.Count; SplitIndex <= QtyHoriz; SplitIndex++)
|
|
m_SplitHorizList.Add(new SplitDimension(dNewDimension, MeasureTypes.PERCENTAGE, true, this, false));
|
|
}
|
|
else if (QtyHoriz < m_SplitHorizList.Count)
|
|
{
|
|
for (var SplitIndex = m_SplitHorizList.Count - 1; SplitIndex >= QtyHoriz; SplitIndex += -1)
|
|
m_SplitHorizList.RemoveAt(SplitIndex);
|
|
}
|
|
}
|
|
|
|
internal void SetSplitQtyVert(int QtyVert)
|
|
{
|
|
if (QtyVert > m_SplitVertList.Count)
|
|
{
|
|
// recupero larghezza ultimo
|
|
double dLastDimension = 100;
|
|
double dNewDimension = 100;
|
|
if (m_SplitVertList.Count > 0)
|
|
{
|
|
dLastDimension = m_SplitVertList[m_SplitVertList.Count - 1].dDimension;
|
|
dNewDimension = dLastDimension / (QtyVert + 1 - nSplitQtyVert);
|
|
m_SplitVertList[m_SplitVertList.Count - 1].dDimension = dNewDimension;
|
|
}
|
|
else
|
|
dNewDimension = dLastDimension / (QtyVert + 1 - nSplitQtyVert);
|
|
// aggiungo area Split di default
|
|
for (var SplitIndex = m_SplitVertList.Count; SplitIndex <= QtyVert; SplitIndex++)
|
|
m_SplitVertList.Add(new SplitDimension(dNewDimension, MeasureTypes.PERCENTAGE, true, this, true));
|
|
}
|
|
else if (QtyVert < m_SplitVertList.Count)
|
|
{
|
|
for (var SplitIndex = m_SplitVertList.Count - 1; SplitIndex >= QtyVert; SplitIndex += -1)
|
|
m_SplitVertList.RemoveAt(SplitIndex);
|
|
}
|
|
}
|
|
|
|
internal void SetSplitShape(SplitShapes Value)
|
|
{
|
|
m_SelSplitShape = Value;
|
|
}
|
|
|
|
internal void SetSplitStartVert(bool SplitStartVert)
|
|
{
|
|
m_bSplitStartVert = SplitStartVert;
|
|
}
|
|
|
|
internal double HeightFrame()
|
|
{
|
|
switch (ParentWindow.AreaList.First().SelShapeIndex)
|
|
{
|
|
case (int)Shapes.RECTANGLE:
|
|
case (int)Shapes.TRIANGLE:
|
|
case (int)Shapes.ARC_FULL:
|
|
{
|
|
return ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Height").First().dDimension;
|
|
}
|
|
case (int)Shapes.RIGHTCHAMFER:
|
|
{
|
|
return ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Left Height").First().dDimension;
|
|
}
|
|
case (int)Shapes.LEFTCHAMFER:
|
|
{
|
|
return ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Right Height").First().dDimension;
|
|
}
|
|
default:
|
|
{
|
|
return ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Full Height").First().dDimension;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Internal Methods
|
|
|
|
#region Private Fields
|
|
|
|
private bool m_bIsPercentage = true;
|
|
private bool m_bSplitStartVert = true;
|
|
private SplitShapes m_SelSplitShape;
|
|
|
|
private List<SplitDimension> m_SplitHorizList = new List<SplitDimension>();
|
|
|
|
private List<SplitDimension> m_SplitPositionList = new List<SplitDimension>();
|
|
|
|
private List<IdNameStruct> m_SplitShapeList = new List<IdNameStruct>
|
|
{
|
|
new IdNameStruct((int)SplitShapes.VERTICAL, "Vertical"),
|
|
new IdNameStruct((int)SplitShapes.HORIZONTAL, "Horizontal"),
|
|
new IdNameStruct((int)SplitShapes.GRID, "Grid"),
|
|
new IdNameStruct((int)SplitShapes.CUSTOM, "Custom")
|
|
};
|
|
|
|
private List<SplitDimension> m_SplitVertList = new List<SplitDimension>();
|
|
|
|
//private double m_Width = 0;
|
|
|
|
#endregion Private Fields
|
|
}
|
|
} |