webwindowconfigurator/WebWindowComplex/Models/SplitDimension.cs

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
            {
                // 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)
                {
                    m_SelMeasureType = (MeasureTypes)value;
                    if (m_SelMeasureType.Equals(MeasureTypes.PROPORTIONAL))
                    {
                        dDimension = 1;
                    }
                    m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
                }
            }
        }

        #endregion Public Properties

        #region Public Methods

        public SplitDimension Copy()
        {
            SplitDimension newSplitDim = new SplitDimension(dDimension, MeasureTypes.PERCENTAGE, bIsRelative, m_Parent, bIsVertListDim);
            return newSplitDim;
        }

        #endregion Public Methods

        #region Internal Methods

        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;
        }

        #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.ABSOLUT, "Absolut"),
            new IdNameStruct((int)MeasureTypes.PROPORTIONAL, "Proportional"),
            new IdNameStruct((int)MeasureTypes.PERCENTAGE, "Percentage"),
        };

        private MeasureTypes m_SelMeasureType;

        // reference
        private Split m_Parent;

        #endregion Private Fields
    }
}