webwindowconfigurator/WebWindowComplex/Models/SashDimension.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 SashDimension
    {
        #region Public Constructors

        public SashDimension(double dDimension, bool bIsRelative, Sash Parent, int nSashId)
        {
            m_dDimension = dDimension;
            m_bIsRelative = bIsRelative;
            m_Parent = Parent;
            m_nSashId = nSashId;
            // assengno maniglia
            if (Parent.SashList.Count == 0 || !Parent.SashList.Any(x => x.bHasHandle))
                m_bHasHandle = true;
            // assegno tipo di anta
            if (Parent.SashList.Count == 0)
                SetOpeningType(Openings.TILTTURN_LEFT);
            else if (Parent.SashList.Count == 1)
            {
                switch (Parent.SashList[0].OpeningType)
                {
                    case Openings.TURNONLY_LEFT:
                        {
                            SetOpeningType(Openings.TURNONLY_RIGHT);
                            break;
                        }

                    case Openings.TURNONLY_RIGHT:
                        {
                            SetOpeningType(Openings.TURNONLY_LEFT);
                            break;
                        }

                    case Openings.TILTTURN_LEFT:
                        {
                            SetOpeningType(Openings.TURNONLY_RIGHT);
                            break;
                        }

                    case Openings.TILTTURN_RIGHT:
                        {
                            SetOpeningType(Openings.TURNONLY_LEFT);
                            break;
                        }

                    case Openings.TILTONLY_TOP:
                        {
                            SetOpeningType(Openings.TILTONLY_BOTTOM);
                            break;
                        }

                    case Openings.TILTONLY_BOTTOM:
                        {
                            SetOpeningType(Openings.TILTONLY_TOP);
                            break;
                        }

                    case Openings.COMPLANARSLIDE_LEFT:
                        {
                            SetOpeningType(Openings.COMPLANARSLIDE_RIGHT);
                            break;
                        }

                    case Openings.COMPLANARSLIDE_RIGHT:
                        {
                            SetOpeningType(Openings.COMPLANARSLIDE_LEFT);
                            break;
                        }

                    case Openings.LIFTSLIDE_LEFT:
                        {
                            SetOpeningType(Openings.LIFTSLIDE_RIGHT);
                            break;
                        }

                    case Openings.LIFTSLIDE_RIGHT:
                        {
                            SetOpeningType(Openings.LIFTSLIDE_LEFT);
                            break;
                        }
                }
            }
            else
                SetOpeningType(Parent.SashList[Parent.SashList.Count - 1].OpeningType);
        }

        #endregion Public Constructors

        #region Public Properties

        public bool bHasHandle
        {
            get
            {
                return m_bHasHandle;
            }
            set
            {
                m_bHasHandle = value;
                m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
            }
        }

        public bool bIsRelative
        {
            get
            {
                return m_bIsRelative;
            }
        }

        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)
                    {
                        // verifico se ci sono assoluti
                        List<SashDimension> RelativeDimList = m_Parent.SashList.Where(x => x.bIsRelative).ToList();
                        if (RelativeDimList.Count > 0)
                        {
                            if (m_Parent.bIsPercentage)
                            {
                                int nIndex = RelativeDimList.IndexOf(this);
                                // se diminuisce dimensione
                                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;
                                    }
                                }
                                // se aumenta dimensione
                                else
                                {
                                    double dRes = value;
                                    // se non ultima anta
                                    if (nIndex < RelativeDimList.Count - 1)
                                    {
                                        for (var nInd = 0; nInd <= nIndex - 1; nInd++)
                                            dRes += RelativeDimList[nInd].dDimension;
                                        dRes = (100 - dRes) / (RelativeDimList.Count - nIndex - 1);
                                        for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
                                            RelativeDimList[Ind].SetDimension(dRes);
                                    }
                                    // se ultima anta
                                    else if (RelativeDimList.Count > 1)
                                    {
                                        if (RelativeDimList.Count > 2)
                                        {
                                            for (var Ind = 0; Ind <= nIndex - 2; Ind++)
                                                dRes += RelativeDimList[Ind].dDimension;
                                        }

                                        //for (var Ind = nIndex + 1; Ind <= RelativeDimList.Count - 1; Ind++)
                                        //    dRes += RelativeDimList[Ind].dDimension;
                                        dRes = (100 - dRes);
                                        RelativeDimList[nIndex - 1].SetDimension(dRes);
                                        //for (var nInd = 0; nInd <= nIndex - 1; nInd++)
                                        //    RelativeDimList[nInd].SetDimension(dRes);
                                    }
                                    else
                                    {
                                        m_dDimension = 100;
                                        return;
                                    }
                                }
                            }
                        }
                    }
                    m_dDimension = value;
                    m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
                }
            }
        }

        public int nSashId
        {
            get
            {
                return m_nSashId;
            }
        }

        public Openings OpeningType
        {
            get
            {
                return (Openings)m_SelOpeningType;
            }
        }

        public List<IdNameStruct> OpeningTypeList
        {
            get
            {
                return m_OpeningTypeList;
            }
        }

        public Openings SelOpeningType
        {
            get
            {
                return m_SelOpeningType;
            }
            set
            {
                m_SelOpeningType = value;
                m_Parent.ReqRefreshShape();
                m_Parent.RefreshHardwareOptionList();
                m_Parent.SetFirstHardware();
            }
        }

        public int SelOpeningTypeIndex
        {
            get
            {
                return IdNameStruct.IndFromId((int)m_SelOpeningType, m_OpeningTypeList);
            }
            set
            {
                m_SelOpeningType = (Openings)IdNameStruct.IdFromInd(value, m_OpeningTypeList);
                m_Parent.ReqRefreshShape();
                m_Parent.RefreshHardwareOptionList();
                m_Parent.SetFirstHardware();
                m_Parent.ParentWindow.OnUpdatePreview(m_Parent.ParentWindow.sSerialized());
            }
        }

        #endregion Public Properties

        #region Public Methods

        public SashDimension Copy()
        {
            SashDimension newSashDim = new SashDimension(dDimension, bIsRelative, m_Parent, m_nSashId);
            newSashDim.SetOpeningType(SelOpeningType);
            newSashDim.SetHasHandle(bHasHandle);
            return newSashDim;
        }

        #endregion Public Methods

        #region Internal Methods

        internal JsonSashDimension Serialize()
        {
            JsonSashDimension JsonSashDimension = new JsonSashDimension(OpeningType, m_bHasHandle, m_dDimension, m_nSashId);
            return JsonSashDimension;
        }

        internal void SetDimension(double dValue)
        {
            m_dDimension = dValue;
        }

        internal void SetHasHandle(bool value)
        {
            m_bHasHandle = value;
        }

        internal void SetOpeningType(Openings value)
        {
            m_SelOpeningType = value;
        }

        #endregion Internal Methods

        #region Private Fields

        private bool m_bHasHandle;

        private bool m_bIsRelative = false;

        private double m_dDimension;

        private int m_nSashId;

        private List<IdNameStruct> m_OpeningTypeList = new List<IdNameStruct>
        {
            new IdNameStruct((int)Openings.TURNONLY_LEFT, ">"),
            new IdNameStruct((int)Openings.TURNONLY_RIGHT, "<"),
            new IdNameStruct((int)Openings.TILTTURN_LEFT, ">*"),
            new IdNameStruct((int)Openings.TILTTURN_RIGHT, "<*"),
            new IdNameStruct((int)Openings.TILTONLY_TOP, "˄"),
            new IdNameStruct((int)Openings.TILTONLY_BOTTOM, "˅"),
            new IdNameStruct((int)Openings.PIVOT, "◊"),
            new IdNameStruct((int)Openings.FIXED, "X"),
            new IdNameStruct((int)Openings.COMPLANARSLIDE_LEFT, "-→"),
            new IdNameStruct((int)Openings.COMPLANARSLIDE_RIGHT, "←-"),
            new IdNameStruct((int)Openings.LIFTSLIDE_LEFT, "┌→"),
            new IdNameStruct((int)Openings.LIFTSLIDE_RIGHT, "←┐")
        };

        // reference
        private Sash m_Parent;

        private Openings m_SelOpeningType;

        #endregion Private Fields
    }
}