Annamaria Sassi
83161fd2c4
- Eliminazione funzioni non più usate - Eliminazione pagine razor sostituite
678 lines
33 KiB
C#
678 lines
33 KiB
C#
using WebWindowComplex.Json;
|
|
using static WebWindowComplex.Json.WindowConst;
|
|
|
|
namespace WebWindowComplex.Models
|
|
{
|
|
public class SplitDimension:AreaDimension
|
|
{
|
|
#region Public Constructors
|
|
|
|
public SplitDimension(double dDimension, MeasureTypes MeasureType, bool bIsRelative, Split Parent, bool IsVertList):base(dDimension, MeasureType, Parent)
|
|
{
|
|
m_dDimension = dDimension;
|
|
m_bIsRelative = bIsRelative;
|
|
m_Parent = Parent;
|
|
m_bIsVertListDim = IsVertList;
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
public bool bIsRelative
|
|
{
|
|
get
|
|
{
|
|
return m_bIsRelative;
|
|
}
|
|
}
|
|
|
|
public bool bIsVertListDim
|
|
{
|
|
get
|
|
{
|
|
return m_bIsVertListDim;
|
|
}
|
|
}
|
|
|
|
public override double dDimension
|
|
{
|
|
get
|
|
{
|
|
return m_dDimension;
|
|
}
|
|
set
|
|
{
|
|
double dimensionTot = 0;
|
|
List<SplitDimension> dimensions = new List<SplitDimension>();
|
|
Frame frame = m_Parent.ParentWindow.AreaList.FirstOrDefault() ?? new Frame(null, Parent.ParentWindow);
|
|
int subAreaVert = -1;
|
|
int subAreaHoriz = -1;
|
|
if (m_Parent.ElemDimVertList.Count > 0)
|
|
subAreaVert = m_Parent.ElemDimVertList.Min(x => x.nSubArea);
|
|
if (m_Parent.ElemDimHorizList.Count > 0)
|
|
subAreaHoriz = m_Parent.ElemDimHorizList.Min(x => x.nSubArea);
|
|
//double width = CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
|
|
double width = Parent.CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
|
|
foreach (var item in m_Parent.ElemDimVertList.Where(x=>x.nSubArea == subAreaVert))
|
|
{
|
|
width = width - item.dDimension;
|
|
}
|
|
double height = (Parent.CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
|
|
//double height = (CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
|
|
foreach (var item in m_Parent.ElemDimHorizList.Where(x => x.nSubArea == subAreaHoriz))
|
|
{
|
|
height = height - item.dDimension;
|
|
}
|
|
if (bIsVertListDim)
|
|
{
|
|
dimensions = m_Parent.SplitVertList;
|
|
dimensionTot = width;
|
|
}
|
|
else
|
|
{
|
|
dimensions = m_Parent.SplitHorizList;
|
|
dimensionTot = height;
|
|
|
|
}
|
|
double valMinAbsolute = 100;
|
|
double valMaxAbsolute = dimensionTot - valMinAbsolute * (dimensions.Count - 1);
|
|
bool valueAccept = false;
|
|
switch (MeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
valueAccept = (value < valMaxAbsolute && value > valMinAbsolute) ? true : false;
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
valMaxAbsolute = 20;
|
|
valueAccept = (value >= 1) ? true : false;
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
valMaxAbsolute = valMaxAbsolute / dimensionTot * 100;
|
|
valMinAbsolute = valMinAbsolute / dimensionTot * 100;
|
|
valueAccept = (value < valMaxAbsolute && value > valMinAbsolute) ? true : false;
|
|
break;
|
|
}
|
|
}
|
|
if (valueAccept)
|
|
{
|
|
List<double> absoluteValList = new List<double>();
|
|
AreaDimension ad = new AreaDimension(dDimension, SelMeasureType, Parent);
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in dimensions)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
|
|
}
|
|
foreach (var item in dimensions)
|
|
{
|
|
absoluteValList.Add(item.CalculateAbsoluteValue(adList, dimensionTot));
|
|
}
|
|
int nIndex = dimensions.IndexOf(this);
|
|
int proportionalCount = dimensions.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).ToList().Count;
|
|
int percentageCount = dimensions.Where(x => x.MeasureType.Equals(MeasureTypes.PERCENTAGE)).ToList().Count;
|
|
// Le dimensioni sono solo in proporzionale
|
|
if (proportionalCount == absoluteValList.Count)
|
|
{
|
|
m_dDimension = value;
|
|
}
|
|
// Le dimensioni sono solo in percentuale
|
|
else if (percentageCount == dimensions.Count)
|
|
{
|
|
if (value < dDimension)
|
|
{
|
|
// L'anta modificata non è l'ultima
|
|
if (nIndex < dimensions.Count - 1)
|
|
dimensions[nIndex + 1].SetDimension(dimensions[nIndex + 1].dDimension + (m_dDimension - value));
|
|
else if (dimensions.Count > 1)
|
|
dimensions[nIndex - 1].SetDimension(dimensions[nIndex - 1].dDimension + (m_dDimension - value));
|
|
else
|
|
{
|
|
m_dDimension = 100;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double dRes = value;
|
|
// se non ultima anta
|
|
if (nIndex < dimensions.Count - 1)
|
|
{
|
|
for (var nInd = 0; nInd <= nIndex - 1; nInd++)
|
|
dRes += dimensions[nInd].dDimension;
|
|
dRes = (100 - dRes) / (dimensions.Count - nIndex - 1);
|
|
for (var Ind = nIndex + 1; Ind <= dimensions.Count - 1; Ind++)
|
|
dimensions[Ind].SetDimension(dRes);
|
|
}
|
|
// se ultima anta
|
|
else if (dimensions.Count > 1)
|
|
{
|
|
if (dimensions.Count > 2)
|
|
{
|
|
for (var Ind = 0; Ind <= nIndex - 2; Ind++)
|
|
dRes += dimensions[Ind].dDimension;
|
|
}
|
|
dRes = (100 - dRes);
|
|
dimensions[nIndex - 1].SetDimension(dRes);
|
|
}
|
|
else
|
|
{
|
|
m_dDimension = 100;
|
|
return;
|
|
}
|
|
}
|
|
m_dDimension = value;
|
|
}
|
|
// Le dimensioni sono miste o solo in assoluto
|
|
else
|
|
{
|
|
double valueInAbsolute = 0;
|
|
switch (MeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
valueInAbsolute = value;
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
var pesi = value + dimensions
|
|
.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL) && !x.Equals(this))
|
|
.Sum(x => x.m_dDimension);
|
|
valueInAbsolute = dimensionTot / pesi * value;
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
valueInAbsolute = (value / 100) * dimensionTot;
|
|
break;
|
|
}
|
|
}
|
|
if (value < dDimension)
|
|
{
|
|
// L'anta modificata non è l'ultima
|
|
if (nIndex < absoluteValList.Count - 1)
|
|
{
|
|
absoluteValList[nIndex + 1] = absoluteValList[nIndex + 1] + (absoluteValList[nIndex] - valueInAbsolute);
|
|
absoluteValList[nIndex] = valueInAbsolute;
|
|
}
|
|
// L'anta modificata è l'ultima
|
|
else if (dimensions.Count > 1)
|
|
{
|
|
absoluteValList[nIndex - 1] = absoluteValList[nIndex - 1] + (absoluteValList[nIndex] - valueInAbsolute);
|
|
absoluteValList[nIndex] = valueInAbsolute;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// L'anta modificata non è l'ultima
|
|
if (nIndex < absoluteValList.Count - 1)
|
|
{
|
|
absoluteValList[nIndex + 1] = absoluteValList[nIndex + 1] - (valueInAbsolute - absoluteValList[nIndex]);
|
|
absoluteValList[nIndex] = valueInAbsolute;
|
|
}
|
|
// L'anta modificata è l'ultima
|
|
else if (dimensions.Count > 1)
|
|
{
|
|
absoluteValList[nIndex - 1] = absoluteValList[nIndex - 1] - (valueInAbsolute - absoluteValList[nIndex]);
|
|
absoluteValList[nIndex] = valueInAbsolute;
|
|
}
|
|
}
|
|
if (MeasureType.Equals(MeasureTypes.PROPORTIONAL))
|
|
m_dDimension = value;
|
|
for (int i = 0; i < absoluteValList.Count; i++)
|
|
{
|
|
var item = dimensions.ElementAt(i);
|
|
item.SetDimension(ad.ConvertAbsoluteIn(adList, absoluteValList[i], (MeasureTypes)item.SelMeasureTypeIndex, dimensionTot));
|
|
}
|
|
}
|
|
for (int i = 0; i < m_Parent.AreaList.Count; i++)
|
|
{
|
|
if (m_Parent.SplitHorizList.Count > 0 && i < m_Parent.SplitHorizList.Count)
|
|
{
|
|
List<AreaDimension> dimList = new List<AreaDimension>();
|
|
foreach (var itemDim in m_Parent.SplitHorizList)
|
|
dimList.Add(new AreaDimension(itemDim.dDimension, itemDim.MeasureType, itemDim.Parent));
|
|
SplitDimension currSplitDim = m_Parent.SplitHorizList[i];
|
|
double dim = currSplitDim.dDimension;
|
|
if (!(currSplitDim.MeasureType.Equals(MeasureTypes.ABSOLUTE)))
|
|
dim = currSplitDim.ConvertDimension(dimList, currSplitDim.MeasureType, MeasureTypes.ABSOLUTE, height, -1);
|
|
m_Parent.AreaList.ElementAt(i).SearchAreaList(m_Parent.AreaList.ElementAt(i), dim, "Height");
|
|
}
|
|
if (m_Parent.SplitVertList.Count > 0 && i < m_Parent.SplitVertList.Count)
|
|
{
|
|
List<AreaDimension> dimList = new List<AreaDimension>();
|
|
foreach (var itemDim in m_Parent.SplitVertList)
|
|
dimList.Add(new AreaDimension(itemDim.dDimension, itemDim.MeasureType, itemDim.Parent));
|
|
SplitDimension currSplitDim = m_Parent.SplitVertList[i];
|
|
double dim = currSplitDim.dDimension;
|
|
if (!(currSplitDim.MeasureType.Equals(MeasureTypes.ABSOLUTE)))
|
|
dim = currSplitDim.ConvertDimension(dimList, currSplitDim.MeasureType, MeasureTypes.ABSOLUTE, width, -1);
|
|
m_Parent.AreaList.ElementAt(i).SearchAreaList(m_Parent.AreaList.ElementAt(i), dim, "Width");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public Split Parent
|
|
{
|
|
get
|
|
{
|
|
return m_Parent;
|
|
}
|
|
set
|
|
{
|
|
m_Parent = value;
|
|
}
|
|
}
|
|
|
|
public override int SelMeasureTypeIndex
|
|
{
|
|
get
|
|
{
|
|
return (int)m_SelMeasureType;
|
|
}
|
|
set
|
|
{
|
|
if (m_SelMeasureType != (MeasureTypes)value)
|
|
{
|
|
MeasureTypes newType = (MeasureTypes)value;
|
|
List<SplitDimension> splitList = new List<SplitDimension>();
|
|
List<SplitElementDimension> splitElemList = new List<SplitElementDimension>();
|
|
if(m_Parent.ParentWindow.AreaList.FirstOrDefault() != null)
|
|
{
|
|
Frame frame = m_Parent.ParentWindow.AreaList.FirstOrDefault()!;
|
|
double dimSplitGroup = 0;
|
|
if (bIsVertListDim)
|
|
{
|
|
splitList = m_Parent.SplitVertList;
|
|
if (Parent.bSplitStartVert)
|
|
splitElemList = m_Parent.ElemDimVertList;
|
|
else
|
|
splitElemList = m_Parent.ElemDimVertList.Where(x => x.nSubArea == 1).ToList();
|
|
//dimSplitGroup = CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
|
|
dimSplitGroup = Parent.CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
|
|
}
|
|
else
|
|
{
|
|
splitList = m_Parent.SplitHorizList;
|
|
if (Parent.bSplitStartVert)
|
|
splitElemList = m_Parent.ElemDimHorizList.Where(x => x.nSubArea == 1).ToList();
|
|
else
|
|
splitElemList = m_Parent.ElemDimHorizList;
|
|
dimSplitGroup = (Parent.CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
|
|
//dimSplitGroup = (CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
|
|
}
|
|
AreaDimension ad = new AreaDimension(dDimension, SelMeasureType, Parent);
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in splitList)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
|
|
}
|
|
foreach (var item in splitElemList)
|
|
{
|
|
dimSplitGroup = dimSplitGroup - item.dDimension;
|
|
}
|
|
if (newType is MeasureTypes.PROPORTIONAL)
|
|
{
|
|
adList = ad.RicalculatePropVal(adList, splitList.IndexOf(this), dimSplitGroup);
|
|
for (int i = 0; i < adList.Count; i++)
|
|
splitList.ElementAt(i).SetDimension(adList.ElementAt(i).dDimension);
|
|
}
|
|
else
|
|
m_dDimension = ad.ConvertDimension(adList, m_SelMeasureType, newType, dimSplitGroup, splitList.IndexOf(this));
|
|
m_SelMeasureType = (MeasureTypes)value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
public SplitDimension Copy()
|
|
{
|
|
SplitDimension newSplitDim = new SplitDimension(dDimension, MeasureType, bIsRelative, m_Parent, bIsVertListDim);
|
|
return newSplitDim;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Internal Methods
|
|
|
|
///// <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)
|
|
//{
|
|
// for (int i = 0; i < area.AreaList.Count; i++)
|
|
// {
|
|
// if (area.Equals(m_Parent))
|
|
// {
|
|
// res.m_Dimension = width;
|
|
// res.m_Found = true;
|
|
// return res;
|
|
// }
|
|
// Area item = area.AreaList[i];
|
|
// if (area is Split split)
|
|
// {
|
|
// if(split.SplitVertList.Count > 0)
|
|
// {
|
|
// 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;
|
|
//}
|
|
|
|
///// <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)
|
|
//{
|
|
// for (int i = 0; i < area.AreaList.Count; i++)
|
|
// {
|
|
// if (area.Equals(m_Parent))
|
|
// {
|
|
// res.m_Dimension = height;
|
|
// res.m_Found = true;
|
|
// return res;
|
|
// }
|
|
// 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;
|
|
//}
|
|
|
|
internal JsonSplitDimension Serialize()
|
|
{
|
|
JsonSplitDimension JsonSplitDimension = new JsonSplitDimension(m_bIsRelative, m_dDimension, MeasureType);
|
|
return JsonSplitDimension;
|
|
}
|
|
|
|
internal void SetIsRelative(bool value)
|
|
{
|
|
m_bIsRelative = value;
|
|
}
|
|
|
|
internal void SetIsVertListDim(bool value)
|
|
{
|
|
m_bIsVertListDim = value;
|
|
}
|
|
|
|
internal void SetMeasureType(MeasureTypes value)
|
|
{
|
|
m_SelMeasureType = value;
|
|
}
|
|
|
|
internal void SetSelMeasureType(MeasureTypes value)
|
|
{
|
|
if (m_SelMeasureType != (MeasureTypes)value)
|
|
{
|
|
MeasureTypes newType = (MeasureTypes)value;
|
|
List<SplitDimension> splitList = new List<SplitDimension>();
|
|
List<SplitElementDimension> splitElemList = new List<SplitElementDimension>();
|
|
if (m_Parent.ParentWindow.AreaList.FirstOrDefault() != null)
|
|
{
|
|
Frame frame = m_Parent.ParentWindow.AreaList.FirstOrDefault()!;
|
|
double dimSplitGroup = 0;
|
|
if (bIsVertListDim)
|
|
{
|
|
splitList = m_Parent.SplitVertList;
|
|
if (Parent.bSplitStartVert)
|
|
splitElemList = m_Parent.ElemDimVertList;
|
|
else
|
|
splitElemList = m_Parent.ElemDimVertList.Where(x => x.nSubArea == 1).ToList();
|
|
//dimSplitGroup = CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
|
|
dimSplitGroup = Parent.CalculateWidthSplitGroup(frame, frame.AvailWidthArea(), new AreaFound(-1, false)).m_Dimension;
|
|
}
|
|
else
|
|
{
|
|
splitList = m_Parent.SplitHorizList;
|
|
if (Parent.bSplitStartVert)
|
|
splitElemList = m_Parent.ElemDimHorizList.Where(x => x.nSubArea == 1).ToList();
|
|
else
|
|
splitElemList = m_Parent.ElemDimHorizList;
|
|
//dimSplitGroup = (CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
|
|
dimSplitGroup = (Parent.CalculateHeightSplitGroup(frame, frame.AvailHeightArea(), new AreaFound(-1, false))).m_Dimension;
|
|
}
|
|
AreaDimension ad = new AreaDimension(dDimension, SelMeasureType, Parent);
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in splitList)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType, it.Parent));
|
|
}
|
|
foreach (var item in splitElemList)
|
|
{
|
|
dimSplitGroup = dimSplitGroup - item.dDimension;
|
|
}
|
|
if (newType is MeasureTypes.PROPORTIONAL)
|
|
{
|
|
adList = ad.RicalculatePropVal(adList, splitList.IndexOf(this), dimSplitGroup);
|
|
for (int i = 0; i < adList.Count; i++)
|
|
splitList.ElementAt(i).SetDimension(adList.ElementAt(i).dDimension);
|
|
}
|
|
else
|
|
m_dDimension = ad.ConvertDimension(adList, m_SelMeasureType, newType, dimSplitGroup, splitList.IndexOf(this));
|
|
m_SelMeasureType = (MeasureTypes)value;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Internal Methods
|
|
|
|
#region Private Fields
|
|
|
|
private bool m_bIsRelative = false;
|
|
|
|
private bool m_bIsVertListDim = false;
|
|
|
|
// reference
|
|
private Split m_Parent;
|
|
|
|
#endregion Private Fields
|
|
}
|
|
|
|
public class AreaFound
|
|
{
|
|
public AreaFound(double dimension, bool found)
|
|
{
|
|
m_Dimension = dimension;
|
|
m_Found = found;
|
|
}
|
|
|
|
public double m_Dimension { get; set; } = -1;
|
|
public bool m_Found { get; set; } = false;
|
|
}
|
|
} |