Annamaria Sassi
824 lines
35 KiB
C#
824 lines
35 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using WebWindowComplex.Json;
|
|
using static WebWindowComplex.Json.WindowConst;
|
|
|
|
namespace WebWindowComplex.Models
|
|
{
|
|
public class SplitDimension
|
|
{
|
|
#region Public Constructors
|
|
|
|
public SplitDimension(double dDimension, MeasureTypes MeasureType, bool bIsRelative, Split Parent, bool IsVertList)
|
|
{
|
|
m_dDimension = dDimension;
|
|
m_SelMeasureType = MeasureType;
|
|
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 double dDimension
|
|
{
|
|
get
|
|
{
|
|
return m_dDimension;
|
|
}
|
|
set
|
|
{
|
|
double dimensionTot = 0;
|
|
List<SplitDimension> dimensions = null;
|
|
if (bIsVertListDim)
|
|
{
|
|
dimensions = m_Parent.SplitVertList;
|
|
dimensionTot = CalculateWidthSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), m_Parent.ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Width").First().dValue);
|
|
}
|
|
else
|
|
{
|
|
dimensions = m_Parent.SplitHorizList;
|
|
dimensionTot = CalculateHeightSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), HeightTot());
|
|
}
|
|
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>();
|
|
foreach (var item in dimensions)
|
|
{
|
|
absoluteValList.Add(item.CalculateAbsoluteValue(dimensionTot, dimensions));
|
|
}
|
|
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(ConvertIn(absoluteValList[i], (MeasureTypes)item.SelMeasureTypeIndex, dimensionTot, dimensions));
|
|
}
|
|
}
|
|
//m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
|
|
}
|
|
//// Controllo che il valore inserito sia compreso tra 0 e 100
|
|
//if (value > 0 && value < 100)
|
|
//{
|
|
// // se sono in percentuale
|
|
// if (m_bIsRelative)
|
|
// {
|
|
// List<SplitDimension> RelativeDimList = new List<SplitDimension>();
|
|
// if (bIsVertListDim)
|
|
// RelativeDimList = m_Parent.SplitVertList.Where(x => x.bIsRelative).ToList();
|
|
// else
|
|
// RelativeDimList = m_Parent.SplitHorizList.Where(x => x.bIsRelative).ToList();
|
|
// // verifico se ci sono assoluti
|
|
// //List<SplitDimension> RelativeDimList = m_Parent.SplitPositionList.Where(x => x.bIsRelative).ToList();
|
|
// if (RelativeDimList.Count > 0)
|
|
// {
|
|
// if (m_Parent.bIsPercentage)
|
|
// {
|
|
// int nIndex = RelativeDimList.IndexOf(this);
|
|
// if (value < m_dDimension)
|
|
// {
|
|
// if (nIndex < RelativeDimList.Count - 1)
|
|
// RelativeDimList[nIndex + 1].SetDimension(RelativeDimList[nIndex + 1].dDimension + (m_dDimension - value));
|
|
// else if (RelativeDimList.Count > 1)
|
|
// RelativeDimList[nIndex - 1].SetDimension(RelativeDimList[nIndex - 1].dDimension + (m_dDimension - value));
|
|
// else
|
|
// {
|
|
// m_dDimension = 100;
|
|
// return;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// double dRes = value;
|
|
// if (nIndex < RelativeDimList.Count - 1)
|
|
// {
|
|
// for (var nInd = 0; nInd <= nIndex - 1; nInd++)
|
|
// dRes += RelativeDimList[nInd].dDimension;
|
|
// dRes = (100 - dRes) / (RelativeDimList.Count - nIndex - 1);
|
|
// if (dRes != 0)
|
|
// {
|
|
// for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
|
|
// RelativeDimList[Ind].SetDimension(dRes);
|
|
// }
|
|
// else
|
|
// return;
|
|
// }
|
|
// else if (RelativeDimList.Count > 1)
|
|
// {
|
|
// if (RelativeDimList.Count > 2)
|
|
// {
|
|
// for (var Ind = 0; Ind <= nIndex - 2; Ind++)
|
|
// dRes += RelativeDimList[Ind].dDimension;
|
|
// }
|
|
// dRes = (100 - dRes);
|
|
// if (dRes != 0)
|
|
// RelativeDimList[nIndex - 1].SetDimension(dRes);
|
|
// else
|
|
// return;
|
|
// }
|
|
// else
|
|
// {
|
|
// m_dDimension = 100;
|
|
// return;
|
|
// }
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// }
|
|
// }
|
|
// }
|
|
// m_dDimension = value;
|
|
// m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
|
|
//}
|
|
}
|
|
}
|
|
|
|
public Split Parent
|
|
{
|
|
get
|
|
{
|
|
return m_Parent;
|
|
}
|
|
set
|
|
{
|
|
m_Parent = value;
|
|
}
|
|
}
|
|
|
|
public MeasureTypes MeasureType
|
|
{
|
|
get
|
|
{
|
|
return m_SelMeasureType;
|
|
}
|
|
}
|
|
|
|
public List<IdNameStruct> MeasureTypeList
|
|
{
|
|
get
|
|
{
|
|
return m_MeasureTypeList;
|
|
}
|
|
}
|
|
|
|
public MeasureTypes SelMeasureType
|
|
{
|
|
get
|
|
{
|
|
return m_SelMeasureType;
|
|
}
|
|
set
|
|
{
|
|
m_SelMeasureType = value;
|
|
}
|
|
}
|
|
|
|
public int SelMeasureTypeIndex
|
|
{
|
|
get
|
|
{
|
|
return (int)m_SelMeasureType;
|
|
}
|
|
set
|
|
{
|
|
if (m_SelMeasureType != (MeasureTypes)value)
|
|
{
|
|
MeasureTypes newType = (MeasureTypes)value;
|
|
List<SplitDimension> splitList = null;
|
|
double tot = 0;
|
|
if (bIsVertListDim)
|
|
{
|
|
splitList = m_Parent.SplitVertList;
|
|
tot = CalculateWidthSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), m_Parent.ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Width").First().dValue);
|
|
}
|
|
else
|
|
{
|
|
splitList = m_Parent.SplitHorizList;
|
|
tot = CalculateHeightSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), HeightTot());
|
|
}
|
|
m_dDimension = ConvertDimension(m_SelMeasureType, newType, tot, splitList);
|
|
m_SelMeasureType = (MeasureTypes)value;
|
|
//m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Metodo per convertire la dimensione dal vecchio tipo al nuovo tipo
|
|
/// </summary>
|
|
/// <param name="oldType"> Vecchio tipo </param>
|
|
/// <param name="newType"> Nuovo tipo </param>
|
|
/// <returns></returns>
|
|
public double ConvertDimension(MeasureTypes oldType, MeasureTypes newType, double widthTot, List<SplitDimension> splitList)
|
|
{
|
|
switch (oldType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
if (newType.Equals(MeasureTypes.PERCENTAGE))
|
|
{
|
|
//return Double.Round((m_dDimension / m_Parent.Width) * 100, 1);
|
|
return (m_dDimension / widthTot) * 100;
|
|
}
|
|
else
|
|
{
|
|
return CalculatePropVal(widthTot, splitList);
|
|
}
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
if (newType.Equals(MeasureTypes.ABSOLUTE))
|
|
{
|
|
//return Double.Round(ConvertFromPropVal(newType), 2);
|
|
return ConvertFromPropVal(newType, widthTot, splitList);
|
|
}
|
|
else
|
|
{
|
|
//return Double.Round(ConvertFromPropVal(newType), 1);
|
|
return ConvertFromPropVal(newType, widthTot, splitList);
|
|
}
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
if (newType.Equals(MeasureTypes.ABSOLUTE))
|
|
{
|
|
//return Double.Round((m_dDimension * m_Parent.Width) / 100, 2);
|
|
return (m_dDimension * widthTot) / 100;
|
|
}
|
|
else
|
|
{
|
|
return CalculatePropVal(widthTot, splitList);
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
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>
|
|
/// <returns></returns>
|
|
internal double CalculateWidthSplitGroup(Area area, double width)
|
|
{
|
|
for (int i = 0; i < area.AreaList.Count; i++)
|
|
{
|
|
double risultato = -1;
|
|
if (area.Equals(m_Parent))
|
|
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 = CalculateWidthSplitGroup(item, split.SplitVertList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
//risultato = CalculateWidthSplitGroup(item, split.SplitVertList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
risultato = CalculateWidthSplitGroup(item, split.SplitVertList.ElementAt(i).dDimension * width / 100);
|
|
break;
|
|
}
|
|
}
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
else
|
|
{
|
|
risultato = CalculateWidthSplitGroup(item, width);
|
|
}
|
|
}
|
|
else if (area is Sash)
|
|
{
|
|
Sash sash = (Sash)area;
|
|
switch (sash.SashList.ElementAt(i).SelMeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
risultato = CalculateWidthSplitGroup(item, sash.SashList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
//risultato = CalculateWidthSplitGroup(item, sash.SashList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
risultato = CalculateWidthSplitGroup(item, sash.SashList.ElementAt(i).dDimension * width / 100);
|
|
break;
|
|
}
|
|
}
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
else
|
|
{
|
|
risultato = CalculateWidthSplitGroup(item, width);
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
}
|
|
return width;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per calcolare altezza intero split group
|
|
/// </summary>
|
|
/// <param name="area"> area di partenza </param>
|
|
/// <param name="height"> altezza di partenza </param>
|
|
/// <returns></returns>
|
|
internal double CalculateHeightSplitGroup(Area area, double height)
|
|
{
|
|
for (int i = 0; i < area.AreaList.Count; i++)
|
|
{
|
|
double risultato = -1;
|
|
if (area.Equals(m_Parent))
|
|
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 = CalculateHeightSplitGroup(item, split.SplitHorizList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
//risultato = CalculateHeightSplitGroup(item, split.SplitVertList.ElementAt(i).dDimension);
|
|
break;
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
risultato = CalculateHeightSplitGroup(item, split.SplitHorizList.ElementAt(i).dDimension * height / 100);
|
|
break;
|
|
}
|
|
}
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
else
|
|
{
|
|
risultato = CalculateHeightSplitGroup(item, height);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
risultato = CalculateHeightSplitGroup(item, height);
|
|
if (risultato != -1)
|
|
return risultato;
|
|
}
|
|
}
|
|
return height;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calcolo MCD
|
|
/// </summary>
|
|
/// <param name="a"></param>
|
|
/// <param name="b"></param>
|
|
/// <returns></returns>
|
|
internal static double CalculateMCD(double a, double b)
|
|
{
|
|
while (b >= 0.01)
|
|
{
|
|
double temp = b;
|
|
b = a % b;
|
|
a = temp;
|
|
}
|
|
//return Double.Round(a,2);
|
|
return a;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per ricalcolare i valori proporzionali a causa della modifica di uno
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
internal double CalculatePropVal(double widthTot, List<SplitDimension> splitList)
|
|
{
|
|
if (splitList.Where(m => m.MeasureType.Equals(MeasureTypes.PROPORTIONAL)).ToList().Count == 0)
|
|
{
|
|
return 1;
|
|
}
|
|
List<double> absoluteValue = new List<double>();
|
|
foreach (var item in splitList)
|
|
{
|
|
absoluteValue.Add(item.CalculateAbsoluteValue(widthTot, splitList));
|
|
}
|
|
for (int i = 0; i < splitList.Count; i++)
|
|
{
|
|
if (!splitList.ElementAt(i).Equals(this) &&
|
|
splitList.ElementAt(i).MeasureType.Equals(MeasureTypes.PROPORTIONAL))
|
|
{
|
|
int nIndex = splitList.IndexOf(this);
|
|
if (absoluteValue.ElementAt(nIndex) <= absoluteValue.ElementAt(i))
|
|
{
|
|
var mcd = CalculateMCD(absoluteValue.ElementAt(nIndex), absoluteValue.ElementAt(i));
|
|
splitList.ElementAt(i).m_dDimension = absoluteValue.ElementAt(i) / mcd;
|
|
m_dDimension = absoluteValue.ElementAt(nIndex) / mcd;
|
|
}
|
|
else
|
|
{
|
|
var mcd = CalculateMCD(absoluteValue.ElementAt(nIndex), absoluteValue.ElementAt(i));
|
|
splitList.ElementAt(i).m_dDimension = absoluteValue.ElementAt(i) / mcd;
|
|
m_dDimension = absoluteValue.ElementAt(nIndex) / mcd;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return m_dDimension;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per trasformare una dimensione in valore assoluto rispetto alla larghezza totale
|
|
/// </summary>
|
|
/// <param name="widthTot"> Larghezza totale </param>
|
|
/// <returns></returns>
|
|
internal double CalculateAbsoluteValue(double widthTot, List<SplitDimension> splitList)
|
|
{
|
|
switch (MeasureType)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
//return Double.Round(dDimension, 2);
|
|
return dDimension;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
//return Double.Round(Proportional2AbsolutVal(), 2);
|
|
return Proportional2AbsoluteVal(widthTot, splitList);
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
//return Double.Round((dDimension / 100) * widthTot, 1);
|
|
return (dDimension / 100) * widthTot;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per convertire una dimensione da un valore assoluto al suo rispettivo tipo
|
|
/// </summary>
|
|
/// <param name="absoluteVal"> Valore assoluto </param>
|
|
/// <param name="type"> Tipo di misura della dimensione </param>
|
|
/// <param name="widthTot"> Larghezza totale </param>
|
|
/// <returns></returns>
|
|
internal double ConvertIn(double absoluteVal, MeasureTypes type, double widthTot, List<SplitDimension> splitList)
|
|
{
|
|
switch (type)
|
|
{
|
|
case MeasureTypes.ABSOLUTE:
|
|
{
|
|
return absoluteVal;
|
|
}
|
|
case MeasureTypes.PROPORTIONAL:
|
|
{
|
|
return Proportional2AbsoluteVal(widthTot, splitList);
|
|
}
|
|
case MeasureTypes.PERCENTAGE:
|
|
{
|
|
return (absoluteVal / widthTot) * 100;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per convertire da misura proporzionale a misura assoluta o percentuale
|
|
/// </summary>
|
|
/// <param name="newType"></param>
|
|
/// <returns></returns>
|
|
internal double ConvertFromPropVal(MeasureTypes newType, double widthTot, List<SplitDimension> splitList)
|
|
{
|
|
double tot = widthTot;
|
|
//Somma misura non proporzionali
|
|
double sumNotProp = splitList
|
|
.Where(m => m.MeasureType != MeasureTypes.PROPORTIONAL && !m.Equals(this))
|
|
.Sum(m => m.CalculateAbsoluteValue(tot, splitList));
|
|
//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;
|
|
if (newType.Equals(MeasureTypes.ABSOLUTE))
|
|
{
|
|
return res / sumPesi * dDimension;
|
|
}
|
|
else
|
|
{
|
|
return (res / sumPesi * dDimension) / tot * 100;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Metodo per trasformare il valore proporzionale in assoluto
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
internal double Proportional2AbsoluteVal(double widthTot, List<SplitDimension> splitList)
|
|
{
|
|
double tot = widthTot;
|
|
//Somma misura non proporzionali
|
|
double sumNotProp = splitList
|
|
.Where(m => m.MeasureType != MeasureTypes.PROPORTIONAL)
|
|
.Sum(m => m.CalculateAbsoluteValue(tot, splitList));
|
|
//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 * dDimension;
|
|
}
|
|
|
|
internal JsonSplitDimension Serialize()
|
|
{
|
|
JsonSplitDimension JsonSplitDimension = new JsonSplitDimension(m_bIsRelative, m_dDimension, MeasureType);
|
|
return JsonSplitDimension;
|
|
}
|
|
|
|
internal void SetDimension(double dValue)
|
|
{
|
|
m_dDimension = dValue;
|
|
}
|
|
|
|
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;
|
|
double tot = 0;
|
|
if (bIsVertListDim)
|
|
{
|
|
tot = CalculateWidthSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), m_Parent.ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Width").First().dValue);
|
|
m_dDimension = ConvertDimension(m_SelMeasureType, newType, tot, m_Parent.SplitVertList);
|
|
}
|
|
else
|
|
{
|
|
tot = CalculateHeightSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), HeightTot());
|
|
m_dDimension = ConvertDimension(m_SelMeasureType, newType, tot, m_Parent.SplitHorizList);
|
|
}
|
|
m_SelMeasureType = (MeasureTypes)value;
|
|
//m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
|
|
}
|
|
}
|
|
|
|
internal double HeightTot()
|
|
{
|
|
switch (m_Parent.ParentWindow.AreaList.First().SelShapeIndex)
|
|
{
|
|
case (int)Shapes.RECTANGLE:
|
|
case (int)Shapes.TRIANGLE:
|
|
case (int)Shapes.ARC_FULL:
|
|
{
|
|
return CalculateHeightSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), m_Parent.ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Height").First().dValue);
|
|
}
|
|
case (int)Shapes.RIGHTCHAMFER:
|
|
{
|
|
return CalculateHeightSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), m_Parent.ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Left Height").First().dValue);
|
|
}
|
|
case (int)Shapes.LEFTCHAMFER:
|
|
{
|
|
return CalculateHeightSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), m_Parent.ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Right Height").First().dValue);
|
|
}
|
|
default:
|
|
{
|
|
return CalculateHeightSplitGroup(m_Parent.ParentWindow.AreaList.FirstOrDefault(), m_Parent.ParentWindow.AreaList.FirstOrDefault().DimensionList.Where(x => x.sName == "Full Height").First().dValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion Internal Methods
|
|
|
|
#region Private Fields
|
|
|
|
private bool m_bIsRelative = false;
|
|
|
|
private bool m_bIsVertListDim = false;
|
|
|
|
private double m_dDimension;
|
|
|
|
private List<IdNameStruct> m_MeasureTypeList = new List<IdNameStruct>
|
|
{
|
|
new IdNameStruct((int)MeasureTypes.ABSOLUTE, "Absolute"),
|
|
new IdNameStruct((int)MeasureTypes.PROPORTIONAL, "Proportional"),
|
|
new IdNameStruct((int)MeasureTypes.PERCENTAGE, "Percentage"),
|
|
};
|
|
|
|
private MeasureTypes m_SelMeasureType;
|
|
|
|
// reference
|
|
private Split m_Parent;
|
|
|
|
#endregion Private Fields
|
|
}
|
|
} |