Annamaria Sassi
647 lines
26 KiB
C#
647 lines
26 KiB
C#
using System.ComponentModel.Design;
|
|
using WebWindowTest.Json;
|
|
using static WebWindowTest.Json.WindowConst;
|
|
|
|
namespace WebWindowTest.Models
|
|
{
|
|
public abstract class Area
|
|
{
|
|
#region Public Constructors
|
|
|
|
public Area(Area ParentArea, Window ParentWindow)
|
|
{
|
|
m_ParentWindow = ParentWindow;
|
|
m_ParentArea = ParentArea;
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
public static int nCounterGroup
|
|
{
|
|
get => m_CounterGroup;
|
|
set => m_CounterGroup = value;
|
|
}
|
|
|
|
public List<Area> AreaList
|
|
{
|
|
get
|
|
{
|
|
return m_AreaList;
|
|
}
|
|
set
|
|
{
|
|
m_AreaList = value;
|
|
}
|
|
}
|
|
|
|
public AreaTypes AreaType
|
|
{
|
|
get
|
|
{
|
|
return m_AreaType;
|
|
}
|
|
set
|
|
{
|
|
m_AreaType = value;
|
|
}
|
|
}
|
|
|
|
public int GroupId
|
|
{
|
|
get
|
|
{
|
|
return m_GroupId;
|
|
}
|
|
|
|
set
|
|
{
|
|
m_GroupId = value;
|
|
}
|
|
}
|
|
|
|
public int nAreaId
|
|
{
|
|
get
|
|
{
|
|
return m_nAreaId;
|
|
}
|
|
set
|
|
{
|
|
m_nAreaId = value;
|
|
}
|
|
}
|
|
|
|
public Area ParentArea
|
|
{
|
|
get
|
|
{
|
|
return m_ParentArea;
|
|
}
|
|
}
|
|
|
|
public Window ParentWindow
|
|
{
|
|
get
|
|
{
|
|
return m_ParentWindow;
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
public static void AddCounterGroup()
|
|
{
|
|
m_CounterGroup++;
|
|
}
|
|
|
|
public void AddFirstSash()
|
|
{
|
|
// Salvo il parent
|
|
Area ParentArea = AreaList[0].ParentArea;
|
|
// Creo area sash di default
|
|
Sash SashArea = Sash.CreateSash(ParentArea);
|
|
// Inserisco famiglia hardware vuota
|
|
SashArea.SetSelFamilyHardware("");
|
|
// Inserisco hardware di default
|
|
SashArea.SetSelHardwareFromId("000000");
|
|
//if (ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.ARC ||
|
|
// ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.DOUBLEARC ||
|
|
// ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.ARC_FULL ||
|
|
// ParentWindow.AreaList.First().SelShapeIndex == (int)Shapes.THREECENTERARC)
|
|
// SashArea.SashArcElem = new SashArcElement(SashArea, ParentWindow, 10, true);
|
|
//else
|
|
// SashArea.SashArcElem = null;
|
|
// Salvo gli oggetti già presenti e li cancello da AreaList
|
|
List <Area> ContentArea = new List<Area>();
|
|
ContentArea.Add(AreaList[0]);
|
|
AreaList.Remove(AreaList[0]);
|
|
// Aggiungo area
|
|
AreaList.Add(SashArea);
|
|
// Inserisco il riempimento precedente
|
|
AreaList[0].AreaList.Add(ContentArea[0]);
|
|
AreaList[0].AreaList[0].SetParentArea(AreaList[0]);
|
|
}
|
|
|
|
public void AddSplit()
|
|
{
|
|
// Salvo il parent
|
|
Area ParentArea = AreaList[0].ParentArea;
|
|
List<Area> ContentArea = new List<Area>();
|
|
// Salvo gli oggetti già presenti e li cancello da AreaList
|
|
ContentArea.Add(AreaList[0]);
|
|
AreaList.Remove(AreaList[0]);
|
|
// Aggiungo Area split di default
|
|
Split SplitArea = Split.CreateSplit(this, SplitShapes.HORIZONTAL);
|
|
// imposto i parametri di default
|
|
SplitArea.SetSplitQtyHoriz(1);
|
|
SplitArea.SetSplitStartVert(false);
|
|
// Aggiungo area
|
|
AreaList.Add(SplitArea);
|
|
// Creo le due aree Splitted
|
|
List<Splitted> newSplittedList = new List<Splitted>();
|
|
for (int i = 0; i < 2; i++)
|
|
newSplittedList.Add(Splitted.CreateSplitted(SplitArea));
|
|
// Inserisco nelle aree Splitted Fill e la struttura precedente (e setto ParentArea del fill)
|
|
ContentArea[0].SetParentArea(newSplittedList[1]);
|
|
newSplittedList[1].AreaList.Add(ContentArea[0]);
|
|
if (ContentArea[0] is Fill)
|
|
{
|
|
Fill fill1 = (Fill)ContentArea[0];
|
|
Fill fill2 = Fill.CreateFill(newSplittedList[0], fill1.FillType);
|
|
newSplittedList[0].AreaList.Add(fill2);
|
|
}
|
|
else
|
|
{
|
|
Fill fill2 = Fill.CreateFill(newSplittedList[0], FillTypes.GLASS);
|
|
newSplittedList[0].AreaList.Add(fill2);
|
|
}
|
|
// All'area Split aggiunto le due aree Splitted
|
|
for (int i = 0; i < 2; i++)
|
|
AreaList[0].AreaList.Add(newSplittedList[i]);
|
|
}
|
|
|
|
public abstract Area Copy(Area ParentArea);
|
|
|
|
public void SetGroupId(int nGroupId)
|
|
{
|
|
m_GroupId = nGroupId;
|
|
}
|
|
|
|
public void SwapAree()
|
|
{
|
|
Area tempArea;
|
|
if (this is Sash || this is Split)
|
|
{
|
|
tempArea = AreaList[0];
|
|
AreaList[0] = AreaList[1];
|
|
AreaList[1] = tempArea;
|
|
}
|
|
Frame frame = ParentWindow.AreaList.First();
|
|
switch (frame.Shape)
|
|
{
|
|
case Shapes.RECTANGLE:
|
|
case Shapes.ARC_FULL:
|
|
case Shapes.TRIANGLE:
|
|
{
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Height")).First().dDimension, "Height");
|
|
break;
|
|
}
|
|
|
|
case Shapes.RIGHTCHAMFER:
|
|
{
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Left Height")).First().dDimension, "Left Height");
|
|
break;
|
|
}
|
|
|
|
case Shapes.LEFTCHAMFER:
|
|
{
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Right Height")).First().dDimension, "Right Height");
|
|
break;
|
|
}
|
|
|
|
case Shapes.DOUBLECHAMFER:
|
|
case Shapes.ARC:
|
|
{
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Full Height")).First().dDimension, "Full Height");
|
|
break;
|
|
}
|
|
|
|
case Shapes.DOUBLEARC:
|
|
{
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Full Height")).First().dDimension, "Full Height");
|
|
break;
|
|
}
|
|
|
|
case Shapes.THREECENTERARC:
|
|
{
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Width")).First().dDimension, "Width");
|
|
SearchAreaList(this, frame.DimensionList.Where(x => x.sName.Equals("Full Height")).First().dDimension, "Full Height");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cerca nell'albero gli oggetti Sash e Split per associare la larghezza
|
|
/// </summary>
|
|
/// <param name="node"></param>
|
|
public void SearchAreaList(Area node, double dim, string nameDim)
|
|
{
|
|
if (node != null)
|
|
{
|
|
if (node.AreaType.Equals(AreaTypes.SASH))
|
|
UpdateDimSubArea((Sash)node, dim, nameDim);
|
|
else if (node.AreaType.Equals(AreaTypes.SPLIT))
|
|
UpdateDimSubArea((Split)node, dim, nameDim);
|
|
for (int i = 0; i < node.AreaList.Count; i++)
|
|
{
|
|
if (node.AreaType.Equals(AreaTypes.SASH))
|
|
{
|
|
Sash s = (Sash)node;
|
|
List<AreaDimension> dimList = new List<AreaDimension>();
|
|
foreach (var item in s.SashList)
|
|
dimList.Add(new AreaDimension(item.dDimension, item.MeasureType));
|
|
if(nameDim.Equals("Width"))
|
|
SearchAreaList(node.AreaList.ElementAt(i), s.SashList.ElementAt(i).CalculateAbsoluteValue(dimList, dim), nameDim);
|
|
else
|
|
SearchAreaList(node.AreaList.ElementAt(i), dim, nameDim);
|
|
}
|
|
else if (node.AreaType.Equals(AreaTypes.SPLIT))
|
|
{
|
|
Split s = (Split)node;
|
|
List<AreaDimension> dimList = new List<AreaDimension>();
|
|
if (s.SplitHorizList.Count > 0 && i < s.SplitHorizList.Count)
|
|
{
|
|
foreach (var item in s.SplitHorizList)
|
|
dimList.Add(new AreaDimension(item.dDimension, item.MeasureType));
|
|
if(nameDim.Equals("Width"))
|
|
SearchAreaList(node.AreaList.ElementAt(i), dim, nameDim);
|
|
else
|
|
SearchAreaList(node.AreaList.ElementAt(i), s.SplitHorizList.ElementAt(i).CalculateAbsoluteValue(dimList, dim), nameDim);
|
|
}
|
|
if (s.SplitVertList.Count > 0 && i < s.SplitVertList.Count)
|
|
{
|
|
foreach (var item in s.SplitVertList)
|
|
dimList.Add(new AreaDimension(item.dDimension, item.MeasureType));
|
|
if(nameDim.Equals("Width"))
|
|
SearchAreaList(node.AreaList.ElementAt(i), s.SplitVertList.ElementAt(i).CalculateAbsoluteValue(dimList, dim), nameDim);
|
|
else
|
|
SearchAreaList(node.AreaList.ElementAt(i), dim, nameDim);
|
|
}
|
|
}
|
|
else
|
|
SearchAreaList(node.AreaList.ElementAt(i), dim, nameDim);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void UpdateDimSubArea(Area area, double dim, string nameDim)
|
|
{
|
|
if (area is Sash && nameDim.Equals("Width"))
|
|
{
|
|
Sash sash = (Sash)area;
|
|
int countAbsolute = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.ABSOLUTE)).Count();
|
|
int countProportional = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).Count();
|
|
int countPercentage = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.PERCENTAGE)).Count();
|
|
List<AreaDimension> dimList = new List<AreaDimension>();
|
|
Split split = new Split(null, null);
|
|
if (sash.ParentArea.ParentArea is Split)
|
|
split = (Split)sash.ParentArea.ParentArea;
|
|
if (sash.ParentArea is Frame || (sash.ParentArea.ParentArea is Split && split.SplitHorizList.Count > 0))
|
|
{
|
|
Frame frame = new Frame(null, null);
|
|
if(split.SplitHorizList.Count > 0)
|
|
frame = (Frame)sash.ParentArea.ParentArea.ParentArea;
|
|
else
|
|
frame = (Frame)sash.ParentArea;
|
|
foreach (var i in frame.DimensionList)
|
|
dimList.Add(new AreaDimension(i.dDimension, i.SelMeasureType));
|
|
}
|
|
else
|
|
{
|
|
//Split s = (Split)sash.ParentArea.ParentArea;
|
|
foreach (var i in split.SplitVertList)
|
|
dimList.Add(new AreaDimension(i.dDimension, i.SelMeasureType));
|
|
}
|
|
if (countAbsolute == sash.SashList.Count)
|
|
{
|
|
double sum = sash.SashList.Sum(x => x.dDimension);
|
|
double res = dim - sum;
|
|
if (res > 0)
|
|
{
|
|
foreach (var sashDim in sash.SashList)
|
|
{
|
|
sashDim.SetDimension(sashDim.dDimension + res / countAbsolute);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (var sashDim in sash.SashList)
|
|
{
|
|
// Sommo perchè res è negativo
|
|
sashDim.SetDimension(sashDim.dDimension + res / countAbsolute);
|
|
}
|
|
}
|
|
}
|
|
else if (countAbsolute < sash.SashList.Count && countPercentage != sash.SashList.Count && countProportional != sash.SashList.Count)
|
|
{
|
|
if (countPercentage > 0 && countPercentage <= sash.SashList.Count && countProportional == 0)
|
|
{
|
|
double sumAbsolute = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.ABSOLUTE)).Sum(x => x.dDimension);
|
|
var percentageList = sash.SashList.Where(x => x.MeasureType.Equals(MeasureTypes.PERCENTAGE)).ToList();
|
|
foreach (var i in percentageList)
|
|
{
|
|
i.SetDimension(i.ConvertIn(dimList, (dim - sumAbsolute) / countPercentage, i.MeasureType, dim));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (area is Split)
|
|
{
|
|
Split split = (Split)area;
|
|
List<SplitDimension> splitList = new List<SplitDimension>();
|
|
if (nameDim.Equals("Width"))
|
|
splitList = split.SplitVertList;
|
|
else
|
|
splitList = split.SplitHorizList;
|
|
int countAbsolute = splitList.Where(x => x.MeasureType.Equals(MeasureTypes.ABSOLUTE)).Count();
|
|
if (countAbsolute != 0 && countAbsolute == splitList.Count)
|
|
{
|
|
double sum = splitList.Sum(x => x.dDimension);
|
|
double res = 0;
|
|
res = dim - sum;
|
|
if (res > 0)
|
|
{
|
|
foreach (var item in splitList)
|
|
{
|
|
item.SetDimension(item.dDimension + res / countAbsolute);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (var item in splitList)
|
|
{
|
|
// Sommo perchè res è negativo
|
|
item.SetDimension(item.dDimension + res / countAbsolute);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Internal Methods
|
|
|
|
internal abstract JsonArea Serialize(bool hideHw);
|
|
|
|
internal void SetAreaType(AreaTypes AreaType)
|
|
{
|
|
m_AreaType = AreaType;
|
|
}
|
|
|
|
internal void SetParentArea(Area ParentArea)
|
|
{
|
|
m_ParentArea = ParentArea;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per convertire da misura proporzionale a misura assoluta o percentuale
|
|
/// </summary>
|
|
/// <param name="newType"></param>
|
|
/// <returns></returns>
|
|
internal double ConvertFromPropVal(Sash sashGroup, double sashDim, MeasureTypes newType, double widthTot)
|
|
{
|
|
double tot = widthTot;
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in sashGroup.SashList)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType));
|
|
}
|
|
//Somma misura non proporzionali
|
|
double sumNotProp = sashGroup.SashList
|
|
.Where(m => m.MeasureType != MeasureTypes.PROPORTIONAL && !m.Equals(this))
|
|
.Sum(m => m.CalculateAbsoluteValue(adList, tot));
|
|
//Calcolo residuo
|
|
double res = tot - sumNotProp;
|
|
if (res < 0) res = 0;
|
|
//Misure proporzionali
|
|
var proportionalList = sashGroup.SashList
|
|
.Where(m => m.SelMeasureType == MeasureTypes.PROPORTIONAL)
|
|
.ToList();
|
|
|
|
double sumPesi = proportionalList.Sum(p => p.dDimension);
|
|
if (sumPesi == 0) sumPesi = 1;
|
|
if (newType.Equals(MeasureTypes.ABSOLUTE))
|
|
{
|
|
return res / sumPesi * sashDim;
|
|
}
|
|
else
|
|
{
|
|
return (res / sumPesi * sashDim) / tot * 100;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per convertire da misura proporzionale a misura assoluta o percentuale
|
|
/// </summary>
|
|
/// <param name="newType"></param>
|
|
/// <returns></returns>
|
|
internal double ConvertFromPropVal(List<SplitDimension> splitList, double splitDim, MeasureTypes newType, double widthTot)
|
|
{
|
|
double tot = widthTot;
|
|
List<AreaDimension> adList = new List<AreaDimension>();
|
|
foreach (var it in splitList)
|
|
{
|
|
adList.Add(new AreaDimension(it.dDimension, it.SelMeasureType));
|
|
}
|
|
//Somma misura non proporzionali
|
|
double sumNotProp = splitList
|
|
.Where(m => m.MeasureType != MeasureTypes.PROPORTIONAL && !m.Equals(this))
|
|
.Sum(m => m.CalculateAbsoluteValue(adList, tot));
|
|
//Calcolo residuo
|
|
double res = tot - sumNotProp;
|
|
if (res < 0) res = 0;
|
|
//Misure proporzionali
|
|
var proportionalList = splitList
|
|
.Where(m => m.SelMeasureType == MeasureTypes.PROPORTIONAL)
|
|
.ToList();
|
|
|
|
double sumPesi = proportionalList.Sum(p => p.dDimension);
|
|
if (sumPesi == 0)
|
|
sumPesi = 1;
|
|
return res / sumPesi * splitDim;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per calcolare larghezza area
|
|
/// </summary>
|
|
/// <param name="area"> area di partenza </param>
|
|
/// <param name="width"> larghezza di partenza </param>
|
|
/// <returns></returns>
|
|
public double CalculateWidthArea(Area area, double width)
|
|
{
|
|
for (int i = 0; i < area.AreaList.Count; i++)
|
|
{
|
|
double risultato = -1;
|
|
if (area.Equals(this))
|
|
return width;
|
|
Area item = area.AreaList[i];
|
|
if (area is Split)
|
|
{
|
|
Split split = (Split)area;
|
|
if (split.SplitVertList.Count > 0)
|
|
{
|
|
switch (split.SplitVertList.ElementAt(i).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
risultato = CalculateWidthArea(item, split.SplitVertList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
risultato = CalculateWidthArea(item, ConvertFromPropVal(split.SplitVertList, split.SplitVertList.ElementAt(i).dDimension, MeasureTypes.ABSOLUTE, width));
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
risultato = CalculateWidthArea(item, split.SplitVertList.ElementAt(i).dDimension * width / 100);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
risultato = CalculateWidthArea(item, width);
|
|
}
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
else if (area is Sash)
|
|
{
|
|
Sash sash = (Sash)area;
|
|
switch (sash.SashList.ElementAt(i).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
risultato = CalculateWidthArea(item, sash.SashList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
risultato = CalculateWidthArea(item, ConvertFromPropVal(sash, sash.SashList.ElementAt(i).dDimension, MeasureTypes.ABSOLUTE, width));
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
risultato = CalculateWidthArea(item, sash.SashList.ElementAt(i).dDimension * width / 100);
|
|
break;
|
|
}
|
|
}
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
else
|
|
{
|
|
risultato = CalculateWidthArea(item, width);
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
}
|
|
return width;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per calcolare larghezza area
|
|
/// </summary>
|
|
/// <param name="area"> area di partenza </param>
|
|
/// <param name="height"> altezza di partenza </param>
|
|
/// <returns></returns>
|
|
public double CalculateHeightArea(Area area, double height)
|
|
{
|
|
for (int i = 0; i < area.AreaList.Count; i++)
|
|
{
|
|
double risultato = -1;
|
|
if (area.Equals(this))
|
|
return height;
|
|
Area item = area.AreaList[i];
|
|
if (area is Split)
|
|
{
|
|
Split split = (Split)area;
|
|
if (split.SplitHorizList.Count > 0)
|
|
{
|
|
switch (split.SplitHorizList.ElementAt(i).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
risultato = CalculateHeightArea(item, split.SplitHorizList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
risultato = CalculateHeightArea(item, ConvertFromPropVal(split.SplitHorizList, split.SplitHorizList.ElementAt(i).dDimension, MeasureTypes.ABSOLUTE, height) );
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
risultato = CalculateHeightArea(item, split.SplitHorizList.ElementAt(i).dDimension * height / 100);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
risultato = CalculateHeightArea(item, height);
|
|
}
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
else if (area is Sash)
|
|
{
|
|
Sash sash = (Sash)area;
|
|
switch (sash.SashList.ElementAt(i).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
risultato = CalculateHeightArea(item, sash.SashList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
risultato = CalculateHeightArea(item, ConvertFromPropVal(sash, sash.SashList.ElementAt(i).dDimension, MeasureTypes.ABSOLUTE, height));
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
risultato = CalculateHeightArea(item, sash.SashList.ElementAt(i).dDimension * height / 100);
|
|
break;
|
|
}
|
|
}
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
else
|
|
{
|
|
risultato = CalculateHeightArea(item, height);
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
}
|
|
return height;
|
|
}
|
|
|
|
#endregion Internal Methods
|
|
|
|
#region Protected Fields
|
|
|
|
protected int m_nAreaId = -1;
|
|
|
|
protected Window m_ParentWindow;
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Private Fields
|
|
|
|
// Conteggio dei macro elementi
|
|
private static int m_CounterGroup = 0;
|
|
|
|
private List<Area> m_AreaList = new List<Area>();
|
|
private AreaTypes m_AreaType;
|
|
private int m_GroupId;
|
|
private Area m_ParentArea;
|
|
|
|
#endregion Private Fields
|
|
|
|
|
|
}
|
|
} |