Annamaria Sassi
809 lines
38 KiB
C#
809 lines
38 KiB
C#
using Newtonsoft.Json.Linq;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.Design;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
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
|
|
{
|
|
m_bSplitStartVert = value;
|
|
m_ElemDimVertList.Clear();
|
|
m_ElemDimHorizList.Clear();
|
|
if (value)
|
|
{
|
|
for (int i = 0; i < nSplitQtyVert; i++)
|
|
{
|
|
m_ElemDimVertList.Add(new SplitElementDimension(this, i + 1, 78, 0));
|
|
}
|
|
for (int subArea = 0; subArea < m_SplitVertList.Count; subArea++)
|
|
{
|
|
for (int index = 0; index < nSplitQtyHoriz; index++)
|
|
m_ElemDimHorizList.Add(new SplitElementDimension(this, index + 1, 78, subArea + 1));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < nSplitQtyHoriz; i++)
|
|
{
|
|
m_ElemDimHorizList.Add(new SplitElementDimension(this, i + 1, 78, 0));
|
|
}
|
|
for (int subArea = 0; subArea < m_SplitHorizList.Count; subArea++)
|
|
{
|
|
for (int index = 0; index < nSplitQtyVert; index++)
|
|
m_ElemDimVertList.Add(new SplitElementDimension(this, index + 1, 78, subArea + 1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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
|
|
{
|
|
Frame? frame = ParentWindow.AreaList.FirstOrDefault();
|
|
if(frame != null)
|
|
{
|
|
double heightTot = CalculateHeightArea(frame, frame.AvailHeightArea());
|
|
// 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));
|
|
if (!m_bSplitStartVert)
|
|
{
|
|
//Aggiungo un elemento alla sottoarea principale
|
|
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++)
|
|
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);
|
|
ElemDimHorizList.Insert(index * i + (i - 1), new SplitElementDimension(this, index + 1, 78, 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;
|
|
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 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
|
|
{
|
|
Frame? frame = ParentWindow.AreaList.FirstOrDefault();
|
|
if (frame != null)
|
|
{
|
|
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));
|
|
if (m_bSplitStartVert)
|
|
{
|
|
//Aggiungo un elemento alla sottoarea principale
|
|
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++)
|
|
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);
|
|
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;
|
|
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 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.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 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;
|
|
}
|
|
}
|
|
|
|
#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());
|
|
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
|
|
{
|
|
// 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, 78, subArea + 1));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < QtyHoriz; i++)
|
|
ElemDimHorizList.Add(new SplitElementDimension(this, i + 1, 78, 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
|
|
{
|
|
// 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, 78, 0));
|
|
}
|
|
else
|
|
{
|
|
for (int subArea = 0; subArea <= QtyHoriz; subArea++)
|
|
{
|
|
for (int i = 0; i < QtyVert; i++)
|
|
ElemDimVertList.Add(new SplitElementDimension(this, i + 1, 78, subArea + 1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal void SetSplitShape(SplitShapes Value)
|
|
{
|
|
m_SelSplitShape = Value;
|
|
}
|
|
|
|
internal void SetSplitStartVert(bool SplitStartVert)
|
|
{
|
|
m_bSplitStartVert = SplitStartVert;
|
|
}
|
|
|
|
internal double HeightFrame()
|
|
{
|
|
double dim = 0;
|
|
switch (ParentWindow.AreaList.First().SelShapeIndex)
|
|
{
|
|
case (int)Shapes.RECTANGLE:
|
|
case (int)Shapes.TRIANGLE:
|
|
case (int)Shapes.ARC_FULL:
|
|
{
|
|
dim = ParentWindow.AreaList.FirstOrDefault()!.DimensionList.Where(x => x.sName == "Height").First().dDimension;
|
|
break;
|
|
}
|
|
case (int)Shapes.RIGHTCHAMFER:
|
|
{
|
|
dim = ParentWindow.AreaList.FirstOrDefault()!.DimensionList.Where(x => x.sName == "Left Height").First().dDimension;
|
|
break;
|
|
}
|
|
case (int)Shapes.LEFTCHAMFER:
|
|
{
|
|
dim = ParentWindow.AreaList.FirstOrDefault()!.DimensionList.Where(x => x.sName == "Right Height").First().dDimension;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
dim = ParentWindow.AreaList.FirstOrDefault()!.DimensionList.Where(x => x.sName == "Full Height").First().dDimension;
|
|
break;
|
|
}
|
|
}
|
|
foreach(var elem in ElemDimHorizList)
|
|
{
|
|
dim = dim - elem.dDimension;
|
|
}
|
|
return dim;
|
|
}
|
|
|
|
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 width = ParentArea.CalculateWidthArea(ParentArea.ParentWindow.AreaList[0], ParentArea.ParentWindow.AreaList[0].AvailWidthArea());
|
|
AreaList.ElementAt(i).SearchAreaList(AreaList.ElementAt(i), width, "Width");
|
|
double dim = currSplitDim.dDimension;
|
|
if (!(currSplitDim.MeasureType.Equals(MeasureTypes.ABSOLUTE)))
|
|
{
|
|
double height = ParentArea.CalculateHeightArea(ParentArea.ParentWindow.AreaList[0], ParentArea.ParentWindow.AreaList[0].AvailHeightArea());
|
|
foreach (var elem in ElemDimHorizList)
|
|
height = height - elem.dDimension;
|
|
dim = currSplitDim.ConvertDimension(dimList, currSplitDim.MeasureType, MeasureTypes.ABSOLUTE, height, -1, 0);
|
|
}
|
|
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;
|
|
if (!(currSplitDim.MeasureType.Equals(MeasureTypes.ABSOLUTE)))
|
|
{
|
|
double width = ParentArea.CalculateWidthArea(ParentArea.ParentWindow.AreaList[0], ParentArea.ParentWindow.AreaList[0].AvailWidthArea());
|
|
foreach (var elem in ElemDimVertList)
|
|
width = width - elem.dDimension;
|
|
dim = currSplitDim.ConvertDimension(dimList, currSplitDim.MeasureType, MeasureTypes.ABSOLUTE, width, -1, 0);
|
|
}
|
|
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
|
|
}
|
|
} |