Annamaria Sassi
1079 lines
54 KiB
C#
1079 lines
54 KiB
C#
using WebWindowComplex.Json;
|
|
using static WebWindowComplex.Json.WindowConst;
|
|
|
|
namespace WebWindowComplex.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 bSplitStartVert
|
|
{
|
|
get
|
|
{
|
|
return m_bSplitStartVert;
|
|
}
|
|
set
|
|
{
|
|
if(m_bSplitStartVert != value)
|
|
{
|
|
m_bSplitStartVert = value;
|
|
List<SplitElementDimension> elemVertListOld = new List<SplitElementDimension>(m_ElemDimVertList);
|
|
List<SplitElementDimension> elemHorizListOld = new List<SplitElementDimension>(m_ElemDimHorizList);
|
|
m_ElemDimVertList.Clear();
|
|
m_ElemDimHorizList.Clear();
|
|
double thickness = SetThickness();
|
|
if (value)
|
|
{
|
|
for (int i = 0; i < nSplitQtyVert; i++)
|
|
{
|
|
SplitElementDimension newVertElem = elemVertListOld.Where(x => x.nSubArea == 1 && x.nIndex == i + 1).First().Copy();
|
|
newVertElem.SetElement(i + 1, thickness, 0);
|
|
m_ElemDimVertList.Add(newVertElem);
|
|
//m_ElemDimVertList.Add(new SplitElementDimension(this, i + 1, thickness, 0));
|
|
}
|
|
for (int subArea = 0; subArea < m_SplitVertList.Count; subArea++)
|
|
{
|
|
for (int index = 0; index < nSplitQtyHoriz; index++)
|
|
{
|
|
SplitElementDimension newHorizElem = elemHorizListOld.Where(x => x.nIndex == index + 1).First().Copy();
|
|
newHorizElem.SetElement(index + 1, thickness, subArea + 1);
|
|
m_ElemDimHorizList.Add(newHorizElem);
|
|
//m_ElemDimHorizList.Add(new SplitElementDimension(this, index + 1, thickness, subArea + 1));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < nSplitQtyHoriz; i++)
|
|
{
|
|
SplitElementDimension newHorizElem = elemHorizListOld.Where(x => x.nSubArea == 1 && x.nIndex == i + 1).First().Copy();
|
|
newHorizElem.SetElement(i + 1, thickness, 0);
|
|
m_ElemDimHorizList.Add(newHorizElem);
|
|
//m_ElemDimHorizList.Add(new SplitElementDimension(this, i + 1, thickness, 0));
|
|
}
|
|
for (int subArea = 0; subArea < m_SplitHorizList.Count; subArea++)
|
|
{
|
|
for (int index = 0; index < nSplitQtyVert; index++)
|
|
{
|
|
SplitElementDimension newVertElem = elemVertListOld.Where(x => x.nIndex == index + 1).First().Copy();
|
|
newVertElem.SetElement(index + 1, thickness, subArea + 1);
|
|
m_ElemDimVertList.Add(newVertElem);
|
|
//m_ElemDimVertList.Add(new SplitElementDimension(this, index + 1, thickness, subArea + 1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual 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
|
|
{
|
|
ElemDimHorizList.RemoveAt(0);
|
|
SetSplitShape(SplitShapes.VERTICAL);
|
|
SetSplitStartVert(true);
|
|
// Controllo quanti split orizzontali ci sono
|
|
int nVert = m_SplitVertList.Count > 0 ? m_SplitVertList.Count : 1;
|
|
// Cancello aree di troppo
|
|
for (var SplitIndex = nVert; SplitIndex <= AreaList.Count; SplitIndex++)
|
|
AreaList.RemoveAt(AreaList.Count - 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Frame? frame = ParentWindow.AreaList.FirstOrDefault();
|
|
if(frame != null)
|
|
{
|
|
double heightTot = CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false)).m_Dimension;
|
|
//double heightTot = SplitHorizList.First().CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false)).m_Dimension;
|
|
// 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;
|
|
if(m_SplitHorizList.Last().MeasureType is MeasureTypes.ABSOLUTE)
|
|
dNewDimension = (dLastDimension - m_ElemDimHorizList.Last().dDimension) / (value + 1 - nSplitQtyHoriz);
|
|
else
|
|
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));
|
|
double thickness = SetThickness();
|
|
if (!m_bSplitStartVert)
|
|
{
|
|
//Aggiungo un elemento alla sottoarea principale
|
|
SplitElementDimension newElemDim = ElemDimHorizList.First().Copy();
|
|
newElemDim.SetElement(ElemDimHorizList.Max(x => x.nIndex) + 1, thickness, 0);
|
|
ElemDimHorizList.Add(newElemDim);
|
|
//ElemDimHorizList.Add(new SplitElementDimension(this, ElemDimHorizList.Max(x => x.nIndex) + 1, 78, 0));
|
|
if (nSplitQtyVert > 0)
|
|
{
|
|
// Aggiungo a tutte le sottoaree degli element
|
|
int subArea = ElemDimVertList.Max(x => x.nSubArea) + 1;
|
|
for (int i = 1; i <= ElemDimVertList.Max(x => x.nIndex); i++)
|
|
{
|
|
newElemDim = ElemDimVertList.First().Copy();
|
|
newElemDim.SetElement(i, thickness, subArea);
|
|
ElemDimVertList.Add(newElemDim);
|
|
//ElemDimVertList.Add(new SplitElementDimension(this, i, 78, subArea));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Aggiungo a tutte le sottoaree degli element
|
|
for (int i = 1; i <= ElemDimHorizList.Max(x => x.nSubArea); i++)
|
|
{
|
|
int index = ElemDimHorizList.Where(x => x.nSubArea == i).Max(x => x.nIndex);
|
|
SplitElementDimension newElemDim = ElemDimVertList.First().Copy();
|
|
newElemDim.SetElement(index + 1, thickness, i);
|
|
ElemDimHorizList.Insert(index * i + (i - 1), newElemDim);
|
|
//ElemDimHorizList.Insert(index * i + (i - 1), new SplitElementDimension(this, index + 1, thickness, i));
|
|
}
|
|
}
|
|
}
|
|
// Ricalcolo dimensioni rimuovendo split
|
|
else
|
|
{
|
|
int countProportional = m_SplitHorizList.Count(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL));
|
|
if (m_SplitHorizList.Last().MeasureType.Equals(MeasureTypes.PROPORTIONAL) && countProportional - 1 == 1)
|
|
{
|
|
m_SplitHorizList.RemoveAt(m_SplitVertList.Count() - 1);
|
|
m_SplitHorizList.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).FirstOrDefault()?.SetDimension(1);
|
|
}
|
|
else
|
|
{
|
|
double dLastDimension = 0;
|
|
for (var SplitIndex = m_SplitHorizList.Count - 1; SplitIndex >= value + 1; SplitIndex += -1)
|
|
{
|
|
dLastDimension += m_SplitHorizList[SplitIndex].dDimension;
|
|
if (m_SplitHorizList.Last().MeasureType.Equals(MeasureTypes.ABSOLUTE))
|
|
dLastDimension += m_ElemDimHorizList[SplitIndex - 1].dDimension;
|
|
m_SplitHorizList.RemoveAt(SplitIndex);
|
|
}
|
|
dLastDimension += m_SplitHorizList[m_SplitHorizList.Count - 1].dDimension;
|
|
m_SplitHorizList[m_SplitHorizList.Count - 1].SetDimension(dLastDimension);
|
|
}
|
|
if (m_bSplitStartVert)
|
|
{
|
|
// Rimuovo da tutte le sottoaree degli element l'ultimo elemento
|
|
for (int subArea = 1; subArea <= ElemDimHorizList.Max(x => x.nSubArea); subArea++)
|
|
{
|
|
SplitElementDimension? removeElem = ElemDimHorizList.Where(x => x.nSubArea == subArea).OrderByDescending(x => x.nIndex).FirstOrDefault();
|
|
if(removeElem != null)
|
|
ElemDimHorizList.Remove(removeElem);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int deleteSubArea = ElemDimHorizList.Count + 1;
|
|
for (var SplitIndex = ElemDimHorizList.Count - 1; SplitIndex >= value; SplitIndex += -1)
|
|
{
|
|
ElemDimHorizList.RemoveAt(ElemDimHorizList.Count - 1);
|
|
}
|
|
if(nSplitQtyVert > 0)
|
|
ElemDimVertList.RemoveAll(x => x.nSubArea == deleteSubArea);
|
|
}
|
|
}
|
|
// 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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//UpdateSubAreaSplit();
|
|
}
|
|
}
|
|
|
|
public virtual 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
|
|
{
|
|
ElemDimVertList.RemoveAt(0);
|
|
SetSplitShape(SplitShapes.HORIZONTAL);
|
|
SetSplitStartVert(false);
|
|
// Controllo quanti split orizzontali ci sono
|
|
int nHoriz = m_SplitHorizList.Count > 0 ? m_SplitHorizList.Count : 1;
|
|
// Cancello aree di troppo
|
|
for (var SplitIndex = nHoriz; SplitIndex <= AreaList.Count; SplitIndex++)
|
|
AreaList.RemoveAt(AreaList.Count-1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Frame? frame = ParentWindow.AreaList.FirstOrDefault();
|
|
if (frame != null)
|
|
{
|
|
double widthTot = CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
|
|
//double widthTot = CalculateWidthArea(frame, frame.AvailWidthArea());
|
|
// 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;
|
|
if (m_SplitVertList.Last().MeasureType is MeasureTypes.ABSOLUTE)
|
|
dNewDimension = (dLastDimension - ElemDimVertList.Last().dDimension) / (value + 1 - nSplitQtyVert);
|
|
else
|
|
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));
|
|
double thickness = SetThickness();
|
|
if (m_bSplitStartVert)
|
|
{
|
|
//Aggiungo un elemento alla sottoarea principale
|
|
SplitElementDimension newElemDim = ElemDimVertList.First().Copy();
|
|
newElemDim.SetElement(ElemDimVertList.Max(x => x.nIndex) + 1, thickness, 0);
|
|
ElemDimVertList.Add(newElemDim);
|
|
//ElemDimVertList.Add(new SplitElementDimension(this, ElemDimVertList.Max(x => x.nIndex) + 1, 78, 0));
|
|
if (nSplitQtyHoriz > 0)
|
|
{
|
|
// Aggiungo a tutte le sottoaree degli element
|
|
int subArea = ElemDimHorizList.Max(x => x.nSubArea) + 1;
|
|
for (int i = 1; i <= ElemDimHorizList.Max(x => x.nIndex); i++)
|
|
{
|
|
newElemDim = ElemDimHorizList.First().Copy();
|
|
newElemDim.SetElement(i, thickness, subArea);
|
|
ElemDimHorizList.Add(newElemDim);
|
|
//ElemDimHorizList.Add(new SplitElementDimension(this, i, 78, subArea));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Aggiungo a tutte le sottoaree un elemento
|
|
for (int i = 1; i <= ElemDimVertList.Max(x => x.nSubArea); i++)
|
|
{
|
|
int index = ElemDimVertList.Where(x => x.nSubArea == i).Max(x => x.nIndex);
|
|
SplitElementDimension newElemDim = ElemDimVertList.First().Copy();
|
|
newElemDim.SetElement(index + 1, thickness, i);
|
|
ElemDimVertList.Insert(index * i + (i - 1), newElemDim);
|
|
//ElemDimVertList.Insert(index * i + (i - 1), new SplitElementDimension(this, index + 1, 78, i));
|
|
}
|
|
}
|
|
}
|
|
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;
|
|
if(m_SplitVertList.Last().MeasureType.Equals(MeasureTypes.ABSOLUTE))
|
|
dLastDimension += ElemDimVertList[SplitIndex - 1].dDimension;
|
|
m_SplitVertList.RemoveAt(SplitIndex);
|
|
}
|
|
dLastDimension += m_SplitVertList[m_SplitVertList.Count - 1].dDimension;
|
|
m_SplitVertList[m_SplitVertList.Count - 1].SetDimension(dLastDimension);
|
|
}
|
|
if (m_bSplitStartVert)
|
|
{
|
|
int deleteSubArea = ElemDimVertList.Count + 1;
|
|
for (var SplitIndex = ElemDimVertList.Count - 1; SplitIndex >= value; SplitIndex += -1)
|
|
{
|
|
ElemDimVertList.RemoveAt(ElemDimVertList.Count - 1);
|
|
}
|
|
if(nSplitQtyHoriz > 0)
|
|
ElemDimHorizList.RemoveAll(x=>x.nSubArea == deleteSubArea);
|
|
}
|
|
else
|
|
{
|
|
// Rimuovo da tutte le sottoaree degli element l'ultimo elemento
|
|
for (int subArea = 1; subArea <= ElemDimVertList.Max(x => x.nSubArea); subArea++)
|
|
{
|
|
SplitElementDimension removeElem = ElemDimVertList.Where(x => x.nSubArea == subArea).OrderByDescending(x => x.nIndex).FirstOrDefault();
|
|
ElemDimVertList.Remove(removeElem);
|
|
}
|
|
}
|
|
}
|
|
// 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);
|
|
}
|
|
}
|
|
}
|
|
//UpdateSubAreaSplit();
|
|
}
|
|
}
|
|
}
|
|
|
|
public virtual int SelSplitShapeIndex
|
|
{
|
|
get
|
|
{
|
|
return (int)m_SelSplitShape;
|
|
}
|
|
set
|
|
{
|
|
SplitShapes OldSelShapeSplit = m_SelSplitShape;
|
|
m_SelSplitShape = (SplitShapes)value;
|
|
// Azzero quantità orizzontale e verticale
|
|
SetSplitQtyVert(0, 0);
|
|
SetSplitQtyHoriz(0, 0);
|
|
if (m_SelSplitShape == SplitShapes.VERTICAL)
|
|
{
|
|
// Inserisco valori di default
|
|
SetSplitStartVert(true);
|
|
SetSplitQtyVert(1, 0);
|
|
}
|
|
else if (m_SelSplitShape == SplitShapes.HORIZONTAL)
|
|
{
|
|
// Inserisco valori di default
|
|
SetSplitStartVert(false);
|
|
SetSplitQtyHoriz(1, 0);
|
|
}
|
|
else
|
|
{
|
|
// Inserisco valori di default
|
|
SetSplitStartVert(true);
|
|
SetSplitQtyVert(1, 1);
|
|
SetSplitQtyHoriz(1, 1);
|
|
}
|
|
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);
|
|
}
|
|
}
|
|
UpdateSubAreaSplit();
|
|
}
|
|
}
|
|
|
|
public List<SplitDimension> SplitHorizList
|
|
{
|
|
get
|
|
{
|
|
return m_SplitHorizList;
|
|
}
|
|
set
|
|
{
|
|
m_SplitHorizList = value;
|
|
}
|
|
}
|
|
|
|
public List<SplitElementDimension> ElemDimHorizList
|
|
{
|
|
get
|
|
{
|
|
return m_ElemDimHorizList;
|
|
}
|
|
set
|
|
{
|
|
m_ElemDimHorizList = value;
|
|
}
|
|
}
|
|
|
|
public List<SplitElementDimension> ElemDimVertList
|
|
{
|
|
get
|
|
{
|
|
return m_ElemDimVertList;
|
|
}
|
|
set
|
|
{
|
|
m_ElemDimVertList = 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.SetSplitShape(SelSplitShape);
|
|
newSplit.SetAreaType(AreaType);
|
|
foreach (var item in ElemDimHorizList)
|
|
{
|
|
SplitElementDimension newElementDimension = item.Copy();
|
|
newSplit.ElemDimHorizList.Add(newElementDimension);
|
|
}
|
|
foreach (var item in ElemDimVertList)
|
|
{
|
|
SplitElementDimension newElementDimension = item.Copy();
|
|
newSplit.ElemDimVertList.Add(newElementDimension);
|
|
}
|
|
foreach (var item in AreaList)
|
|
{
|
|
Area a = item.Copy(newSplit);
|
|
newSplit.AreaList.Add(a);
|
|
}
|
|
return newSplit;
|
|
}
|
|
|
|
public void Remove()
|
|
{
|
|
ParentArea.AreaList.Remove(this);
|
|
if(!(ParentArea is Fill))
|
|
{
|
|
Fill newFill = Fill.CreateFill(ParentArea, FillTypes.GLASS);
|
|
newFill.SetAreaType(AreaTypes.FILL);
|
|
ParentArea.AreaList.Add(newFill);
|
|
}
|
|
}
|
|
|
|
public List<SplitElementDimension> searchElemFromSubArea(int subArea)
|
|
{
|
|
if(subArea == 0)
|
|
{
|
|
if (m_bSplitStartVert)
|
|
return m_ElemDimVertList;
|
|
else
|
|
return m_ElemDimHorizList;
|
|
}
|
|
else
|
|
{
|
|
if (m_bSplitStartVert)
|
|
return m_ElemDimHorizList.Where(x => x.nSubArea == subArea).ToList();
|
|
else
|
|
return m_ElemDimVertList.Where(x => x.nSubArea == subArea).ToList();
|
|
}
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Internal Properties
|
|
|
|
internal SplitShapes SelSplitShape
|
|
{
|
|
get
|
|
{
|
|
return m_SelSplitShape;
|
|
}
|
|
set
|
|
{
|
|
m_SelSplitShape = value;
|
|
}
|
|
}
|
|
|
|
#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;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per calcolare altezza intero split group
|
|
/// </summary>
|
|
/// <param name="area"> area di partenza </param>
|
|
/// <param name="height"> altezza di partenza </param>
|
|
/// <param name="res"> area di ritorno </param>
|
|
/// <returns></returns>
|
|
internal AreaFound CalculateHeightSplitGroup(Area area, double height, AreaFound res)
|
|
{
|
|
if (area.Equals(this))
|
|
{
|
|
res.m_Dimension = height;
|
|
res.m_Found = true;
|
|
return res;
|
|
}
|
|
for (int i = 0; i < area.AreaList.Count; i++)
|
|
{
|
|
Area item = area.AreaList[i];
|
|
if (area is Split split)
|
|
{
|
|
if (split.SplitHorizList.Count > 0)
|
|
{
|
|
double dim = height;
|
|
foreach (var elem in split.ElemDimHorizList)
|
|
dim = dim - elem.dDimension;
|
|
int index = i;
|
|
if (split.SelSplitShape is SplitShapes.GRID)
|
|
index = i % split.SplitHorizList.Count;
|
|
switch (split.SplitHorizList.ElementAt(index).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
dim = split.SplitHorizList.ElementAt(index).dDimension;
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
AreaDimension ad = new AreaDimension(split.SplitHorizList.ElementAt(index).dDimension, split.SplitHorizList.ElementAt(index).SelMeasureType, split.SplitHorizList.ElementAt(index).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, dim);
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
dim = split.SplitHorizList.ElementAt(index).dDimension * dim / 100;
|
|
break;
|
|
}
|
|
}
|
|
res = CalculateHeightSplitGroup(item, dim, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
else
|
|
{
|
|
double dim = height;
|
|
res = CalculateHeightSplitGroup(item, dim, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
}
|
|
else if (area is Sash sash)
|
|
{
|
|
double bottomRail = 0;
|
|
if (sash.SashBottomRailQty > 0)
|
|
{
|
|
foreach (var bottom in sash.BottomRailElemDimList)
|
|
bottomRail = bottomRail + bottom.dDimension
|
|
- bottom.dOverlap;
|
|
}
|
|
double dim = height - sash.SashList.First().ElementDimensionList.First().dDimension
|
|
- sash.SashList.First().ElementDimensionList.ElementAt(sash.SashList.First().ElementDimensionList.Count - 2).dDimension
|
|
- bottomRail;
|
|
res = CalculateHeightSplitGroup(item, dim, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
else if (area is Splitted splitted)
|
|
{
|
|
double dim = height;
|
|
if (splitted.ParentArea is Split sp && splitted.AreaList.First() is Sash sh)
|
|
{
|
|
if (sp.SplitHorizList.Count > 0)
|
|
{
|
|
dim = dim + sh.SashList.First().ElementDimensionList.First().dOverlap
|
|
+ sh.SashList.First().ElementDimensionList.ElementAt(sh.SashList.First().ElementDimensionList.Count - 2).dOverlap;
|
|
}
|
|
}
|
|
res = CalculateHeightSplitGroup(item, dim, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
else
|
|
{
|
|
res = CalculateHeightSplitGroup(item, height, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per calcolare larghezza intero split group
|
|
/// </summary>
|
|
/// <param name="area"> area di partenza </param>
|
|
/// <param name="width"> larghezza di partenza </param>
|
|
/// <param name="res"> area di ritorno </param>
|
|
/// <returns></returns>
|
|
internal AreaFound CalculateWidthSplitGroup(Area area, double width, AreaFound res)
|
|
{
|
|
if (area.Equals(this))
|
|
{
|
|
res.m_Dimension = width;
|
|
res.m_Found = true;
|
|
return res;
|
|
}
|
|
for (int i = 0; i < area.AreaList.Count; i++)
|
|
{
|
|
Area item = area.AreaList[i];
|
|
if (area is Split split)
|
|
{
|
|
if (split.SplitVertList.Count > 0)
|
|
{
|
|
int index = i;
|
|
double dim = width;
|
|
foreach (var elem in split.ElemDimVertList)
|
|
dim = dim - elem.dDimension;
|
|
if (split.SelSplitShape is SplitShapes.GRID)
|
|
index = i % split.SplitHorizList.Count;
|
|
switch (split.SplitVertList.ElementAt(index).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
res = CalculateWidthSplitGroup(item, split.SplitVertList.ElementAt(index).dDimension, res);
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
AreaDimension ad = new AreaDimension(split.SplitVertList.ElementAt(index).dDimension, split.SplitVertList.ElementAt(index).SelMeasureType, split.SplitVertList.ElementAt(index).Parent);
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in split.SplitVertList)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
|
|
}
|
|
res = CalculateWidthSplitGroup(item, ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, dim), res);
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
res = CalculateWidthSplitGroup(item, split.SplitVertList.ElementAt(index).dDimension * dim / 100, res);
|
|
break;
|
|
}
|
|
}
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
else
|
|
{
|
|
res = CalculateWidthSplitGroup(item, width, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
}
|
|
else if (area is Sash sash)
|
|
{
|
|
double widthTot = width;
|
|
double dim = 0;
|
|
if (sash.ParentArea.ParentArea is Split)
|
|
widthTot = widthTot + sash.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dOverlap + sash.SashList.ElementAt(i).ElementDimensionList.Last().dOverlap;
|
|
if (sash.bIsDimensionLight)
|
|
{
|
|
widthTot = widthTot - sash.SashList.First().ElementDimensionList.ElementAt(1).dDimension - sash.SashList.First().ElementDimensionList.Last().dDimension;
|
|
for (int anta = 1; anta < sash.SashList.Count; anta++)
|
|
{
|
|
widthTot = widthTot - sash.SashList.ElementAt(anta).ElementDimensionList.ElementAt(1).dDimension - sash.SashList.ElementAt(anta).ElementDimensionList.Last().dDimension + sash.SashList.ElementAt(anta).ElementDimensionList.Last().dOverlap;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int anta = 1; anta < sash.SashList.Count; anta++)
|
|
{
|
|
widthTot = widthTot + sash.SashList.ElementAt(anta).ElementDimensionList.Last().dOverlap;
|
|
}
|
|
}
|
|
switch (sash.SashList.ElementAt(i).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
dim = sash.SashList.ElementAt(i).dDimension;
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
AreaDimension ad = new AreaDimension(sash.SashList.ElementAt(i).dDimension, sash.SashList.ElementAt(i).SelMeasureType, sash.SashList.ElementAt(i).Parent);
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in sash.SashList)
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
|
|
dim = ad.ConvertFromPropVal(adList, MeasureTypes.ABSOLUTE, widthTot);
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
dim = sash.SashList.ElementAt(i).dDimension * widthTot / 100;
|
|
break;
|
|
}
|
|
}
|
|
if (!sash.bIsDimensionLight)
|
|
dim = dim - sash.SashList.ElementAt(i).ElementDimensionList.ElementAt(1).dDimension
|
|
- sash.SashList.ElementAt(i).ElementDimensionList.Last().dDimension;
|
|
res = CalculateWidthSplitGroup(item, dim, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
else
|
|
{
|
|
res = CalculateWidthSplitGroup(item, width, res);
|
|
if (res.m_Dimension != -1 && res.m_Found)
|
|
return res;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
internal override JsonArea Serialize(bool hideHw)
|
|
{
|
|
if (nCounterGroup < GroupId)
|
|
Area.nCounterGroup = GroupId;
|
|
JsonSplit JsonSplit = new JsonSplit(m_SelSplitShape, GroupId);
|
|
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());
|
|
if(m_ElemDimHorizList != null && m_ElemDimHorizList.Count > 0)
|
|
{
|
|
int subAreaMinHoriz = m_ElemDimHorizList.Min(x => x.nSubArea);
|
|
List<SplitElementDimension> horizList = m_ElemDimHorizList.Where(x => x.nSubArea == subAreaMinHoriz).ToList();
|
|
foreach (var Elem in horizList)
|
|
JsonSplit.ElementDimHorizList.Add(Elem.Serialize());
|
|
}
|
|
if (m_ElemDimVertList != null && m_ElemDimVertList.Count > 0)
|
|
{
|
|
int subAreaMinVert = m_ElemDimVertList.Min(x => x.nSubArea);
|
|
List<SplitElementDimension> vertList = m_ElemDimVertList.Where(x => x.nSubArea == subAreaMinVert).ToList();
|
|
foreach (var Elem in vertList.ToList())
|
|
JsonSplit.ElementDimVertList.Add(Elem.Serialize());
|
|
}
|
|
foreach (var Area in AreaList)
|
|
JsonSplit.AreaList.Add(Area.Serialize(hideHw));
|
|
return JsonSplit;
|
|
}
|
|
|
|
internal void SetSplitQtyHoriz(int QtyHoriz, int QtyVert)
|
|
{
|
|
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);
|
|
}
|
|
if(QtyHoriz == 0)
|
|
{
|
|
ElemDimHorizList.Clear();
|
|
}
|
|
else
|
|
{
|
|
double thickness = SetThickness();
|
|
// Un Elemento per ogni dimensione principale e per ogni sotto dimensione
|
|
if (bSplitStartVert)
|
|
{
|
|
for (int subArea = 0; subArea <= QtyVert; subArea++)
|
|
{
|
|
for (int i = 0; i < QtyHoriz; i++)
|
|
ElemDimHorizList.Add(new SplitElementDimension(this, i + 1, thickness, subArea + 1));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < QtyHoriz; i++)
|
|
ElemDimHorizList.Add(new SplitElementDimension(this, i + 1, thickness, 0));
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void SetSplitQtyVert(int QtyVert, int QtyHoriz)
|
|
{
|
|
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);
|
|
}
|
|
if (QtyVert == 0)
|
|
{
|
|
ElemDimVertList.Clear();
|
|
}
|
|
else
|
|
{
|
|
double thickness = SetThickness();
|
|
// Un Elemento per ogni dimensione principale e per ogni sotto dimensione
|
|
if (bSplitStartVert)
|
|
{
|
|
for (int i = 0; i < QtyVert; i++)
|
|
ElemDimVertList.Add(new SplitElementDimension(this, i + 1, thickness, 0));
|
|
}
|
|
else
|
|
{
|
|
for (int subArea = 0; subArea <= QtyHoriz; subArea++)
|
|
{
|
|
for (int i = 0; i < QtyVert; i++)
|
|
ElemDimVertList.Add(new SplitElementDimension(this, i + 1, thickness, subArea + 1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal virtual double SetThickness()
|
|
{
|
|
double thickness = 78;
|
|
if (ParentArea is Sash || ParentArea.ParentArea is Sash)
|
|
thickness = Window.m_ParameterList.GetValueOrDefault("Sash_Sash_Split_DimStd");
|
|
return thickness;
|
|
}
|
|
|
|
internal void SetSplitShape(SplitShapes Value)
|
|
{
|
|
m_SelSplitShape = Value;
|
|
}
|
|
|
|
internal void SetSplitStartVert(bool SplitStartVert)
|
|
{
|
|
m_bSplitStartVert = SplitStartVert;
|
|
}
|
|
|
|
internal void UpdateSubAreaSplit()
|
|
{
|
|
if (SplitHorizList.Count > 0)
|
|
{
|
|
for (int i = 0; i < AreaList.Count; i++)
|
|
{
|
|
if (i < SplitHorizList.Count)
|
|
{
|
|
SplitDimension currSplitDim = SplitHorizList[i];
|
|
List<AreaDimension> dimList = new List<AreaDimension>();
|
|
foreach (var itemDim in SplitHorizList)
|
|
dimList.Add(new AreaDimension(itemDim.dDimension, itemDim.MeasureType, itemDim.Parent));
|
|
double dim = currSplitDim.dDimension;
|
|
double height = 0;
|
|
if (!(currSplitDim.MeasureType.Equals(MeasureTypes.ABSOLUTE)))
|
|
{
|
|
Frame frame = ParentArea.ParentWindow.AreaList[0];
|
|
if (frame != null)
|
|
{
|
|
height = CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false)).m_Dimension;
|
|
//height = currSplitDim.CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false)).m_Dimension;
|
|
}
|
|
foreach (var elem in ElemDimHorizList)
|
|
height = height - elem.dDimension;
|
|
dim = currSplitDim.ConvertDimension(dimList, currSplitDim.MeasureType, MeasureTypes.ABSOLUTE, height, -1);
|
|
}
|
|
AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), dim, "Height");
|
|
}
|
|
}
|
|
}
|
|
if (SplitVertList.Count > 0)
|
|
{
|
|
for (int i = 0; i < AreaList.Count; i++)
|
|
{
|
|
if (i < SplitVertList.Count)
|
|
{
|
|
SplitDimension currSplitDim = SplitVertList[i];
|
|
List<AreaDimension> dimList = new List<AreaDimension>();
|
|
foreach (var itemDim in SplitVertList)
|
|
dimList.Add(new AreaDimension(itemDim.dDimension, itemDim.MeasureType, itemDim.Parent));
|
|
double dim = currSplitDim.dDimension;
|
|
double width = 0;
|
|
if (!(currSplitDim.MeasureType.Equals(MeasureTypes.ABSOLUTE)))
|
|
{
|
|
Frame frame = ParentArea.ParentWindow.AreaList[0];
|
|
if(frame != null)
|
|
{
|
|
width = CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
|
|
//width = currSplitDim.CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
|
|
}
|
|
foreach (var elem in ElemDimVertList)
|
|
width = width - elem.dDimension;
|
|
dim = currSplitDim.ConvertDimension(dimList, currSplitDim.MeasureType, MeasureTypes.ABSOLUTE, width, -1);
|
|
}
|
|
AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), dim, "Width");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Internal Methods
|
|
|
|
#region Private Fields
|
|
|
|
private bool m_bSplitStartVert = true;
|
|
private SplitShapes m_SelSplitShape;
|
|
|
|
private List<SplitDimension> m_SplitHorizList = new List<SplitDimension>();
|
|
private List<SplitElementDimension> m_ElemDimHorizList = new List<SplitElementDimension>();
|
|
private List<SplitElementDimension> m_ElemDimVertList = new List<SplitElementDimension>();
|
|
|
|
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>();
|
|
|
|
#endregion Private Fields
|
|
}
|
|
} |