Imports System.Collections.ObjectModel
Imports System.ComponentModel
Imports System.IO
Imports EgtUILib
Imports System.Text.RegularExpressions

Public Class Assembly
   Implements INotifyPropertyChanged

   ' questa variabile se settata a vero da la possibilità di costruire un riferimento sui Jamb
   Friend Shared BuiltReffCompo As Boolean = False
   Public bIsNewAssembly As Boolean = False
   Public Shared FirstReadingWeight As Boolean = False

   Public Shared Refreshing As Boolean = True

   Public bOldVersion As Boolean = False

   ' è usata per abilitare la TextBox associata all'OverlapLock
   Private m_OneDoorProperty As Boolean = True
   Public Property OneDoorProperty As Boolean
      Get
         Return m_OneDoorProperty
      End Get
      Set(value As Boolean)
         m_OneDoorProperty = value
         NotifyPropertyChanged("OneDoorProperty")
      End Set
   End Property

   ' tutte queste proprietà interagiscono direttamente con le dimensioni del TELAIO
   ' per questo motivo la funzione set può ospitare la chiamata ad una funzione che modifica le dimensioni della porta

   Private m_AssemblyUnit As String = ConstGen.VAL_INCHES
   Public ReadOnly Property AssemblyUnit As String
      Get
         Return m_AssemblyUnit
      End Get
   End Property

#Region "GENERAL"

#Region "Light Up/Bottom"

   Private m_LightUp As String
   Public Property LightUp As String
      Get
         Return m_LightUp
      End Get
      Set(value As String)
         m_LightUp = value
         NotifyPropertyChanged("LightUp")
         ' viene ricalcolata la dimensione dell'anta
         HeightDoor()
         ' viene ricalcolata l'altezza della porta e dei jamb laterali a partire dalla dimensione della porta 
         HeightJamb()
         ' esegue il riposizionamento delle componeti sul telaio
         UpDateAllCompo()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
      End Set
   End Property
   ' questo metodo è utilizzato per caricare e aggiornare il valore m_lightUp senza eseguire le operazioni del Set
   Public Sub SetLightUp(sLightUp As String)
      m_LightUp = sLightUp
      NotifyPropertyChanged("LightUp")
   End Sub

   Private m_LightBottom As String
   Public Property LightBottom As String
      Get
         Return m_LightBottom
      End Get
      Set(value As String)
         m_LightBottom = value
         ' viene ricalcolata la dimensione dell'anta
         HeightDoor()
         ' viene ricalcolata l'altezza dei jamb laterali a partire dalla dimensione della porta 
         HeightJamb()
         ' esegue il riposizionamento delle componeti sul telaio
         UpDateAllCompo()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
      End Set
   End Property
   Public Sub SetLightBottom(sLightBottom As String)
      m_LightBottom = sLightBottom
      NotifyPropertyChanged("LightBottom")
   End Sub

#End Region    ' Light Up/Bottom

#Region "Light Hinge/Lock"

   Private m_LightHinge As String
   Public Property LightHinge As String
      Get
         Return m_LightHinge
      End Get
      Set(value As String)
         m_LightHinge = value
         ' viene ricalcolata la larghezza dei jamb orizzonati (le dimensioni della porta devono esistere)
         TopBottomWidth()
         ' esegue il riposizionamento delle componeti sul telaio
         UpDateAllCompo()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
      End Set
   End Property
   Public Sub SetLightHinge(sSetLightHinge As String)
      m_LightHinge = sSetLightHinge
      NotifyPropertyChanged("LightHinge")
   End Sub

   Private m_LightLock As String
   Public Property LightLock As String
      Get
         Return m_LightLock
      End Get
      Set(value As String)
         m_LightLock = value
         ' viene ricalcolata la larghezza dei jamb orizzonati (le dimensioni della porta devono esistere)
         TopBottomWidth()
         ' esegue il riposizionamento delle componeti sul telaio
         UpDateAllCompo()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
      End Set
   End Property
   Public Sub SetLightLock(sLightLock As String)
      m_LightLock = sLightLock
      NotifyPropertyChanged("LightLock")
   End Sub

#End Region    ' Light Hinge/Lock

#Region "ThicknessHead"

   Private m_ThicknessHead As String
   Public Property ThicknessHead As String
      Get
         Return m_ThicknessHead
      End Get
      Set(value As String)
         m_ThicknessHead = value
         NotifyPropertyChanged("ThicknessHead")
         ' viene ricalcolata l'altezza del JambTop
         HeightJambTop()
         ' viene ricalcolata l'altezza della porta e dei jamb laterali a partire dalla dimensione della porta 
         ' per il fatto che anche i jamb lateriali devono allungarsi 
         HeightJamb()
         ' viene ricalcolata la dimsione dei rabbet sui jamb laterali (per ospitare la nuova dimansione del JambTop)
         TopRabbetJamb()
         ' esegue il riposizionamento delle componeti sul telaio
         UpDateAllCompo()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
      End Set
   End Property
   Public Sub SetThicknessHead(sThicknessHead As String)
      m_ThicknessHead = sThicknessHead
      NotifyPropertyChanged("ThicknessHead")
   End Sub

#End Region    ' ThicknessHead

#Region "Thickness/Depth Bottom"

   Private m_ThicknessBottom As String
   Public Property ThicknessBottom As String
      Get
         Return m_ThicknessBottom
      End Get
      Set(value As String)
         m_ThicknessBottom = value
         NotifyPropertyChanged("ThicknessBottom")
         ' viene ricalcolata l'altezza del JambTop
         HeightJambBottom()
         ' viene ricalcolata l'altezza della porta e dei jamb laterali a partire dalla dimensione della porta 
         ' per il fatto che anche i jamb lateriali devono allungarsi 
         HeightJamb()
         ' viene ricalcolata la dimsione dei rabbet sui jamb laterali (per ospitare la nuova dimansione del JambTop)
         BottomRabbetJamb()
         ' esegue il riposizionamento delle componeti sul telaio
         UpDateAllCompo()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
      End Set
   End Property
   Public Sub SetThicknessBottom(sThicknessBottom As String)
      m_ThicknessBottom = sThicknessBottom
      NotifyPropertyChanged("ThicknessBottom")
   End Sub

   Private m_DepthBottom As String
   Public Property DepthBottom As String
      Get
         Return m_DepthBottom
      End Get
      Set(value As String)
         m_DepthBottom = value
         NotifyPropertyChanged("DepthBottom")
         ' viene ricalcolata la profondità del JambBottom
         SetThicKnessJamb()
         UpDateAllCompo()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
      End Set
   End Property
   Public Sub SetDepthBottom(sDepthBottom As String)
      m_DepthBottom = sDepthBottom
      NotifyPropertyChanged("DepthBottom")
   End Sub

#End Region    ' Thickness Depth Bottom

#Region "Overlap Hinge/Lock/Top/DeltaT"

   Private m_OverlapHinge As String
   Public Property OverlapHinge As String
      Get
         Return m_OverlapHinge
      End Get
      Set(value As String)
         m_OverlapHinge = value
         ' modifico le dimensioni dei Jambs
         'DoorVisibilityNew()
         ' deve essere ricalcolata la dimensione del Top e del Bottom del telaio 
         TopBottomWidth()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'SetWidthJamb()
         ' viene ricalcolato il valore dei rabbet (sui Jamb laterali)
         TopRabbetJamb()
         HingeRabbetJamb()
         BottomRabbetJamb()
         UpDateAllCompo()
      End Set
   End Property
   Public Sub SetOverlapHinge(sOverlapHinge As String)
      m_OverlapHinge = sOverlapHinge
      NotifyPropertyChanged("OverlapHinge")
   End Sub

   Private m_OverlapLock As String
   Public Property OverlapLock As String
      Get
         Return m_OverlapLock
      End Get
      Set(value As String)
         m_OverlapLock = value
         ' modifico le dimensioni dei Jambs
         'DoorVisibilityNew()
         TopBottomWidth()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'SetWidthJamb()
         TopRabbetJamb()
         HingeRabbetJamb()
         BottomRabbetJamb()
         UpDateAllCompo()
      End Set
   End Property
   Public Sub SetOverlapLock(sOverlapLock As String)
      m_OverlapLock = sOverlapLock
      NotifyPropertyChanged("OverlapLock")
   End Sub

   Private m_OverlapTop As String
   Public Property OverlapTop As String
      Get
         Return m_OverlapTop
      End Get
      Set(value As String)
         m_OverlapTop = value
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         HeightJamb()
         SetWidthJamb()
         HingeRabbetJamb()
         'BottomRabbetJamb()
         UpDateAllCompo()
      End Set
   End Property
   Public Sub SetOverlapTop(sOverlapTop As String)
      m_OverlapTop = sOverlapTop
      NotifyPropertyChanged("OverlapTop")
   End Sub

   Private m_OverlapBottom As String
   Public Property OverlapBottom As String
      Get
         Return m_OverlapBottom
      End Get
      Set(value As String)
         m_OverlapBottom = value
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         HeightJamb()
         SetWidthJamb()
         UpDateAllCompo()
      End Set
   End Property
   Public Sub SetOverlapBottom(sOverlapBottom As String)
      m_OverlapBottom = sOverlapBottom
      NotifyPropertyChanged("OverlapBottom")
   End Sub

   Private m_DeltaThickness As String
   Public Property DeltaThickness As String
      Get
         Return m_DeltaThickness
      End Get
      Set(value As String)
         m_DeltaThickness = value
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         HingeRabbetJamb()
         BottomRabbetJamb()
         UpDateAllCompo()
      End Set
   End Property
   Public Sub SetDeltaThickness(sDeltaThickness As String)
      m_DeltaThickness = sDeltaThickness
      NotifyPropertyChanged("DeltaThickness")
   End Sub
#End Region    ' Overlap Hinge/Lock/Top/DeltaT

#Region "Jamb Thckness/Width"

   Private m_Thickness As String
   Public Property Thickness As String
      Get
         Return m_Thickness
      End Get
      Set(value As String)
         m_Thickness = value
         SetThicKnessJamb()
         UpDateAllCompo()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
      End Set
   End Property
   Public Sub SetThickness(sThickness As String)
      m_Thickness = sThickness
      NotifyPropertyChanged("Thickness")
   End Sub

   Private m_Width As String
   Public Property Width As String
      Get
         Return m_Width
      End Get
      Set(value As String)
         m_Width = value
         HeightJamb()
         SetWidthJamb()
         UpDateAllCompo()
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
      End Set
   End Property
   Public Sub SetWidth(sWidth As String)
      m_Width = sWidth
      NotifyPropertyChanged("Width")
   End Sub
#End Region    ' Jamb Thickness/Width

#Region "EdgeType/Machining"

   Friend Shared m_FrameEdgeTypeList As New ObservableCollection(Of EdgeType)
   Public ReadOnly Property EdgeTypeList As ObservableCollection(Of EdgeType)
      Get
         Return m_FrameEdgeTypeList
      End Get
   End Property

   Public ReadOnly Property DispositionList As ObservableCollection(Of EdgeType)
      Get
         Return Part.m_DispositionList
      End Get
   End Property

   ' elemento selezionato dalla lista delle disposizinioni
   Private m_DispositionItem As EdgeType
   Public Property DispositionItem As EdgeType
      Get
         Return m_DispositionItem
      End Get
      Set(value As EdgeType)
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.DispositionItem = value
         Next
         m_DispositionItem = value
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         NotifyPropertyChanged("DispositionItem")
      End Set
   End Property
   Public Sub SetDispositionItem(ObjDisposition As EdgeType)
      If IsNothing(m_DispositionItem) Then
         m_DispositionItem = ObjDisposition
      End If
      NotifyPropertyChanged("DispositionItem")
   End Sub

   Private m_LockEdgeType As New EdgeType("", Visibility.Visible)
   Public Property LockEdgeType As EdgeType
      Get
         If m_LockEdgeType.IsActive = Visibility.Collapsed Then
            m_LockEdgeType = EdgeTypeList(0)
            Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         End If
         Return m_LockEdgeType
      End Get
      Set(value As EdgeType)
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.LockEdgeType = value
         Next
         m_LockEdgeType = value
         NotifyPropertyChanged("LockEdgeType")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'm_LeftJamb.SetLockEdgeType(value)
         'm_RightJamb.SetLockEdgeType(value)
         'm_TopJamb.SetLockEdgeType(value)
         'm_BottomJamb.SetLockEdgeType(value)
      End Set
   End Property
   Public Sub SetLockEdgeType(sLockEdgeType As EdgeType)
      m_LockEdgeType = sLockEdgeType
      NotifyPropertyChanged("LockEdgeType")
   End Sub

   Private m_HingeEdgeType As New EdgeType("", Visibility.Visible)
   Public Property HingeEdgeType As EdgeType
      Get
         If m_HingeEdgeType.IsActive = Visibility.Collapsed Then
            m_HingeEdgeType = EdgeTypeList(0)
            Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         End If
         Return m_HingeEdgeType
      End Get
      Set(value As EdgeType)
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.HingeEdgeType = value
         Next
         m_HingeEdgeType = value
         NotifyPropertyChanged("HingeEdgeType")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'm_LeftJamb.SetHingeEdgeType(value)
         'm_RightJamb.SetHingeEdgeType(value)
         'm_TopJamb.SetHingeEdgeType(value)
         'm_BottomJamb.SetHingeEdgeType(value)
      End Set
   End Property
   Public Sub SetHingeEdgeType(sHingeEdgeType As EdgeType)
      m_HingeEdgeType = sHingeEdgeType
      NotifyPropertyChanged("HingeEdgeType")
   End Sub

   Private m_TopType As New EdgeType("", Visibility.Visible)
   Public Property TopType As EdgeType
      Get
         If m_TopType.IsActive = Visibility.Collapsed Then
            m_TopType = EdgeTypeList(0)
            Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         End If
         Return m_TopType
      End Get
      Set(value As EdgeType)
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.TopType = value
         Next
         m_TopType = value
         NotifyPropertyChanged("TopType")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'm_LeftJamb.SetTopType(value)
         'm_RightJamb.SetTopType(value)
         'm_TopJamb.SetTopType(value)
         'm_BottomJamb.SetTopType(value)
      End Set
   End Property
   Public Sub SetTopType(sTopType As EdgeType)
      m_TopType = sTopType
      NotifyPropertyChanged("TopType")
   End Sub

   Private m_BottomType As New EdgeType("", Visibility.Visible)
   Public Property BottomType As EdgeType
      Get
         If m_BottomType.IsActive = Visibility.Collapsed Then
            m_BottomType = EdgeTypeList(0)
            Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         End If
         Return m_BottomType
      End Get
      Set(value As EdgeType)
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.BottomType = value
         Next
         m_BottomType = value
         NotifyPropertyChanged("BottomType")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'm_LeftJamb.SetBottomType(value)
         'm_RightJamb.SetBottomType(value)
         'm_TopJamb.SetBottomType(value)
         'm_BottomJamb.SetBottomType(value)
      End Set
   End Property
   Public Sub SetBottomType(sBottomType As EdgeType)
      m_BottomType = sBottomType
      NotifyPropertyChanged("BottomType")
   End Sub

   Private m_TopMachining As Boolean
   Public Property TopMachining As Boolean
      Get
         Return m_TopMachining
      End Get
      Set(value As Boolean)
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.TopMachining = value
         Next
         m_TopMachining = value
         NotifyPropertyChanged("TopMachining")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'm_LeftJamb.TopMachining = m_TopMachining
         'm_RightJamb.TopMachining = m_TopMachining
         'm_TopJamb.TopMachining = m_TopMachining
         'm_BottomJamb.TopMachining = m_TopMachining
      End Set
   End Property
   Public Sub SetTopMachining(sTopMachining As Boolean)
      m_TopMachining = sTopMachining
      NotifyPropertyChanged("TopMachining")
   End Sub

   Private m_LockEdgeMachining As Boolean
   Public Property LockEdgeMachining As Boolean
      Get
         Return m_LockEdgeMachining
      End Get
      Set(value As Boolean)
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.LockEdgeMachining = value
         Next
         m_LockEdgeMachining = value
         NotifyPropertyChanged("LockEdgeMachining")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'm_LeftJamb.LockEdgeMachining = m_LockEdgeMachining
         'm_RightJamb.LockEdgeMachining = m_LockEdgeMachining
         'm_TopJamb.LockEdgeMachining = m_LockEdgeMachining
         'm_BottomJamb.LockEdgeMachining = m_LockEdgeMachining
      End Set
   End Property
   Public Sub SetLockEdgeMachining(sLockEdgeMachining As Boolean)
      m_LockEdgeMachining = sLockEdgeMachining
      NotifyPropertyChanged("LockEdgeMachining")
   End Sub

   Private m_HingeEdgeMachining As Boolean
   Public Property HingeEdgeMachining As Boolean
      Get
         Return m_HingeEdgeMachining
      End Get
      Set(value As Boolean)
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.HingeEdgeMachining = value
         Next
         m_HingeEdgeMachining = value
         NotifyPropertyChanged("HingeEdgeMachining")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'm_LeftJamb.HingeEdgeMachining = value
         'm_RightJamb.HingeEdgeMachining = value
         'm_TopJamb.HingeEdgeMachining = value
         'm_BottomJamb.HingeEdgeMachining = value
      End Set
   End Property
   Public Sub SetHingeEdgeMachining(sHingeEdgeMachining As Boolean)
      m_HingeEdgeMachining = sHingeEdgeMachining
      NotifyPropertyChanged("HingeEdgeMachining")
   End Sub

   Private m_BottomMachining As Boolean
   Public Property BottomMachining As Boolean
      Get
         Return m_BottomMachining
      End Get
      Set(value As Boolean)
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.BottomMachining = value
         Next
         m_BottomMachining = value
         NotifyPropertyChanged("BottomMachining")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         'm_LeftJamb.BottomMachining = value
         'm_RightJamb.BottomMachining = value
         'm_TopJamb.BottomMachining = value
         'm_BottomJamb.BottomMachining = value
      End Set
   End Property
   Public Sub SetBottomMachining(sBottomMachining As Boolean)
      m_BottomMachining = sBottomMachining
      NotifyPropertyChanged("BottomMachining")
   End Sub

#End Region    ' EdgeType

#Region "EXTERIOR"

   Private m_Exterior As Boolean
   Public Property Exterior As Boolean
      Get
         Return m_Exterior
      End Get
      Set(value As Boolean)
         m_Exterior = value
         NotifyPropertyChanged("Exterior")
         SetDimension("JambIsCheked")
         'JambBIsChecked = value
         SetJambBTIsChecked(value)
         NotifyPropertyChanged("JambBIsChecked")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         SetThicKnessJamb()
         'HingeRabbetJamb()
         'BottomRabbetJamb()
      End Set
   End Property
   Public Sub SetExterior(bExterior As Boolean)
      m_Exterior = bExterior
      NotifyPropertyChanged("Exterior")
   End Sub

   Private m_DeltaBottom As String
   Public Property DeltaBottom As String
      Get
         Return m_DeltaBottom
      End Get
      Set(value As String)
         m_DeltaBottom = value
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         BottomRabbetJamb()
         UpDateAllCompo()
      End Set
   End Property
   Public Sub SetDeltaBottom(sDeltaBottom As String)
      m_DeltaBottom = sDeltaBottom
      NotifyPropertyChanged("DeltaBottom")
   End Sub

#End Region    ' Exterior

#Region "ASSEMBLY DIMENSION"

   Private m_Dimension As Boolean = OptionModule.m_TotalDimension
   Public Property Dimension As Boolean
      Get
         Return m_Dimension
      End Get
      Set(value As Boolean)
         m_Dimension = value
         NotifyPropertyChanged("Dimension")
      End Set
   End Property
   Public Sub SetDimension(bDimension As Boolean)
      m_Dimension = bDimension
      NotifyPropertyChanged("Dimension")
   End Sub

   Private m_AssemblyHeight As String
   Public Property AssemblyHeight As String
      Get
         ' calcolo la dimensione dell'assemblato
         If Not IsNothing(m_Door1) AndAlso Not m_Dimension Then
            Dim nLU As Double = 0
            Dim nLB As Double = 0
            Dim nTH As Double = 0
            Dim nBH As Double = 0
            Dim nOLB As Double = 0
            Dim nDO_1H As Double = 0
            Dim nOLT As Double = 0
            StringToDouble(LightUp, nLU)
            StringToDouble(LightBottom, nLB)
            StringToDouble(ThicknessHead, nTH)
            StringToDouble(ThicknessBottom, nBH)
            StringToDouble(OverlapBottom, nOLB)
            StringToDouble(m_Door1.Height, nDO_1H)
            StringToDouble(OverlapTop, nOLT)
            m_AssemblyHeight = DoubleToString(nLU + nLB + nTH + nDO_1H - nOLT, 4)
            If Exterior Then

               m_AssemblyHeight = DoubleToString(nLU + nLB + nTH + nBH + nDO_1H - nOLT - nOLB, 4)
            End If
         End If
         Return m_AssemblyHeight
      End Get
      Set(value As String)
         m_AssemblyHeight = value
         NotifyPropertyChanged("AssemblyHeight")
         SetDimension("Height")
      End Set
   End Property
   Public Sub SetAssemblyHeight(sAssemblyHeight As String)
      m_AssemblyHeight = sAssemblyHeight
      NotifyPropertyChanged("AssemblyHeight")
   End Sub

   Private m_AssemblyWidth As String
   Public Property AssemblyWidth As String
      Get
         If Not Dimension AndAlso Not IsNothing(Map.refAssemblyManagerVM.ReserchPartDoor("FT_")) AndAlso
            Not IsNothing(Map.refAssemblyManagerVM.ReserchPartDoor("FT_").Door.Width) Then
            Dim nFTW As Double = 0
            Dim nJW As Double = 0
            Dim nOLL As Double
            Dim nOLH As Double
            StringToDouble(Map.refAssemblyManagerVM.ReserchPartDoor("FT_").Door.Width, nFTW)
            StringToDouble(Width, nJW)
            StringToDouble(OverlapLock, nOLL)
            StringToDouble(OverlapHinge, nOLH)
            If DoorNumber = "1" Then
               m_AssemblyWidth = DoubleToString(nFTW + 2 * nJW - nOLL - nOLH, 4)
            Else
               m_AssemblyWidth = DoubleToString(nFTW + 2 * nJW - 2 * nOLH, 4)
            End If
         End If
         Return m_AssemblyWidth
      End Get
      Set(value As String)
         m_AssemblyWidth = value
         SetWidthJamb()
         SetDimension("Width")
         NotifyPropertyChanged("AssemblyWidth")
      End Set
   End Property
   Public Sub SetAssemblyWidth(sAssemblyWidth As String)
      m_AssemblyWidth = sAssemblyWidth
      NotifyPropertyChanged("AssemblyWidth")
   End Sub

   ' questa proprietà è utilizzata per stampare l'altezza della porta nella sezione dei jamb
   Public ReadOnly Property OrigHeightDoor As String
      Get
         If Not IsNothing(m_Door1) Then
            Return m_Door1.Height
         ElseIf Not IsNothing(m_Door2) Then
            Return m_Door2.Height
         End If
         Return "0"
      End Get
   End Property

#End Region    ' Assembly Dimension

#Region "OverMaterial"

   Private m_LockEdgeOverMaterial As String = String.Empty
   Public Property LockEdgeOverMaterial As String
      Get
         Return m_LockEdgeOverMaterial
      End Get
      Set(value As String)
         If String.IsNullOrEmpty(value) Then value = "0"
         Dim dVal As Double
         If StringToDouble(value, dVal) Then
            m_LockEdgeOverMaterial = value
         Else
            MessageBox.Show(EgtMsg(50148), EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Asterisk)
         End If
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.LockEdgeOverMaterial = value
         Next
         'm_LeftJamb.LockEdgeOverMaterial = value
         'm_RightJamb.LockEdgeOverMaterial = value
         'm_TopJamb.LockEdgeOverMaterial = value
         'm_BottomJamb.LockEdgeOverMaterial = value
      End Set
   End Property
   Public Sub SetLockEdgeOverMaterial(sLockEdgeOverMaterial As String)
      m_LockEdgeOverMaterial = sLockEdgeOverMaterial
      NotifyPropertyChanged("LockEdgeOverMaterial")
   End Sub

   Private m_HingeEdgeOverMaterial As String = String.Empty
   Public Property HingeEdgeOverMaterial As String
      Get
         Return m_HingeEdgeOverMaterial
      End Get
      Set(value As String)
         If String.IsNullOrEmpty(value) Then value = "0"
         Dim dVal As Double
         If StringToDouble(value, dVal) Then
            m_HingeEdgeOverMaterial = value
         Else
            MessageBox.Show(EgtMsg(50148), EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Asterisk)
         End If
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.HingeEdgeOverMaterial = value
         Next
         'm_LeftJamb.HingeEdgeOverMaterial = value
         'm_RightJamb.HingeEdgeOverMaterial = value
         'm_TopJamb.HingeEdgeOverMaterial = value
         'm_BottomJamb.HingeEdgeOverMaterial = value
      End Set
   End Property
   Public Sub SetHingeEdgeOverMaterial(sHingeEdgeOverMaterial As String)
      m_HingeEdgeOverMaterial = sHingeEdgeOverMaterial
      NotifyPropertyChanged("HingeEdgeOverMaterial")
   End Sub

   Private m_TopOverMaterial As String = String.Empty
   Public Property TopOverMaterial As String
      Get
         Return m_TopOverMaterial
      End Get
      Set(value As String)
         If String.IsNullOrEmpty(value) Then value = "0"
         Dim dVal As Double
         If StringToDouble(value, dVal) Then
            m_TopOverMaterial = value
         Else
            MessageBox.Show(EgtMsg(50148), EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Asterisk)
         End If
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.TopOverMaterial = value
         Next
         'm_LeftJamb.TopOverMaterial = value
         'm_RightJamb.TopOverMaterial = value
         'm_TopJamb.TopOverMaterial = value
         'm_BottomJamb.TopOverMaterial = value
      End Set
   End Property
   Public Sub SetTopOverMaterial(sTopOverMaterial As String)
      m_TopOverMaterial = sTopOverMaterial
      NotifyPropertyChanged("TopOverMaterial")
   End Sub

   Private m_BottomOverMaterial As String = String.Empty
   Public Property BottomOverMaterial As String
      Get
         Return m_BottomOverMaterial
      End Get
      Set(value As String)
         If String.IsNullOrEmpty(value) Then value = "0"
         Dim dVal As Double
         If StringToDouble(value, dVal) Then
            m_BottomOverMaterial = value
         Else
            MessageBox.Show(EgtMsg(50148), EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Asterisk)
         End If
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         Dim CurrAssembly As Assembly = Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.SelAssembly
         For Each ItemPartDoor In CurrAssembly.ListPartDoor
            If ItemPartDoor.Type.Contains("F") Then ItemPartDoor.Door.BottomOverMaterial = value
         Next
         'm_LeftJamb.BottomOverMaterial = value
         'm_RightJamb.BottomOverMaterial = value
         'm_TopJamb.BottomOverMaterial = value
         'm_BottomJamb.BottomOverMaterial = value
      End Set
   End Property
   Public Sub SetBottomOverMaterial(sBottomOverMaterial As String)
      m_BottomOverMaterial = sBottomOverMaterial
      NotifyPropertyChanged("BottomOverMaterial")
   End Sub

#End Region    ' OverMaterial

#End Region    ' General

   Private m_JambT As Part = Nothing
   Private m_JambB As Part = Nothing
   Private m_JambL As Part = Nothing
   Private m_JambR As Part = Nothing
   Private m_Door1 As Part = Nothing
   Private m_Door2 As Part = Nothing

   Public Property JambTIsChecked As Boolean
      Get
         If IsNothing(m_JambT) Then Return False
         Return m_JambT.IsActive
      End Get
      Set(value As Boolean)
         ' se il pezzo non esiste deve essere creato
         OptionModule.m_TopJambChk = value
         ' setto la sua variabile
         If Not IsNothing(m_JambT) Then
            m_JambT.IsActive = value
            NotifyPropertyChanged("JambTIsChecked")
         End If
         ' se non esiste l'oggeto prima lo creo
         SetDimension("JambIsCheked")
      End Set
   End Property

   Public Property JambBIsChecked As Boolean
      Get
         If IsNothing(m_JambB) Then Return False
         Return m_JambB.IsActive
      End Get
      Set(value As Boolean)
         OptionModule.m_BottomJambChk = value
         ' setto la sua variabile
         If Not IsNothing(m_JambB) Then
            m_JambB.IsActive = value
            NotifyPropertyChanged("JambBIsChecked")
         End If
         ' se non esiste l'oggeto prima lo creo
         SetDimension("JambIsCheked")
      End Set
   End Property

   Public Sub SetJambBTIsChecked(value As Boolean)
      OptionModule.m_BottomJambChk = value
      If Not IsNothing(m_JambB) Then
         m_JambB.IsActive = value
         NotifyPropertyChanged("JambBIsChecked")
         Map.refSceneManagerVM.RefreshBtn()
      End If
   End Sub

   Public Property JambLIsChecked As Boolean
      Get
         If IsNothing(m_JambL) Then Return False
         Return m_JambL.IsActive
      End Get
      Set(value As Boolean)
         OptionModule.m_LeftJambChk = value
         ' setto la sua variabile
         If Not IsNothing(m_JambL) Then
            m_JambL.IsActive = value
            NotifyPropertyChanged("JambLIsChecked")
         End If
         ' se non esiste l'oggeto prima lo creo
         SetDimension("JambIsCheked")

      End Set
   End Property

   Public Property JambRIsChecked As Boolean
      Get
         If IsNothing(m_JambR) Then Return False
         Return m_JambR.IsActive
      End Get
      Set(value As Boolean)
         OptionModule.m_RightJambChk = value
         ' setto la sua variabile
         If Not IsNothing(m_JambR) Then
            m_JambR.IsActive = value
            NotifyPropertyChanged("JambRIsChecked")
         End If
         ' se non esiste l'oggeto prima lo creo
         SetDimension("JambIsCheked")
      End Set
   End Property

#Region "DOOR NUMBER"

   ' carica il numero di porte da mostrare nella combobox
   Private m_DoorListNumber As New List(Of String)
   Public Property DoorListNumber As List(Of String)
      Get
         Return m_DoorListNumber
      End Get
      Set(value As List(Of String))
         m_DoorListNumber = value
      End Set
   End Property

   ' converto il numero di porte letto nella combobox in una lista di stringhe (sDoorList)
   Private m_DoorNumber As String
   Public Property DoorNumber As String
      Get
         Return m_DoorNumber
      End Get
      Set(value As String)
         m_DoorNumber = value
         If Trim(m_DoorNumber) = "1" Then
            OneDoorProperty = True
         Else
            OneDoorProperty = False
         End If
         NotifyPropertyChanged("DoorNumber")
         SetDimension("DoorNumber")
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
         Map.refSceneManagerVM.RefreshBtn()
      End Set
   End Property
   Public Sub SetDoorNumber(sDoorNumber As String)
      DoorListNumber = OptionModule.m_DoorsListNumber
      For Each sNumber In DoorListNumber
         If sNumber = sDoorNumber Then
            m_DoorNumber = sNumber
         End If
      Next
      If Trim(m_DoorNumber) = "1" Then
         OneDoorProperty = True
      Else
         OneDoorProperty = False
      End If
      NotifyPropertyChanged("DoorNumber")
   End Sub

#End Region    ' Door Number

#Region "LIST PART"
   ' al momento della creazione di un nuovo assembalto vengono caricati di defualt:
   ' JambLeft, JambTop, JambRight, JambBottom, Door_1
   Private m_ListPartDoor As New ObservableCollection(Of PartDoor)
   Public Property ListPartDoor As ObservableCollection(Of PartDoor)
      Get
         Return m_ListPartDoor
      End Get
      Set(value As ObservableCollection(Of PartDoor))
         m_ListPartDoor = value
         ' ogni volta che si aggiunge una compoenente riallinea la lista sotto
         NotifyPropertyChanged("ListPartDoorOfDoor")
      End Set
   End Property

   ' questo elenco estrae dall'elenco sopra tutte le ante, cosi da poter essre passata come lista di solo ante nella grafica
   Private m_ListPartDoorOfDoor As New ObservableCollection(Of PartDoor)
   Public ReadOnly Property ListPartDoorOfDoor As ObservableCollection(Of PartDoor)
      Get
         m_ListPartDoorOfDoor.Clear()
         For Each ItemPartDoor In m_ListPartDoor
            If ItemPartDoor.Type.Contains("DO_") Then
               m_ListPartDoorOfDoor.Add(ItemPartDoor)
            End If
         Next
         Return m_ListPartDoorOfDoor
      End Get
   End Property

#End Region    ' List Part

#Region "Lettura Assemblato"

   ' messaggi che possono essere restituiti in fase di lettura dell'assemblato
   Public Enum ResultReadingAssembInfo
      MissingAssembInfo
      ErrorInAssembInfo
      CorrectAssembInfo
   End Enum

   ' carico il valore finale restituito dalla lettura dell'assembalto (di default errore)
   Public bOk As ResultReadingAssembInfo = ResultReadingAssembInfo.ErrorInAssembInfo

   ' vettore di righe del file ddf in lettura
   Private FileContent() As String

   Shared Sub ReadDDFAssembly(sPathDDF As String, ByRef ReadAssembly As Assembly)
      ' durante la lettura del ddf disabilito la costruzione degli hardware sui jamb
      BuiltReffCompo = False
      Dim sErrorInfo As String = String.Empty
      ' controllo se esiste il file DDF
      If Not File.Exists(sPathDDF) Then
         Return
      End If
      ReadAssembly.FileContent = File.ReadAllLines(sPathDDF)
      ' se il file esiste ma è vuoto
      If ReadAssembly.FileContent.Count = 0 Then
         ' 50107: Emplyu file, 50101: Error
         MessageBox.Show(EgtMsg(50107), EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
      End If
      '---------------------------------------------------------------------------------------------------------------------------------
      Dim IndexLine As Integer = 0
      ' carico i valori di default dell'assemblato (dalla pagina delle opzioni)
      Map.refAssemblyManagerVM.LoadAssemblyInformation(ReadAssembly)
      ReadAssembly.bOk = ReadAssembly.GetGeneralAssembly(IndexLine, sErrorInfo)
      Part.bFirstConfigRead = False
      '---------------------------------------------------------------------------------------------------------------------------------
      If ReadAssembly.bOk <> ResultReadingAssembInfo.ErrorInAssembInfo Then
         If IndexLine = -1 Then
            ' 50163= Error in reading General Assembly in DDF
            sErrorInfo += String.Format(EgtMsg(50102), EgtMsg(50163) + vbCrLf)
            ReadAssembly = Nothing
            Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = False
            Map.refMainWindowVM.SelectedPage = MainWindowVM.ListPageEnum.nNothingSelected
         Else
            Map.refSceneManagerVM.EnableRefresh = False
            If ReadAssembly.GetDDFDoor(IndexLine, sErrorInfo) = -1 Then
               ' errore nella lettura di un part: blocco tutto
               ReadAssembly = Nothing
               Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = False
               Map.refMainWindowVM.SelectedPage = MainWindowVM.ListPageEnum.nNothingSelected
            End If
         End If
         Map.refSceneManagerVM.EnableRefresh = True
         If Not IsNothing(ReadAssembly) AndAlso ReadAssembly.bOldVersion Then
            ReadAssembly.CalcOverlapTop()
            ReadAssembly.CalcOverlapBottom()
            ReadAssembly.GetSizeBottom()
         End If
      Else
         ' 50163= Error in reading General Assembly in DDF
         sErrorInfo += String.Format(EgtMsg(50102), EgtMsg(50163) + vbCrLf)
         ReadAssembly = Nothing
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = False
         Map.refMainWindowVM.SelectedPage = MainWindowVM.ListPageEnum.nNothingSelected
      End If
      If Not String.IsNullOrWhiteSpace(sErrorInfo) Then
         ' 50164=In General Assembly:
         sErrorInfo = EgtMsg(50164) & vbCrLf & sErrorInfo
         MessageBox.Show(sErrorInfo, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
      End If
   End Sub

   ' lettura dei parametri generali dell'assemblato
   Private Function GetGeneralAssembly(ByRef IndexLine As Integer, sErrorInfo As String) As ResultReadingAssembInfo
      ' salta le righe vuote e quelle che non contengono "##",
      ' restituisce la prima riga successiva valida,
      ' termina quando incontra la riga "measure" oppure "produce" restituiendo il valore 0
      IndexLine = SkipWhiteSpace(IndexLine)
      ' se non carico nessuna informazione allora non è un assemblato, esco
      If IndexLine = 0 Then Return ResultReadingAssembInfo.MissingAssembInfo

      ' Measure
      If IndexLine < FileContent.Count - 1 Then
         If SearchKey(FileContent(IndexLine), "Unit") Then
            ' leggo le dimemensioni dei Jamb e restituisco la riga successiva
            IndexLine = GetUnit(IndexLine + 1)
            If IndexLine = -1 Then
               ' 50102: Failed reading DDF file. Missing needed parameter {0}.
               sErrorInfo += String.Format(EgtMsg(50102), "measures" + vbCrLf)
               Return ResultReadingAssembInfo.ErrorInAssembInfo
            End If
         Else
            IndexLine = GetUnitFromDoor(IndexLine)
            If IndexLine = -1 Then
               ' 50102: Failed reading DDF file. Missing needed parameter {0}.
               sErrorInfo += String.Format(EgtMsg(50102), "measures" + vbCrLf)
               Return ResultReadingAssembInfo.ErrorInAssembInfo
            End If
         End If
      End If

      IndexLine = SkipWhiteSpace(IndexLine)
      If IndexLine = 0 Then Return ResultReadingAssembInfo.MissingAssembInfo
      ' Size
      If IndexLine < FileContent.Count - 1 Then
         If SearchKey(FileContent(IndexLine), ConstIni.S_SIZE_INI) Then
            ' leggo le dimemensioni dei Jamb e restituisco la riga successiva
            IndexLine = GetSize(IndexLine + 1)
            If IndexLine = -1 Then
               ' 50102: Failed reading DDF file. Missing needed parameter {0}.
               sErrorInfo += String.Format(EgtMsg(50102), ConstIni.S_SIZE_INI + vbCrLf)
               Return ResultReadingAssembInfo.ErrorInAssembInfo
            End If
         End If
      End If

      IndexLine = SkipWhiteSpace(IndexLine)
      If IndexLine = 0 Then Return ResultReadingAssembInfo.MissingAssembInfo
      ' Light
      If IndexLine < FileContent.Count - 1 Then
         If SearchKey(FileContent(IndexLine), ConstIni.S_LIGHT) Then
            IndexLine = GetLight(IndexLine + 1)
            If IndexLine = -1 Then
               ' 50102: Failed reading DDF file. Missing needed parameter {0}.
               sErrorInfo += String.Format(EgtMsg(50102), ConstIni.S_LIGHT + vbCrLf)
               Return ResultReadingAssembInfo.ErrorInAssembInfo
            End If
         End If
      End If

      IndexLine = SkipWhiteSpace(IndexLine)
      If IndexLine = 0 Then Return ResultReadingAssembInfo.MissingAssembInfo
      ' Overlap
      If IndexLine < FileContent.Count - 1 Then
         If SearchKey(FileContent(IndexLine), ConstIni.S_OVERLAP) Then
            IndexLine = GetOverlap(IndexLine + 1)
            If IndexLine = -1 Then
               ' 50102: Failed reading DDF file. Missing needed parameter {0}.
               sErrorInfo += String.Format(EgtMsg(50102), ConstIni.S_OVERLAP + vbCrLf)
               Return ResultReadingAssembInfo.ErrorInAssembInfo
            End If
         End If
      End If

      IndexLine = SkipWhiteSpace(IndexLine)
      If IndexLine = 0 Then Return ResultReadingAssembInfo.MissingAssembInfo
      ' Exterior
      If IndexLine < FileContent.Count - 1 Then
         If SearchKey(FileContent(IndexLine), ConstIni.K_EXTERIOR) Then
            IndexLine = GetExterior(IndexLine + 1)
            If IndexLine = -1 Then
               ' 50102: Failed reading DDF file. Missing needed parameter {0}.
               sErrorInfo += String.Format(EgtMsg(50102), ConstIni.K_EXTERIOR + vbCrLf)
               Return ResultReadingAssembInfo.ErrorInAssembInfo
            End If
         End If
      End If

      IndexLine = SkipWhiteSpace(IndexLine)
      If IndexLine = 0 Then Return ResultReadingAssembInfo.MissingAssembInfo
      ' Profiles
      If IndexLine < FileContent.Count - 1 Then
         If SearchKey(FileContent(IndexLine), ConstIni.S_PROFILES) Then
            IndexLine = GetProfiles(IndexLine + 1)
            If IndexLine = -1 Then
               ' 50102: Failed reading DDF file. Missing needed parameter {0}.
               sErrorInfo += String.Format(EgtMsg(50102), ConstIni.S_PROFILES + vbCrLf)
               Return ResultReadingAssembInfo.ErrorInAssembInfo
            End If
         End If
      End If

      IndexLine = SkipWhiteSpace(IndexLine)
      If IndexLine = 0 Then Return ResultReadingAssembInfo.MissingAssembInfo
      ' Doors
      If IndexLine < FileContent.Count Then
         If SearchKey(FileContent(IndexLine), ConstIni.S_DOORS_ASSEMBY) Then
            ' assegno ad una variabile il valore in lettura
            IndexLine = GetValue(IndexLine, ConstIni.S_DOORS_ASSEMBY, m_DoorNumber, False)
            ' assegno il numero di ante
            SetDoorNumber(m_DoorNumber)
            If IndexLine = -1 Then
               ' 50102: Failed reading DDF file. Missing needed parameter {0}.
               sErrorInfo += String.Format(EgtMsg(50102), ConstIni.S_DOORS_ASSEMBY + vbCrLf)
               Return ResultReadingAssembInfo.ErrorInAssembInfo
            End If
            ' se sono arrivato fino a qui significa che ormai è terminata la pagina
            If IsNothing(m_Exterior) OrElse Not m_Exterior Then
               m_Exterior = False
               m_OverlapBottom = m_OverlapTop
               m_DepthBottom = m_Thickness
               m_ThicknessBottom = m_Width
               ' il delta è sempre definito nullo di default, quindi è inutile scriverlo qui
            End If
         End If
      End If

      Return ResultReadingAssembInfo.CorrectAssembInfo
   End Function

   ' salta le righe che non contengono un metadata
   Private Function SkipWhiteSpace(Index As Integer) As Integer
      Dim ExitLoop As Boolean = False
      While Not ExitLoop And Index < FileContent.Count - 1
         ' se la riga contiene un commeto allora faccio questo controllo
         If FileContent(Index).Contains(ConstCompo.DDF_METADATA) Then
            If Not String.IsNullOrWhiteSpace(Regex.Match(FileContent(Index), "\s*" & DDF_METADATA & "\s*(.*?\b)\s*:\s*$").Groups(1).Value) Then
               ExitLoop = True
            ElseIf Not String.IsNullOrWhiteSpace(Regex.Match(FileContent(Index), "\s*" & DDF_METADATA & "\s*(.*?\b)\s*:\s*(.*?\.*)$").Groups(1).Value) Then
               ExitLoop = True
            ElseIf Not String.IsNullOrWhiteSpace(Regex.Match(FileContent(Index), "\s*(" & ConstCompo.S_MEASURES & ")\s*:\s*(.*?\.*)$").Groups(1).Value) Then
               ExitLoop = True
            Else
               Index += 1
            End If
            ' utilizzando una funzione regex
         ElseIf Not String.IsNullOrWhiteSpace(Regex.Match(FileContent(Index), "\s*(" & ConstCompo.S_MEASURES & ")\s*:\s*(.*?\.*)$").Groups(1).Value) Or
                Not String.IsNullOrWhiteSpace(Regex.Match(FileContent(Index), "\s*(" & ConstCompo.S_PRODUCE & ")\s*:\s*(.*?\.*)$").Groups(1).Value) Then
            '' utilizzando il semplice controllo se la stringa contiene le parole
            'ElseIf Not FileContent(Index).Contains(ConstCompo.S_MEASURES) Or
            '    Not FileContent(Index).Contains(ConstCompo.S_PRODUCE) Then
            Index = 0
            ExitLoop = True
         Else
            Index += 1
         End If
      End While
      Return Index
   End Function

   ' funzione per la ricerca dei valori, restituice la riga successiva
   Private Function GetValue(Index As Integer, Name As String, ByRef Var As String, Optional bConvertUnit As Boolean = True) As Integer
      If Index = -1 Then Return -1
      Dim Local_Var As String = GetValueWithKey(FileContent(Index), Name)
      If String.IsNullOrWhiteSpace(Local_Var) Then
         ' se non c'è la parola chiave allora esci
         If Not SearchKey(FileContent(Index), Name) Then Return -1
         ' altrimenti lascia il valore vuoto
      Else
         If bConvertUnit Then ConvertDDFValueIntoCurrentUnit(m_AssemblyUnit, Local_Var)
         Var = Local_Var
      End If
      Return Index + 1
   End Function

   ' funzione per la ricerca dei profili, restituisce la riga successiva
   Private Function GetValueProfiles(Index As Integer, Name As String, ByRef Var As EdgeType, ByRef VarMachining As Boolean, ByRef VarOverMaterial As String) As Integer
      ' Creo una stringa per scrivere gli errori
      Dim bError As Boolean = False
      If Index = -1 Then
         Return Index
      Else
         ' Lock
         Dim Bevel As String
         Bevel = GetValueWithKey(FileContent(Index), Name)
         ' se il valore restituito è nullo o vuoto
         If String.IsNullOrWhiteSpace(Bevel) Then
            ' se non c'è la parola chiave allora esci
            If Not SearchKey(FileContent(Index), Bevel) Then
               ' restituisco il valore -1
               Return -1
            Else
               Var = EdgeTypeList(0)
            End If
            Index += 1
         Else
            'Dim IndexEdge As Integer = EdgeTypeList.IndexOf(Var)
            Dim IndexEdge As Integer = 0
            For I As Integer = 0 To EdgeTypeList.Count - 1
               If Bevel = EdgeTypeList(I).Name And EdgeTypeList(I).IsActive = Visibility.Visible Then
                  Var = EdgeTypeList(I)
                  IndexEdge = I
                  Exit For
               Else
                  IndexEdge = -1
               End If
            Next

            If IndexEdge = -1 And Bevel = ConstGen.BEVEL_UP Then
               Var = EdgeTypeList(0)
               bError = True
               MsgBevel(bError, Bevel)
               Index += 1
            Else
               Var.Name = EdgeTypeList(IndexEdge).Name
               ' restituisco la riga successiva all'ultimo valore letto
               Index += 1
            End If
         End If
      End If
      If Index = -1 Then
         Return Index
      Else
         Dim Machining = GetValueWithKey(FileContent(Index), K_MACHINING)
         If String.IsNullOrWhiteSpace(Machining) Then
            If Not SearchKey(FileContent(Index), K_MACHINING) Then Return -1
            Index += 1
         Else
            VarMachining = Utility.ConvertOnOffToBoolean(Machining)
            Index += 1
         End If
      End If
      If Index = -1 Then
         Return Index
      Else
         VarOverMaterial = GetValueWithKey(FileContent(Index), K_OVERMATERIAL)
         If String.IsNullOrWhiteSpace(VarOverMaterial) Then
            If Not SearchKey(FileContent(Index), K_OVERMATERIAL) Then Return -1
            Index += 1
         Else
            Index += 1
         End If
      End If
      Return Index
   End Function

   Private Sub MsgBevel(bFound As Boolean, Edge As String)
      If bFound And Not Part.FirstReadingEdge Then
         ' Bevel {0} can not be acceptable in Jamb
         Dim CautionBevel As String = String.Format(EgtMsg(50158), Edge)
         MessageBox.Show(CautionBevel, EgtMsg(50115), MessageBoxButton.OK, MessageBoxImage.Asterisk)
         Part.FirstReadingEdge = True
      End If
   End Sub

   ' Unit (Metadati Assembly)
   Private Function GetUnit(Index As Integer) As Integer
      If Index = -1 Then Return -1
      Dim PreviuosIndex As Integer = Index
      Index = GetValue(Index, "measures", m_AssemblyUnit, False)
      Return Index
   End Function

   ' Measures (Parametri Door)
   Private Function GetUnitFromDoor(Index As Integer) As Integer
      ' inizio la ricerca all'interno del file
      Dim PreviuosIndex As Integer = Index
      Dim bUnitFound As Boolean = False
      ' cerco la prima porta e recupero la sua unità di misura
      While Not SearchKey(FileContent(Index), "measures") And Index < FileContent.Count - 1
         Index += 1
      End While
      If SearchKey(FileContent(Index), "measures") Then
         m_AssemblyUnit = GetValueWithKey(FileContent(Index), "measures")
         bUnitFound = True
      End If
      If bUnitFound Then
         Index = PreviuosIndex
      Else
         Index = -1
      End If
      Return Index
   End Function

   ' Size
   Private Function GetSize(Index As Integer) As Integer
      If Index = -1 Then Return -1
      Index = GetValue(Index, "thickness", m_Thickness)
      If Index = -1 Then Return -1
      Index = GetValue(Index, "width", m_Width)
      Return Index
   End Function

   ' light
   Private Function GetLight(Index As Integer) As Integer
      If Index = -1 Then Return -1
      Index = GetValue(Index, SIDE_UP, m_LightUp)
      If Index = -1 Then Return -1
      Index = GetValue(Index, SIDE_LOCK, m_LightLock)
      If Index = -1 Then Return -1
      Index = GetValue(Index, SIDE_HINGE, m_LightHinge)
      If Index = -1 Then Return -1
      Index = GetValue(Index, K_BOTTOM, m_LightBottom)
      Return Index
   End Function

   ' Overlap
   Private Function GetOverlap(Index As Integer) As Integer
      If Index = -1 Then Return -1
      Index = GetValue(Index, "thickness", m_ThicknessHead)
      If Index = -1 Then Return -1
      Index = GetValue(Index, SIDE_HINGE, m_OverlapHinge)
      If Index = -1 Then Return -1
      Index = GetValue(Index, SIDE_LOCK, m_OverlapLock)
      If Index = -1 Then Return -1
      ' per retrocompatibilità: se questo parametro manca dall'elenco devo comunque continuare
      Dim TempIndex = GetValue(Index, K_TOP, m_OverlapTop)
      If TempIndex > -1 Then
         Index = TempIndex
      Else
         bOldVersion = True
      End If
      If Index = -1 Then Return -1
      Index = GetValue(Index, "deltaT", m_DeltaThickness)
      Return Index
   End Function

   ' Profiles
   Private Function GetProfiles(Index As Integer) As Integer
      If Index = -1 Then Return -1
      Index = GetValueProfiles(Index, K_LOCKEDGE, m_LockEdgeType, m_LockEdgeMachining, m_LockEdgeOverMaterial)
      If Index = -1 Then Return -1
      Index = GetValueProfiles(Index, K_HINGEEDGE, m_HingeEdgeType, m_HingeEdgeMachining, m_HingeEdgeOverMaterial)
      If Index = -1 Then Return -1
      Index = GetValueProfiles(Index, K_TOP, m_TopType, m_TopMachining, m_TopOverMaterial)
      If Index = -1 Then Return -1
      Index = GetValueProfiles(Index, K_BOTTOM, m_BottomType, m_BottomMachining, m_BottomOverMaterial)
      Return Index
   End Function

   ' exterior
   Private Function GetExterior(Index As Integer) As Integer
      ' devo distingiure la lettura in funzione della versione del file DDF
      m_Exterior = True
      If Not bOldVersion Then
         If Index = -1 Then Return -1
         Index = GetValue(Index, K_OVERLAP_BOTTOM, m_OverlapBottom)
         If Index = -1 Then Return -1
         Index = GetValue(Index, K_THICKNESS_BOTTOM, m_ThicknessBottom)
         If Index = -1 Then Return -1
         Index = GetValue(Index, K_DEPTH_BOTTOM, m_DepthBottom)
         If Index = -1 Then Return -1
         Index = GetValue(Index, K_DELTA_BOTTOM, m_DeltaBottom)
      Else
         If Index = -1 Then Return -1
         Index = GetValue(Index, K_TOP, m_OverlapTop)
      End If
      'If Index = -1 Then Return -1
      'Index = GetValue(Index, "deltaT", m_DeltaThickness)
      Return Index
   End Function

   ' dopo la lettura delle informazioni dell'assemblato
   Private Function GetDDFDoor(IndexLine As Integer, ByRef sErrorInfo As String) As Integer
      Dim Line As Integer = IndexLine
      While Line < FileContent.Count - 1 AndAlso Not Search3Dots(FileContent(Line))
         Dim Local_PartDoor As New PartDoor
         Dim Local_Door As New Part(Local_PartDoor)
         ' carcio la liste delle propiretà
         'CreateNewPropertiesList(Local_Door.PropertiesList, Local_Door.SelectedMaterial)
         CreateNewPropertiesList(Local_Door)
         If Line > 0 Then
            ' per saltare la riga che è stata appena restituita che contiene "---"
            Line += 1
         End If
         ' se la  lettura di un oggetto fallisce allora restituisce nothing
         Part.ReadDDFPartDoor(FileContent, Line, Local_Door)
         ' se l'oggetto appena restituito non esiste allora esco
         If IsNothing(Local_Door) Then Return -1
         ' se l'getto appena caricato non specifica il tipo di pezzo allora di default è la prima anta
         If String.IsNullOrEmpty(Local_Door.TypePart) Then Local_Door.TypePart = ConstGen.PART_DO_ & "1"
         Dim sDoorPiece As String = Local_Door.TypePart

         ' ricavo il tipo di pezzo eliminando la descrizione dello swing da "TypePart"
         If OptionModule.m_ConfigurationSoftware = ConfigType.Assembly Then
            If sDoorPiece.Count > 3 AndAlso sDoorPiece.Contains(ConstGen.PART_FRAME) Then
               sDoorPiece = sDoorPiece.Remove(sDoorPiece.LastIndexOf("_"c) + 1)
            End If
            Map.refCompoPanelVM.GoBackVisibility = Visibility.Visible
            Map.refMainWindowVM.SelectedPage = MainWindowVM.ListPageEnum.nAssemblyPage
         Else
            ' significa che stiamo per leggere una porta singola, cerco una porta
            If Not Local_Door.TypePart.Contains("DO_") Then
               ' 50518=The current ddf is an Assembly. Any modify will be saved as single door.
               sErrorInfo = EgtMsg(50518)
               Continue While
            End If
            Local_Door.IsActive = True
            Local_PartDoor.Door = Local_Door
            Local_PartDoor.Door.SwingTypeList = OptionModule.m_SwingTypeList
            Local_PartDoor.Door.MaterialsList = OptionModule.m_MaterialList
            Local_PartDoor.SetIsChecked(Local_Door.IsActive)
            ListPartDoor.Add(Local_PartDoor)
            Map.refPartPageVM.CurrPart = Local_Door
            Map.refCompoPanelVM.GoBackVisibility = Visibility.Collapsed
            Map.refMainWindowVM.SelectedPage = MainWindowVM.ListPageEnum.nDDFPage
            Exit While
         End If

         ' impedisco di costruire i riferminti 
         BuiltReffCompo = False
         Select Case sDoorPiece
            Case ConstGen.PART_DO_ & "1"
               Local_PartDoor.Door = Local_Door
               Local_PartDoor.Door.SwingTypeList = m_SwingTypeListSinlgeDoor
               'CreateNewPropertiesList(Local_Door.PropertiesList, Local_Door.SelectedMaterial)
               CreateNewPropertiesList(Local_Door)
               Local_PartDoor.SetIsChecked(Local_Door.IsActive)
               ListPartDoor.Add(Local_PartDoor)
            Case ConstGen.PART_DO_ & "2"
               Local_PartDoor.Door = Local_Door
               If Not IsNothing(Map.refAssemblyManagerVM.ReserchPartDoor("DO_1")) Then
                  Local_PartDoor.Door.SwingTypeList = m_SwingTypeListRightDoor
                  Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door.SwingTypeList = m_SwingTypeListLeftDoor
               Else
                  Local_PartDoor.Door.SwingTypeList = m_SwingTypeListSinlgeDoor
               End If
               'CreateNewPropertiesList(Local_Door.PropertiesList, Local_Door.SelectedMaterial)
               CreateNewPropertiesList(Local_Door)
               Local_PartDoor.SetIsChecked(Local_Door.IsActive)
               ListPartDoor.Add(Local_PartDoor)

            Case ConstGen.PART_DO_ & "3"
               Local_PartDoor.Door = Local_Door
               Local_PartDoor.SetIsChecked(Local_Door.IsActive)
               ListPartDoor.Add(Local_PartDoor)
               'SetArrayPartDoor(Local_PartDoor, 2)
            Case ConstGen.PART_DO_ & "4"
               Local_PartDoor.Door = Local_Door
               Local_PartDoor.SetIsChecked(Local_Door.IsActive)
               ListPartDoor.Add(Local_PartDoor)
               'SetArrayPartDoor(Local_PartDoor, 3)
            Case ConstGen.PART_DO_ & "5"
               Local_PartDoor.Door = Local_Door
               Local_PartDoor.SetIsChecked(Local_Door.IsActive)
               'SetArrayPartDoor(Local_PartDoor, 4)
            Case ConstGen.PART_DO_ & "6"
               Local_PartDoor.Door = Local_Door
               Local_PartDoor.SetIsChecked(Local_Door.IsActive)
               ListPartDoor.Add(Local_PartDoor)
               'SetArrayPartDoor(Local_PartDoor, 5)

            Case ConstGen.PART_FRAME_LEFT
               Local_PartDoor.Door = Local_Door
               Local_Door.SwingTypeList = m_SwingTypeList
               'CreateNewPropertiesList(Local_Door.PropertiesList, Local_Door.SelectedMaterial)
               CreateNewPropertiesList(Local_Door)
               ListPartDoor.Add(Local_PartDoor)
               'm_LeftJamb = Local_Door
            Case ConstGen.PART_FRAME_RIGHT
               Local_PartDoor.Door = Local_Door
               Local_Door.SwingTypeList = m_SwingTypeList
               'CreateNewPropertiesList(Local_Door.PropertiesList, Local_Door.SelectedMaterial)
               CreateNewPropertiesList(Local_Door)
               ListPartDoor.Add(Local_PartDoor)
               'm_RightJamb = Local_Door
            Case ConstGen.PART_FRAME_TOP
               Local_PartDoor.Door = Local_Door
               Local_Door.SwingTypeList = m_SwingTypeList
               'CreateNewPropertiesList(Local_Door.PropertiesList, Local_Door.SelectedMaterial)
               CreateNewPropertiesList(Local_Door)
               ListPartDoor.Add(Local_PartDoor)
               'm_TopJamb = Local_Door
            Case ConstGen.PART_FRAME_BOTTOM
               Local_PartDoor.Door = Local_Door
               Local_Door.SwingTypeList = m_SwingTypeList
               'CreateNewPropertiesList(Local_Door.PropertiesList, Local_Door.SelectedMaterial)
               CreateNewPropertiesList(Local_Door)
               ListPartDoor.Add(Local_PartDoor)
               'm_BottomJamb = Local_Door
               If Not m_Exterior Then Local_PartDoor.Door.IsActive = False
         End Select
      End While

      ' controllo che gli oggetti che sono stati caricati
      If Not ControlAssemblyInformation() Then
         Return -1
      Else
         Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = False
      End If
      ' scrivo in locale un a copia dei riferiemti ai part
      SetPartDoorCurrAssembly()
      If Not OptionModule.m_ConfigurationSoftware = ConfigType.Door Then
         If Not ControlListDoor() Then
            Return -1
         End If
         If Not ControlSwing() Then
            Return -1
         End If
      End If
      BuiltReffCompo = True
      Map.refAssemblyManagerVM.CreateAssociation(Me)
      MatchCompo()
      'Map.refProjectManagerVM.NotifyPropertyChanged("VisibilityCreateAssembly")
      Return 1
   End Function

   ' verifico che la dicitaura delle porte sia coerente
   Private Function ControlListDoor() As Boolean
      Dim WritingError As String = String.Empty
      Select Case ListPartDoorOfDoor.Count
         Case 1
            ' se ho una porta soltanto deve essere la prima
            If IsNothing(m_Door1) Then
               WritingError = EgtMsg(50506)
               MessageBox.Show(WritingError, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
               Return False
            Else
               Return True
            End If
         Case 2
            If ListPartDoorOfDoor.Count < 2 Then Return False
            If IsNothing(m_Door1) OrElse IsNothing(m_Door2) Then
               ' 50513=Impossible to find the first door (DO_1) or the second door (DO_2)!
               WritingError = EgtMsg(50513)
               MessageBox.Show(WritingError, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
               Return False
            End If
            If Not ListPartDoorOfDoor(0).Door.TypePart = "DO_1" Then
               ' 50515=The first door is not realy the first, check the ddf.
               WritingError = EgtMsg(50515)
               MessageBox.Show(WritingError, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
               Return False
            End If
            Return True
      End Select
      Return False
   End Function

   ' controllo che gli swing siano coerenti:
   Private Function ControlSwing() As Boolean
      Dim ErrorSwingMessages As String = String.Empty
      Select Case ListPartDoorOfDoor.Count
         Case 1
            Dim Local_Door1 As Part = ListPartDoorOfDoor(0).Door
            Dim Local_Swing As String = Local_Door1.Swing
            Local_Door1.SwingTypeList = OptionModule.m_SwingTypeListSinlgeDoor
            If String.IsNullOrEmpty(Local_Swing) Then Return False
            Dim Index As Integer = Local_Door1.SwingTypeList.FindIndex(Function(sValue) Trim(sValue) = Trim(Local_Swing))
            ' se Index = -1 significa che non è stata trovata nessuna corrispondenza
            If Index < 0 Then
               ' 50507=The swing is not a member of the swing list of single door.
               ErrorSwingMessages = EgtMsg(50507)
               MessageBox.Show(ErrorSwingMessages, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
               Return False
            End If
            Local_Door1.Swing = Local_Door1.SwingTypeList(Index)
            Return True
         Case 2
            Dim Index_1 As Integer = -1
            Dim Index_2 As Integer = -1
            If Not IsNothing(m_Door1) Then
               Index_1 = OptionModule.m_SwingTypeListLeftDoor.FindIndex(Function(sValue) Trim(sValue) = Trim(m_Door1.Swing))
            End If
            If Not IsNothing(m_Door2) Then
               Index_2 = OptionModule.m_SwingTypeListRightDoor.FindIndex(Function(sValue) Trim(sValue) = Trim(m_Door2.Swing))
            End If
            ' Se uno swing è corretto e l'altro è sbagliato
            If (Index_1 < 0 AndAlso Index_2 > -1) Then
               ' 50508=The swing of left door is not a member of the swing list of left door.
               ErrorSwingMessages = EgtMsg(50508)
               MessageBox.Show(ErrorSwingMessages, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
               Return False
            ElseIf (Index_1 > -1 AndAlso Index_2 < 0) Then
               ' 50509=The swing of right door is not a member of the swing list of right door.
               ErrorSwingMessages = EgtMsg(50509)
               MessageBox.Show(ErrorSwingMessages, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
               Return False
            End If
            ' se sono entrambi sbagliati provo a verificare che non siano invertite le ante
            If Index_1 < 0 OrElse Index_2 < 0 Then
               If Not IsNothing(m_Door2) Then
                  Index_1 = OptionModule.m_SwingTypeListLeftDoor.FindIndex(Function(sValue) Trim(sValue) = Trim(m_Door2.Swing))
               End If
               If Not IsNothing(m_Door1) Then
                  Index_2 = OptionModule.m_SwingTypeListRightDoor.FindIndex(Function(sValue) Trim(sValue) = Trim(m_Door1.Swing))
               End If
               ' verifico i risultati ottenuti
               If (Index_1 > -1 AndAlso Index_2 > -1) Then
                  ' 50510=The swing of left door is on the right door and viceverse.
                  ErrorSwingMessages = EgtMsg(50510)
                  MessageBox.Show(ErrorSwingMessages, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
                  Return False
               ElseIf (Index_1 < 0 AndAlso Index_2 > -1) Then
                  ' 50511=The swing of left door is not a member of the swing list of left door.
                  ErrorSwingMessages = EgtMsg(50511)
                  MessageBox.Show(ErrorSwingMessages, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
                  Return False
               ElseIf (Index_1 > -1 AndAlso Index_2 < 0) Then
                  ' 50512=The swing of right door is not a member of the swing list of right door.
                  ErrorSwingMessages = EgtMsg(50512)
                  MessageBox.Show(ErrorSwingMessages, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
                  Return False
               Else
                  ' 50514=The swing are absolutly wrong!
                  ErrorSwingMessages = EgtMsg(50514)
                  MessageBox.Show(ErrorSwingMessages, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
                  Return False
               End If
            End If
            Return True
      End Select
      Return False
   End Function

   ' controllo degli oggetti caricati nell'assemblato
   Private Function ControlAssemblyInformation() As Boolean
      Dim ErrorMessages As String = String.Empty
      Select Case bOk
         Case ResultReadingAssembInfo.CorrectAssembInfo
            If OptionModule.m_ConfigurationSoftware = ConfigType.Door Then
               ' 50520=The current ddf is an assembly
               ErrorMessages = EgtMsg(50520)
               MessageBox.Show(ErrorMessages, EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
               Return True
            End If
            ' verifico se è un assemblato
            If ListPartDoor.Count < 4 And ListPartDoorOfDoor.Count > 0 Then
               ' 50516=The current ddf contains {0} jambs.
               ErrorMessages = EgtMsg(50516)
               Dim sVal As String = Utility.DoubleToString(ListPartDoor.Count - ListPartDoorOfDoor.Count, 0)
               ' 50144=Warning
               MessageBox.Show(String.Format(ErrorMessages, sVal), EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
               Return True
            End If
            If ListPartDoor.Count < 4 And ListPartDoorOfDoor.Count = 0 Then
               ' 50517=The current ddf does not contains doors!
               ErrorMessages = EgtMsg(50517)
               MessageBox.Show(ErrorMessages, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
               Return False
            End If
         Case ResultReadingAssembInfo.MissingAssembInfo
            ' verifico se è un assemblato
            If ListPartDoor.Count < 4 And ListPartDoorOfDoor.Count > 0 Then
               If OptionModule.m_ConfigurationSoftware = ConfigType.Door Then Return True
               ' 50518=The current ddf is not an assembly.
               ErrorMessages = EgtMsg(50518)
               MessageBox.Show(ErrorMessages, EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
               Return True
            End If
            ' verifico che se è una porta singola oppure un assemblato vecchio
            If ListPartDoor.Count < 4 And ListPartDoorOfDoor.Count = 0 Then
               ' 50519=Impossible to open a ddf with no doors.
               ErrorMessages = EgtMsg(50519)
               MessageBox.Show(ErrorMessages, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
               Return False
            End If
            If OptionModule.m_ConfigurationSoftware = ConfigType.Door AndAlso ListPartDoor.Count > 4 Then
               ' 50520=The current ddf is an assembly
               ErrorMessages = EgtMsg(50520)
               MessageBox.Show(ErrorMessages, EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
               Return True
            End If
         Case Else
            Return False
      End Select
      Return True
   End Function

   Public Function ControlAssembly(Optional ByVal bSaving As Boolean = False) As String
      ' se è una porta singola oppure le info generali non sono state caricate correttamente non controllo l'assemblato
      If bSaving Then
         If bOk <> ResultReadingAssembInfo.MissingAssembInfo Then Return String.Empty
      Else
         If bOk = ResultReadingAssembInfo.ErrorInAssembInfo OrElse bOk = ResultReadingAssembInfo.MissingAssembInfo Then Return String.Empty
      End If
      Dim WritingError As String = String.Empty
      Dim DoorTypeList As String = String.Empty
      If ListPartDoor.Count < 3 Then
         For Each ItemPart In ListPartDoor
            DoorTypeList &= " ," & ItemPart.Door.TypePart
         Next
         DoorTypeList = DoorTypeList.Remove(1, 1)
         WritingError = String.Format(EgtMsg(50505), DoorTypeList)
      End If
      Return WritingError
   End Function

   ' ricavo dal JambT il valore di OverlabTop
   Public Sub CalcOverlapTop()
      Dim Jamb As Part = m_JambT
      Dim IndexSide As Integer = 2
      Dim Indexparam As Integer = 2
      If Not IsNothing(Jamb) Then
         Dim IndexCompo As Integer = GetRabbetCompo(Jamb, IndexSide)
         SetOverlapTop(GetValueParam(Jamb, IndexSide, Indexparam))
      End If
   End Sub

   ' ricavo dal JambB il valore di OverlabBottom
   Public Sub CalcOverlapBottom()
      Dim Jamb As Part = m_JambB
      Dim IndexSide As Integer = 2
      Dim Indexparam As Integer = 2
      If Not IsNothing(Jamb) Then
         Dim IndexCompo As Integer = GetRabbetCompo(Jamb, IndexSide)
         SetOverlapBottom(GetValueParam(Jamb, IndexSide, Indexparam))
      End If
   End Sub

   ' restituisce l'indice della componente nella lista delle componeti del jamb
   Public Function GetRabbetCompo(ByVal Jamb As Part, ByVal IndexSide As Integer) As Integer
      ' IndexSide: 0->Top, 1->bottom , 2->hinge , 3->lock
      ' se ritorna "-2" significa che non esiste la componente rabbet nell'elenco dei direttori
      ' se ritorna "-1" significa che non esiste la componente rabbet nell'elenco delle componenti del Jamb
      Dim IndexCompo As Integer
      Dim IndexCompoPanel As Integer = -1
      ' ricerco la posizione del rabbet nella lista dei componenti
      IndexCompoPanel = nCompoRabbet()
      ' se la ricerca ha dato un esito positivo allora procedo
      If IndexCompoPanel = -1 Then Return -2
      If Jamb.CompoList.Count > 0 Then
         ' inizio la ricerca della componente di tipo rabbet
         For IndexCompo = 0 To Jamb.CompoList.Count - 1
            If Jamb.CompoList(IndexCompo).CompoType.DDFName = OptionModule.m_CompoPaneOrder(IndexCompoPanel) Then
               If DirectCast(Jamb.CompoList(IndexCompo).CompoParamList(0), ComboBoxParam).SelItem = DirectCast(Jamb.CompoList(IndexCompo).CompoParamList(0), ComboBoxParam).ItemList(IndexSide) Then
                  Return IndexCompo
               End If
            End If
         Next
      End If
      Return -1
   End Function

   ' utlizzata per recuperare il valore di un parametro del rabbet
   Public Function GetValueParam(Jamb As Part, IndexSide As Integer, IndexParam As Integer) As String
      If Not IsNothing(Jamb) Then
         ' verifico che il rabbet indicato sia costruito su uno specifico lato
         Dim IndexCompo As Integer = GetRabbetCompo(Jamb, IndexSide)
         If IndexCompo < 0 Then
            Return "0"
         End If
         ' ricerco il parametro "depth"
         If Jamb.CompoList(IndexCompo).CompoParamList.Count - 1 >= IndexParam Then
            Dim sValue As String = DirectCast(Jamb.CompoList(IndexCompo).CompoParamList(IndexParam), TextBoxParam).Value
            If Not String.IsNullOrEmpty(sValue) Then Return sValue
         End If
      End If
      Return "0"
   End Function

   ' carico le dimensioni del bottom direttamente del frame
   Public Sub GetSizeBottom()
      If IsNothing(m_JambB) Then Return
      SetThicknessBottom(m_JambB.Height)
      SetDepthBottom(m_JambB.Thickness)
      ' calcolo il delta del bottom
      If Not IsNothing(m_Door1) Then
         Dim dPositionZ As Double
         Dim dThicknessBottom As Double
         Dim dThicknessDoor As Double
         Dim dDeltaThickness As Double
         StringToDouble(m_JambB.Height, dThicknessBottom)
         StringToDouble(m_Door1.Thickness, dThicknessDoor)
         StringToDouble(m_DeltaThickness, dDeltaThickness)
         StringToDouble(m_JambB.Position(2), dPositionZ)
         Dim dDeltaBottom As Double = dThicknessBottom - dThicknessDoor - dDeltaThickness - dPositionZ
         SetDeltaBottom(DoubleToString(dDeltaBottom, 4))
      End If
   End Sub

#Region "Associazione delle compo lette da ddf"

   Public Sub MatchCompo()
      If IsNothing(m_Door1) Then Return
      For Each ItemDoor In ListPartDoorOfDoor
         If Not IsNothing(m_JambL) Then ResearchMatchJamb(ItemDoor.Door, m_JambL)
         If Not IsNothing(m_JambR) Then ResearchMatchJamb(ItemDoor.Door, m_JambR)
         If Not IsNothing(m_JambT) Then ResearchMatchJamb(ItemDoor.Door, m_JambT)
         If Not IsNothing(m_JambB) Then ResearchMatchJamb(ItemDoor.Door, m_JambB)
      Next
      If Not IsNothing(m_Door2) Then
         ResearchMatchDoor(m_Door1, m_Door2)
         ResearchMatchDoor(m_Door2, m_Door1)
         SetDoorNumber("2")
      Else
         SetDoorNumber("1")
      End If
   End Sub

   ' setta per ogni componente sul telaio la proprietà "IsReadOnly" letta dal file Matching
   Private Sub ResearchMatchJamb(Door As Part, Jamb As Part)
      For IndexCompo As Integer = 0 To Door.CompoList.Count - 1
         ReSearchFrameFile(Door.CompoList(IndexCompo))
         If Not String.IsNullOrEmpty(Door.CompoList(IndexCompo).IdCode) Then
            ' cerco l'associazione delle compo sulla porta con le componenti sul telaio
            For IndexCompoJamb As Integer = 0 To Jamb.CompoList.Count - 1
               If Trim(Jamb.CompoList(IndexCompoJamb).IdCode) = Trim(Door.CompoList(IndexCompo).IdCode) Then
                  Door.CompoList(IndexCompo).refJambCompo = Jamb.CompoList(IndexCompoJamb)
                  Jamb.CompoList(IndexCompoJamb).refCompoDoor = Door.CompoList(IndexCompo)
                  Door.CompoList(IndexCompo).refJambCompo.VisibilitiReloadBtn = Visibility.Visible
                  Door.CompoList(IndexCompo).refJambCompo.IsReadOnly = True
                  Door.CompoList(IndexCompo).IsReadOnly = False
                  ' definisco la proprietà ReadOnly per i parametri inseriti
                  If Not LoadCompoParam(Door.CompoList(IndexCompo), Door.TypePart) Then Return
                  For IndexParam As Integer = 0 To Door.CompoList(IndexCompo).refJambCompo.CompoParamList.Count - 1
                     Dim CmpRefPar As CompoParam = Door.CompoList(IndexCompo).refJambCompo.CompoParamList(IndexParam)
                     If TypeOf CmpRefPar Is TextBoxOnOffParam Then
                        Dim TBoxRefPar As TextBoxOnOffParam = DirectCast(CmpRefPar, TextBoxOnOffParam)
                        CalcCompoParamVisibility(TBoxRefPar.DDFName, TBoxRefPar.IsReadOnly)
                     ElseIf TypeOf CmpRefPar Is TextBoxParam Then
                        Dim TBoxRefPar As TextBoxParam = DirectCast(CmpRefPar, TextBoxParam)
                        CalcCompoParamVisibility(TBoxRefPar.DDFName, TBoxRefPar.IsReadOnly)
                     ElseIf TypeOf CmpRefPar Is ComboBoxOnOffParam Then
                        Dim TBoxRefPar As ComboBoxOnOffParam = DirectCast(CmpRefPar, ComboBoxOnOffParam)
                        CalcCompoParamVisibility(TBoxRefPar.DDFName, TBoxRefPar.IsReadOnly)
                     ElseIf TypeOf CmpRefPar Is ComboBoxParam Then
                        Dim TBoxRefPar As ComboBoxParam = DirectCast(CmpRefPar, ComboBoxParam)
                        CalcCompoParamVisibility(TBoxRefPar.DDFName, TBoxRefPar.IsReadOnly)
                     End If
                  Next
                  ResetCompoParam()
                  Exit For
               End If
            Next
         Else
            Door.CompoList(IndexCompo).IsReadOnly = False
         End If
      Next
   End Sub

   ' setta per ogni componente (associata) sulla porta inattiva la proprietà "IsReadOnly" letta dal file Matching
   Private Sub ResearchMatchDoor(DoorActive As Part, DoorInactive As Part)
      If Not DoorActive.SwingAlias.Name.Contains(ConstGen.INACTIVE) Then
         For IndexCompo As Integer = 0 To DoorActive.CompoList.Count - 1
            If Not String.IsNullOrEmpty(DoorActive.CompoList(IndexCompo).IdCode) Then
               For IndexCompoInactiveDoor As Integer = 0 To DoorInactive.CompoList.Count - 1
                  ' cerco l'associazione delle compo sulla porta attiva con le componenti sulla porta inattiva
                  Dim Local_Copo As Compo
                  If Trim(DoorInactive.CompoList(IndexCompoInactiveDoor).IdCode) = Trim(DoorActive.CompoList(IndexCompo).IdCode) Then
                     If DoorActive.CompoList(IndexCompo).MatchedDoor Then
                        DoorInactive.CompoList(IndexCompoInactiveDoor).refJambCompo = DoorActive.CompoList(IndexCompo)
                        DoorInactive.CompoList(IndexCompoInactiveDoor).refJambCompo.VisibilitiReloadBtn = Visibility.Visible
                        DoorActive.CompoList(IndexCompo).refCompoDoor = DoorInactive.CompoList(IndexCompoInactiveDoor)
                        DoorInactive.CompoList(IndexCompoInactiveDoor).refJambCompo.IsReadOnly = False
                        DoorInactive.CompoList(IndexCompoInactiveDoor).refJambCompo.VisibilitiReloadBtn = Visibility.Visible
                        DoorInactive.CompoList(IndexCompoInactiveDoor).IsReadOnly = True
                        If Not LoadCompoParam(DoorInactive.CompoList(IndexCompoInactiveDoor), DoorActive.TypePart) Then Return
                        ' assegno la componente
                        Local_Copo = DoorInactive.CompoList(IndexCompoInactiveDoor).refJambCompo
                     Else
                        DoorActive.CompoList(IndexCompo).refJambCompo = DoorInactive.CompoList(IndexCompoInactiveDoor)
                        DoorActive.CompoList(IndexCompo).refJambCompo.VisibilitiReloadBtn = Visibility.Visible
                        DoorInactive.CompoList(IndexCompoInactiveDoor).refCompoDoor = DoorActive.CompoList(IndexCompo)
                        DoorActive.CompoList(IndexCompo).VisibilitiReloadBtn = Visibility.Visible
                        DoorActive.CompoList(IndexCompo).refJambCompo.IsReadOnly = False
                        DoorActive.CompoList(IndexCompo).IsReadOnly = True
                        ' assegno la componente
                        If Not LoadCompoParam(DoorActive.CompoList(IndexCompo), DoorActive.TypePart) Then Return
                        Local_Copo = DoorActive.CompoList(IndexCompo).refJambCompo
                     End If
                     'DoorActive.CompoList(IndexCompo).refJambCompo = DoorInactive.CompoList(IndexCompoInactiveDoor)
                     'DoorInactive.CompoList(IndexCompoInactiveDoor).refCompoDoor = DoorActive.CompoList(IndexCompo)
                     'DoorActive.CompoList(IndexCompo).VisibilitiReloadBtn = Visibility.Visible
                     'DoorActive.CompoList(IndexCompo).refJambCompo.IsReadOnly = False
                     'DoorActive.CompoList(IndexCompo).IsReadOnly = True
                     'If Not LoadCompoParam(DoorActive.CompoList(IndexCompo), DoorActive.TypePart) Then Return
                     For IndexParam As Integer = 0 To Local_Copo.CompoParamList.Count - 1
                        'Dim CmpPar As CompoParam = DoorActive.CompoList(IndexCompo).CompoParamList(IndexParam)
                        Dim CmpRefPar As CompoParam = Local_Copo.CompoParamList(IndexParam)
                        If TypeOf CmpRefPar Is TextBoxOnOffParam Then
                           'Dim TBoxPar As TextBoxOnOffParam = DirectCast(CmpPar, TextBoxOnOffParam)
                           Dim TBoxRefPar As TextBoxOnOffParam = DirectCast(CmpRefPar, TextBoxOnOffParam)
                           'CalcCompoParamVisibility(TBoxPar.DDFName, TBoxRefPar.IsReadOnly)
                           'TBoxPar.IsReadOnly = True
                           CalcCompoParamVisibility(TBoxRefPar.DDFName, TBoxRefPar.IsReadOnly)
                        ElseIf TypeOf CmpRefPar Is TextBoxParam Then
                           'Dim TBoxPar As TextBoxParam = DirectCast(CmpPar, TextBoxParam)
                           Dim TBoxRefPar As TextBoxParam = DirectCast(CmpRefPar, TextBoxParam)
                           'CalcCompoParamVisibility(TBoxPar.DDFName, TBoxRefPar.IsReadOnly)
                           'TBoxPar.IsReadOnly = True
                           CalcCompoParamVisibility(TBoxRefPar.DDFName, TBoxRefPar.IsReadOnly)
                        ElseIf TypeOf CmpRefPar Is ComboBoxOnOffParam Then
                           'Dim TBoxPar As ComboBoxOnOffParam = DirectCast(CmpPar, ComboBoxOnOffParam)
                           Dim TBoxRefPar As ComboBoxOnOffParam = DirectCast(CmpRefPar, ComboBoxOnOffParam)
                           'CalcCompoParamVisibility(TBoxPar.DDFName, TBoxRefPar.IsReadOnly)
                           'TBoxPar.IsReadOnly = True
                           CalcCompoParamVisibility(TBoxRefPar.DDFName, TBoxRefPar.IsReadOnly)
                        ElseIf TypeOf CmpRefPar Is ComboBoxParam Then
                           'Dim TBoxPar As ComboBoxParam = DirectCast(CmpPar, ComboBoxParam)
                           Dim TBoxRefPar As ComboBoxParam = DirectCast(CmpRefPar, ComboBoxParam)
                           'CalcCompoParamVisibility(TBoxPar.DDFName, TBoxRefPar.IsReadOnly)
                           'TBoxPar.IsReadOnly = True
                           CalcCompoParamVisibility(TBoxRefPar.DDFName, TBoxRefPar.IsReadOnly)
                        End If
                     Next
                     ResetCompoParam()
                     Exit For
                  End If
               Next
            Else
               DoorActive.CompoList(IndexCompo).IsReadOnly = True
            End If
         Next
      End If

   End Sub

   ' in fase di cricamento della porta verifico se posso esistere delle componenti da associare
   ' infatti potrebbe esistere una componente sull'anta ma non sul telaio
   ' il caso contrario è vietato dal programma (a meno che non sia stato modificato il ddf manualmente)
   Public Function ReSearchFrameFile(ByVal CurrCompo As Compo) As Boolean
      ' se è la configurazione è di songola porta allora interrompi la costruzione
      If OptionModule.m_ConfigurationSoftware = ConfigType.Door Then Return False
      ' nome del file Matchting.ini
      Dim FrameFile As String = String.Empty
      ' percorso del file di Config.ini del file frame
      Dim FrameFileConfig As String = String.Empty
      ' numero di ante presenti nel progetto corrente
      Dim nDoorNbr As Integer = 1

      ' cerco il nome della componente da associare FrameFile
      Dim CurrDoorHArdwareFile As String = CurrCompo.CompoType.Path & "\" & CurrCompo.TemplateSelItem
      If Path.GetExtension(CurrDoorHArdwareFile) <> NGE_EXTENSION Then
         CurrDoorHArdwareFile &= LUA_EXTENSION
      End If
      ' cerco il campo [Match file] nel file lua della componente
      If File.Exists(CurrDoorHArdwareFile) Then
         Dim ReadCurrCompo() As String = File.ReadAllLines(CurrDoorHArdwareFile)
         For LineIndex = 0 To ReadCurrCompo.Count - 1
            If RegexFunction.IsMatchingParameterTitle(ReadCurrCompo(LineIndex)) Then
               ' mi preparo per leggere la prima riga dopo il titolo
               Dim ParamIndex As Integer = 1
               FrameFile = Trim(RegexFunction.ParamLine(ReadCurrCompo(LineIndex + ParamIndex), K_MATCHING_FILE))
               While String.IsNullOrEmpty(FrameFile) And LineIndex + ParamIndex < ReadCurrCompo(LineIndex + ParamIndex).Count
                  ParamIndex += 1
                  FrameFile = Trim(RegexFunction.ParamLine(ReadCurrCompo(LineIndex + ParamIndex), K_MATCHING_FILE))
               End While
               Exit For
            End If
         Next
      End If
      ' se non esiste nessun accoppiamento allora esco ed elimino la componente
      If FrameFile.Contains("None") Then
         CurrCompo.VisibilitiReloadBtn = Visibility.Collapsed
         Return False
      End If
      ' converto il numero di porte da string a int
      Int32.TryParse(Map.refAssemblyPageVM.CurrAssembly.DoorNumber, nDoorNbr)
      ' cerco il nome nella tabella: se lo script lua da errori, e la variabile FrameFile è vuota esco
      If String.IsNullOrEmpty(FrameFile) AndAlso
            Not CalcCompoMatching(CurrCompo.CompoType.Path, nDoorNbr, CurrCompo.TemplateSelItem, FrameFile) Then
         CurrCompo.VisibilitiReloadBtn = Visibility.Collapsed
         Return False
      End If
      CurrCompo.VisibilitiReloadBtn = Visibility.Visible
      Return True
   End Function

#End Region    ' Associazione delle compo lette da ddf

#End Region    ' Lettura Assemblato

#Region "RULES ASSEMBLY"

#Region "CreateRefCompo"

   ' questo metodo è chiamato dalla proprietà CompoBtn nella classe CompoPanelVM
   ' dopo aver aggiunto una componente da pulsantiera viene chiamato questo metodo che costruisce il riferimento
   ' o anche solo esegue la modifica dell'associzaione
   Public Function CreateCompoOnJamb(ByRef CurrCompo As Compo, ByVal sSide As String, Optional ByVal sTypeDoor As String = "") As Boolean
      Dim Local_CurrDoor As Part = Nothing
      ' eventualmente carico la porta indicata nella funzione
      If Not String.IsNullOrEmpty(sTypeDoor) Then
         Dim Local_CurrPartDoor As PartDoor = Map.refAssemblyPageVM.ReserchPartDoor(sTypeDoor)
         If Not IsNothing(Local_CurrPartDoor) Then
            Local_CurrDoor = Local_CurrPartDoor.Door
         Else
            Local_CurrDoor = Map.refPartPageVM.CurrPart
         End If
      Else
         Local_CurrDoor = Map.refPartPageVM.CurrPart
      End If

      ' se è la configurazione è di songola porta allora interrompi la costruzione
      If OptionModule.m_ConfigurationSoftware = ConfigType.Door Then Return False
      ' nome del file Matchting.ini
      Dim FrameFile As String = String.Empty
      ' percorso del file di Config.ini del file frame
      Dim FrameFileConfig As String = String.Empty
      ' numero di ante presenti nel progetto corrente
      Dim nDoorNbr As Integer = 1

      ' cerco nella configurazione della componente sulla porta il parametro Side
      Dim Side As String = String.Empty
      If Not String.IsNullOrEmpty(sSide) Then Side = sSide
      ' cerco nel file Config.ini il campo [PositionSide]
      If String.IsNullOrEmpty(Side) Then
         GetPrivateProfileJambSide(S_POSITIONSIDE, K_SIDE, Side, CurrCompo.CompoType.Path & "\" & CONFIGINI_FILE_NAME)
      End If
      ' controllo sempre nell'elenco dei parametri se esiste un parametro di tipo Side
      For IndexParam As Integer = 0 To CurrCompo.CompoParamList.Count - 1
         If CurrCompo.CompoParamList(IndexParam).DDFName.ToLower = K_SIDE.ToLower Then
            Side = DirectCast(CurrCompo.CompoParamList(IndexParam), ComboBoxParam).SelItem
            Dim IndexDDF As Integer = DirectCast(CurrCompo.CompoParamList(IndexParam), ComboBoxParam).ItemList.IndexOf(Side)
            If IndexDDF > -1 Then
               Side = DirectCast(CurrCompo.CompoParamList(IndexParam), ComboBoxParam).ItemListDDF(IndexDDF)
            End If
            Exit For
         End If
      Next
      ' converto tutti i nomi che ho caricato in carattere minuscolo
      If Not String.IsNullOrEmpty(Side) Then
         Side = Side.ToLower
         Dim ItemSplit As String() = Side.Split("_"c)
         If ItemSplit.Count > 1 Then
            Side = Trim(ItemSplit(0))
         End If
      End If
      ' a questo punto ricerco nella lista delle associazioni se esite il frame sul quale costruire il riferimento
      ' converto la posizione letta in valore numerico 
      ' queste associazioni funzionano sulle ante, per i Jamb non ho studiato una conversione
      If IsNothing(Local_CurrDoor) Then Return False
      Dim nSide As Integer = 0
      Select Case Side
         Case "lock"
            ' se è LeftHand
            If Local_CurrDoor.SwingAlias.Name.Contains("L") Then
               nSide = 100
            Else
               nSide = 300
            End If
         Case "hinge"
            If Local_CurrDoor.SwingAlias.Name.Contains("L") Then
               nSide = 300
            Else
               nSide = 100
            End If
         Case "top"
            nSide = 200
         Case "bottom"
            nSide = 400
      End Select

      ' ricerco il PartDoor associato al side
      Dim refPartDoor As PartDoor = Nothing
      If Local_CurrDoor.TypePart.Contains("DO_") Then
         For Each ItemPartDoor In ListPartDoor
            If ItemPartDoor.Type = Local_CurrDoor.TypePart Then
               For Each ItemAssociation In ItemPartDoor.ListAssociation
                  ' verifico che esiesta un Part sul lato indicato dal side
                  If ItemAssociation.Side > nSide AndAlso ItemAssociation.Side < nSide + 100 Then
                     refPartDoor = ItemAssociation.refPartDoor
                     Exit For
                  End If
               Next
               Exit For
            End If
         Next
      Else
         refPartDoor = Map.refAssemblyPageVM.ReserchPartDoor(Local_CurrDoor.TypePart)
      End If
      ' se non è stata trovata nessuna associazione esco
      If IsNothing(refPartDoor) Then
         CurrCompo.VisibilitiReloadBtn = Visibility.Collapsed
         Return False
      End If

      ' se l'associazione è un'anta allora verifico se la componente non sia un riferiememto
      If refPartDoor.Door.TypePart.Contains("DO_") AndAlso Not IsNothing(CurrCompo.refCompoDoor) Then
         Return False
      End If

      ' cerco il nome della componente da associare FrameFile
      Dim CurrDoorHArdwareFile As String = CurrCompo.CompoType.Path & "\" & CurrCompo.TemplateSelItem
      If Path.GetExtension(CurrDoorHArdwareFile) <> NGE_EXTENSION Then
         CurrDoorHArdwareFile &= LUA_EXTENSION
      End If
      ' cerco il campo [Match file] nel file lua della componente
      Dim sKey As String = K_MATCHING_FILE
      ' se il riferiemento è un'anta allora devo caricare il file "MatchingFileDoor"
      If refPartDoor.Door.TypePart.Contains("DO_") Then
         sKey = K_MATCHING_FILE_DOOR
      End If
      If File.Exists(CurrDoorHArdwareFile) Then
         Dim ReadCurrCompo() As String = File.ReadAllLines(CurrDoorHArdwareFile)
         For LineIndex = 0 To ReadCurrCompo.Count - 1
            If RegexFunction.IsMatchingParameterTitle(ReadCurrCompo(LineIndex)) Then
               ' mi preparo per leggere la prima riga dopo il titolo
               Dim ParamIndex As Integer = 1
               FrameFile = Trim(RegexFunction.ParamLine(ReadCurrCompo(LineIndex + ParamIndex), sKey))
               While String.IsNullOrEmpty(FrameFile) And LineIndex + ParamIndex < ReadCurrCompo(LineIndex + ParamIndex).Count
                  ParamIndex += 1
                  FrameFile = Trim(RegexFunction.ParamLine(ReadCurrCompo(LineIndex + ParamIndex), sKey))
               End While
               Exit For
            End If
         Next
      End If
      ' se non esiste nessun accoppiamento allora esco ed elimino la componente
      If FrameFile.Contains("None") Then
         If Not IsNothing(CurrCompo.refJambCompo) Then
            Local_CurrDoor.RemoveCompo(CurrCompo, True)
            CurrCompo.refJambCompo = Nothing
         End If
         ' 50144 =Warning, 50166 =Jamb compo does not exist 
         'MessageBox.Show(EgtMsg(50166), EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
         CurrCompo.VisibilitiReloadBtn = Visibility.Collapsed
         Return False
      End If
      ' converto il numero di porte da string a int
      Int32.TryParse(Map.refAssemblyPageVM.CurrAssembly.DoorNumber, nDoorNbr)
      ' cerco il nome nella tabella: se lo script lua da errori, e la variabile FrameFile è vuota esco
      If String.IsNullOrEmpty(FrameFile) AndAlso
         Not CalcCompoMatching(CurrCompo.CompoType.Path, nDoorNbr, CurrCompo.TemplateSelItem, FrameFile) Then
         ' elimino la componente di riferimento
         If Not IsNothing(CurrCompo.refJambCompo) Then
            Local_CurrDoor.RemoveCompo(CurrCompo, True)
            CurrCompo.refJambCompo = Nothing
         End If
         CurrCompo.VisibilitiReloadBtn = Visibility.Collapsed
         Return False
      End If

      ' costruisco il percosrso del file Config.ini associato al FrameFile
      If Not SearchFileConfig(FrameFile, FrameFileConfig) Then
         ' 50144 =Warning, 50166 =Jamb compo does not exist 
         ' MessageBox.Show(EgtMsg(50166), EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
         ' se il file FrameFileConfig.ini non esiste allora elimino il  riferimento
         If Not IsNothing(CurrCompo.refJambCompo) Then
            Local_CurrDoor.RemoveCompo(CurrCompo, True)
            CurrCompo.refJambCompo = Nothing
         End If
         ' restituisco false perchè la componente non è stata creata
         CurrCompo.VisibilitiReloadBtn = Visibility.Collapsed
         Return False
      Else
         ' inizio la lettura di FrameFileConfig
         Dim FrameNameDDF As String = String.Empty
         Dim FrameName As String = String.Empty
         Dim FrameSide As String = String.Empty
         Dim FrameFolderName As String = String.Empty
         GetPrivateProfileCompoName(ConstCompo.S_COMPO, ConstCompo.K_NAME, FrameNameDDF, FrameName, FrameFileConfig)
         GetPrivateProfileJambSide(S_POSITIONSIDE, K_SIDE, FrameSide, FrameFileConfig)
         GetPrivateProfileFolderName(S_TEMPLATE, K_FOLDER_NAME, FrameFolderName, FrameFileConfig)

         'Ogni volta che creo una componente elimino i precedenti riferimenti
         If Not IsNothing(CurrCompo.refJambCompo) Then Local_CurrDoor.RemoveCompo(CurrCompo, True)
         If IsNothing(CurrCompo.refJambCompo) Then
            ' costruisco sul riferiento la nuova componente inserita
            Dim refCompoType As New CompoType(FrameName, FrameNameDDF, Path.GetDirectoryName(FrameFileConfig), FrameSide, FrameFolderName)
            ' aggiungo la componete sul riferiento passato (caricando la lista dei file di tipo Frame)
            Dim refPartDoor_IsFrame As Boolean = True
            If refPartDoor.Door.TypePart.Contains("DO_") Then refPartDoor_IsFrame = False
            CurrCompo.refJambCompo = refPartDoor.Door.AddNewCompo(refCompoType, refPartDoor_IsFrame)
            CurrCompo.refJambCompo.refCompoDoor = CurrCompo
            ' se non è un frame allora sto costruendo su una anta
            CurrCompo.refJambCompo.MatchedDoor = Not refPartDoor_IsFrame
            ' definsco se la componente deve essre ribalata (Top-Door2; Bottom-Door1 e una sola anta)
            If Side = "top" And Local_CurrDoor.TypePart.Contains("DO_2") Then
               CurrCompo.refJambCompo.OtherDoor = True
            ElseIf Side = "bottom" And Local_CurrDoor.TypePart.Contains("DO_1") And m_DoorNumber <> "1" Then
               CurrCompo.refJambCompo.OtherDoor = True
            End If
         End If
         ' setto il nome della componente da caricare
         If Not IsNothing(CurrCompo.refJambCompo) Then
            CurrCompo.refJambCompo.SplitBrandFile(FrameFile)
            CurrCompo.refJambCompo.refCompoDoor = CurrCompo
         Else
            MessageBox.Show("File '" & FrameFile & "' exist, but it is not in the correct Directory!", EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
            CurrCompo.VisibilitiReloadBtn = Visibility.Collapsed
            Return False
         End If
      End If

      ' assegno i parametri letti dallo script per il corretto posizionamento del pezzo ( solo se il pezzo corrente è un DO_)
      If LoadCompoParam(CurrCompo, Local_CurrDoor.TypePart) Then
         UpDateCurrCompoJamb(CurrCompo, Local_CurrDoor.TypePart)
         ResetSTU()
         ResetCompoParam()
      Else
         Dim Msg As String = String.Format(EgtMsg(50157), CurrCompo.CompoType.Path, MATCHING_FILE_NAME)
         MessageBox.Show(Msg, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
      End If
      ' se sono arrivato in fondo significa che il riferiemnto è stato costruito
      CurrCompo.VisibilitiReloadBtn = Visibility.Visible
      CurrCompo.refJambCompo.VisibilitiReloadBtn = Visibility.Visible
      Return True
   End Function

   ' questa funzione è utilizzata per ricostruire (da Matching.lua) una componente del telaio a partire da essa stessa
   Public Function CreateCompoOnJambFromJamb(ByRef CurrCompo As Compo, ByVal sSide As String) As Boolean
      Dim IndexRefCompo As Integer = -1
      ' se è la configurazione è di songola porta allora interrompi la costruzione
      If OptionModule.m_ConfigurationSoftware = ConfigType.Door Then Return False
      ' nome del file Matchting.ini
      Dim FrameFile As String = String.Empty
      ' percorso del file di Config.ini del file frame
      Dim FrameFileConfig As String = String.Empty
      ' numero di ante presenti nel progetto corrente
      Dim nDoorNbr As Integer = 1

      ' ricerco il PartDoor associato al side (anche da anta ad anta)
      Dim refPartDoor As PartDoor = Map.refAssemblyPageVM.ReserchPartDoor(Map.refPartPageVM.CurrPart.TypePart)
      'If Map.refPartPageVM.CurrPart.TypePart.Contains("DO_") Then
      '   Return False
      'Else
      '   refPartDoor = Map.refAssemblyPageVM.ReserchPartDoor(Map.refPartPageVM.CurrPart.TypePart)
      'End If

      ' se non è stata trovata nessuna associazione esco
      If IsNothing(refPartDoor) Then
         CurrCompo.VisibilitiReloadBtn = Visibility.Collapsed
         Return False
      End If

      ' ricerco l'indice della componente che sto modificando
      For Index As Integer = 0 To refPartDoor.Door.CompoList.Count - 1
         If Trim(refPartDoor.Door.CompoList(Index).IdCode) = Trim(CurrCompo.IdCode) Then
            IndexRefCompo = Index
         End If
      Next

      ' ricerco l'anta a cui devo fare riferimento (dalle informazioni della Compo e del tipo di Frame)
      Dim LocalDoor As Part = Map.refAssemblyPageVM.ReserchPartDoor("DO_1").Door
      If IsNothing(LocalDoor) Then
         Return False
      End If
      If m_DoorNumber <> "1" Then
         If refPartDoor.Door.TypePart.Contains("FT_") AndAlso CurrCompo.refJambCompo.OtherDoor Then
            LocalDoor = Map.refAssemblyPageVM.ReserchPartDoor("DO_2").Door
         ElseIf refPartDoor.Door.TypePart.Contains("FB_") AndAlso Not CurrCompo.refJambCompo.OtherDoor Then
            LocalDoor = Map.refAssemblyPageVM.ReserchPartDoor("DO_2").Door
         ElseIf refPartDoor.Door.TypePart.Contains("FR_") Then
            LocalDoor = Map.refAssemblyPageVM.ReserchPartDoor("DO_2").Door
         ElseIf refPartDoor.Door.TypePart.Contains("DO_1") Then
            LocalDoor = Map.refAssemblyPageVM.ReserchPartDoor("DO_2").Door
         End If
      End If

      ' costruisco il nome del FrameFile
      Dim DirectoryCompo As String = Path.GetFileName(CurrCompo.refJambCompo.CompoType.Path)
      FrameFile = DirectoryCompo & "\" & CurrCompo.refJambCompo.TemplateSelItem

      ' costruisco il percosrso del file Config.ini associato al FrameFile
      If Not SearchFileConfig(FrameFile, FrameFileConfig) Then
         ' 50144 =Warning, 50166 =Jamb compo does not exist 
         ' MessageBox.Show(EgtMsg(50166), EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
         ' se il file FrameFileConfig.ini non esiste allora elimino il  riferimento
         If Not IsNothing(CurrCompo.refJambCompo) Then
            LocalDoor.RemoveCompo(CurrCompo, True)
            CurrCompo.refJambCompo = Nothing
         End If
         ' restituisco false perchè la componente non è stata creata
         Return False
      Else
         ' inizio la lettura di FrameFileConfig
         Dim FrameNameDDF As String = String.Empty
         Dim FrameName As String = String.Empty
         Dim FrameSide As String = String.Empty
         Dim FrameFolderName As String = String.Empty
         GetPrivateProfileCompoName(ConstCompo.S_COMPO, ConstCompo.K_NAME, FrameNameDDF, FrameName, FrameFileConfig)
         GetPrivateProfileJambSide(S_POSITIONSIDE, K_SIDE, FrameSide, FrameFileConfig)
         GetPrivateProfileFolderName(S_TEMPLATE, K_FOLDER_NAME, FrameFolderName, FrameFileConfig)

         'Ogni volta che creo una componente elimino i precedenti riferimenti
         If Not IsNothing(CurrCompo.refJambCompo) Then LocalDoor.RemoveCompo(CurrCompo, True)
         If IsNothing(CurrCompo.refJambCompo) Then
            ' costruisco sul riferiento la nuova componente inserita
            Dim refCompoType As New CompoType(FrameName, FrameNameDDF, Path.GetDirectoryName(FrameFileConfig), FrameSide, FrameFolderName)
            ' aggiungo la componete sul riferiento passato (caricando la lista dei file di tipo Frame solo per il telaio)
            Dim refPartDoor_IsFrame As Boolean = True
            If refPartDoor.Door.TypePart.Contains("DO_") Then refPartDoor_IsFrame = False
            CurrCompo.refJambCompo = refPartDoor.Door.AddNewCompo(refCompoType, refPartDoor_IsFrame, IndexRefCompo)
            CurrCompo.refJambCompo.refCompoDoor = CurrCompo
            ' definsco se la componente deve essre ribalata (Top-Door2; Bottom-Door1 e una sola anta)
            If sSide = "top" And LocalDoor.TypePart.Contains("DO_2") Then
               CurrCompo.refJambCompo.OtherDoor = True
            ElseIf sSide = "bottom" And LocalDoor.TypePart.Contains("DO_1") And m_DoorNumber <> "1" Then
               CurrCompo.refJambCompo.OtherDoor = True
            End If
         End If
         ' setto il nome della componente da caricare
         If Not IsNothing(CurrCompo.refJambCompo) Then
            CurrCompo.refJambCompo.SplitBrandFile(FrameFile)
            CurrCompo.refJambCompo.refCompoDoor = CurrCompo
         Else
            ' 50549=File {0} exist, but it is not in the correct Directory!
            Dim sMessageError As String = String.Format(EgtMsg(50549), FrameFile)
            MessageBox.Show(sMessageError, EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
            CurrCompo.VisibilitiReloadBtn = Visibility.Collapsed
            Return False
         End If
      End If

      ' assegno i parametri letti dallo script per il corretto posizionamento del pezzo ( solo se il pezzo corrente è un DO_)
      If LoadCompoParam(CurrCompo, LocalDoor.TypePart) Then
         UpDateCurrCompoJamb(CurrCompo, LocalDoor.TypePart)
         ResetSTU()
         ResetCompoParam()
      Else
         Dim Msg As String = String.Format(EgtMsg(50157), CurrCompo.CompoType.Path, MATCHING_FILE_NAME)
         MessageBox.Show(Msg, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
      End If
      ' se sono arrivato in fondo significa che il riferiemnto è stato costruito
      CurrCompo.VisibilitiReloadBtn = Visibility.Visible
      CurrCompo.refJambCompo.VisibilitiReloadBtn = Visibility.Visible
      Return True
   End Function

#End Region     ' CreateRefCompo

   ' ha lo scopo di creare una copia dei riferimenti dei PartDoor 
   ' per permettere di scrivere in modo più semplice i metodi
   Private Sub SetPartDoorCurrAssembly()
      m_JambT = Nothing
      m_JambB = Nothing
      m_JambL = Nothing
      m_JambR = Nothing
      m_Door1 = Nothing
      m_Door2 = Nothing
      For IndexPartDoor As Integer = 0 To ListPartDoor.Count - 1
         If ListPartDoor(IndexPartDoor).Type.Contains("FT_") Then
            m_JambT = ListPartDoor(IndexPartDoor).Door
         ElseIf ListPartDoor(IndexPartDoor).Type.Contains("FB_") Then
            m_JambB = ListPartDoor(IndexPartDoor).Door
         ElseIf ListPartDoor(IndexPartDoor).Type.Contains("FL_") Then
            m_JambL = ListPartDoor(IndexPartDoor).Door
         ElseIf ListPartDoor(IndexPartDoor).Type.Contains("FR_") Then
            m_JambR = ListPartDoor(IndexPartDoor).Door
         ElseIf ListPartDoor(IndexPartDoor).Type.Contains("DO_1") Then
            m_Door1 = ListPartDoor(IndexPartDoor).Door
         ElseIf ListPartDoor(IndexPartDoor).Type.Contains("DO_2") Then
            m_Door2 = ListPartDoor(IndexPartDoor).Door
         End If
      Next
      NotifyPropertyChanged("JambExists")
   End Sub

   Public ReadOnly Property JambExists As Boolean
      Get
         If Not IsNothing(m_JambL) AndAlso Not IsNothing(m_JambR) AndAlso Not IsNothing(m_JambT) Then
            Return True
         End If
         Return False
      End Get
   End Property

   ' gestisce la chimata delle funzioni a seconda della modifica eseguita
#Region "DIMENSIONING"

   ' Durante la costruzione di un nuovo assemblato, oppure quando viene aggiunta/rimossa un'anta
   ' una volta creata la prima porta questa funzione calcola le dimensioni del telaio
   Public Sub SetNewDimensionAssembly(ByVal Optional IsNewAssembly As Boolean = False)
      ' permette di creare una copia degli oggetti di tipo PartDoor presenti nell'assemblato
      SetPartDoorCurrAssembly()
      ' se non esiste la prima porta allora non calcolo le dimensioni del telaio
      If IsNothing(m_Door1) Then Return
      ' i parametri che devono ancora essere definiti affinchè funzioni tutto sono
      ' Size, Swing, Rabbet
      If OptionModule.m_ConfigurationSoftware = ConfigType.Door Then Return
      SwingJamb()
      HeightJamb(IsNewAssembly)
      TopBottomWidth()
      HeightDoor(IsNewAssembly)
      TopRabbetJamb()
      HingeRabbetJamb()
      BottomRabbetJamb()
      MaterialJamb()
   End Sub

   ' riceve il nome del parametro modificato ed associa la funzione per il ridimensionamento
   Public Sub SetDimension(sParameter As String, Optional CurrCompo As Compo = Nothing)
      If OptionModule.m_ConfigurationSoftware = ConfigType.Door Then Return
      ' riceve il nome della modifica, e indirizza la funzione preposta alla modifica
      Select Case sParameter

         Case "CreateRefCompo"
            If BuiltReffCompo Then CreateCompoOnJamb(CurrCompo, "")

         Case "JambIsCheked"
            Map.refAssemblyManagerVM.CreateJamb(Me, False)
            Map.refAssemblyManagerVM.LoadOM_M_ET(Me)
            Map.refAssemblyManagerVM.CreateAssociation(Me)
            SetNewDimensionAssembly()
            ' UpDateAllCompo()
            Map.refSceneManagerVM.RefreshBtn()

         Case "Height"
            HeightJamb()
            HeightDoor()
            TopRabbetJamb()
            BottomRabbetJamb()
            HingeRabbetJamb()
            SetVarAssembly()
            UpDateAllCompo()

         Case "Width"
            TopBottomWidth()
            TopRabbetJamb()
            BottomRabbetJamb()
            HingeRabbetJamb()
            SetVarAssembly()
            UpDateAllCompo()

         Case "Thickness"
            TopRabbetJamb()
            UpDateAllCompo()

         Case "Swing"
            UpDateCompolistOnJamb()
            SwingJamb()
            SetPartDoorCurrAssembly()
            CreateAssembly(True)
            'UpDateAllCompo()

         Case "DoorNumber"
            ClearRefOnAssembly()
            SetPartDoorCurrAssembly()
            ReverseDoor()
            Map.refAssemblyManagerVM.CreateDoor(Me)
            Map.refAssemblyManagerVM.CreateAssociation(Me)
            SetPartDoorCurrAssembly()
            SetVarAssembly()
            ReloadAllCompoDoor1()
            ReverseDoor()
            UpDateAllCompo()
            TopBottomWidth()
            SwingJamb()
            HeightDoor()
            TopRabbetJamb()
      End Select
   End Sub

#End Region    ' Dimensioning

#Region "UpDateRefCompo"

   ' ricostruisce tutte le componenti del telaio
   Public Sub CreateAssembly(Optional bAllDoors As Boolean = False)
      If ListPartDoorOfDoor.Count < 1 Then Return
      'If Not JambExists Then SetDimension("JambIsCheked")
      Dim nIndexDoor As Integer = 0
      If Not IsNothing(Map.refPartPageVM.CurrPart) AndAlso Map.refMainWindowVM.SelectedPage = MainWindowVM.ListPageEnum.nDDFPage AndAlso Not bAllDoors Then
         If Map.refPartPageVM.CurrPart.TypePart.Contains("DO_") Then
            If IsThereModifyCompoParamRef(Map.refPartPageVM.CurrPart.CompoList) Then
               ' 50550=Every componente on jambs will be relocated, do you want to continue , 50144=Warning
               If MessageBox.Show(EgtMsg(50550), EgtMsg(50144), MessageBoxButton.YesNo, MessageBoxImage.Asterisk) = MessageBoxResult.No Then
                  Return
               End If
            End If
            For IndexCompo = 0 To Map.refPartPageVM.CurrPart.CompoList.Count - 1
               CreateCompoOnJamb(Map.refPartPageVM.CurrPart.CompoList(IndexCompo), "")
            Next
         End If
      ElseIf Not IsNothing(Map.refPartPageVM.CurrPart) AndAlso Map.refMainWindowVM.SelectedPage = MainWindowVM.ListPageEnum.nDDFPage AndAlso bAllDoors Then
         ' verifico per entrmabe le ante se posso procedere
         For Each ItemPart In ListPartDoorOfDoor
            For IndexCompo = 0 To ItemPart.Door.CompoList.Count - 1
               If IsThereModifyCompoParamRef(ItemPart.Door.CompoList) Then
                  If MessageBox.Show(EgtMsg(50550), EgtMsg(50144), MessageBoxButton.YesNo, MessageBoxImage.Asterisk) = MessageBoxResult.No Then
                     Return
                  Else
                     Exit For
                  End If
               End If
            Next
         Next
         For Each ItemPart In ListPartDoorOfDoor
            For IndexCompo = 0 To ItemPart.Door.CompoList.Count - 1
               CreateCompoOnJamb(ItemPart.Door.CompoList(IndexCompo), "", ItemPart.Door.TypePart)
               ' potrebbe capitare che vengano eliminate delle componenti, quindi è meglio controllare
               If IndexCompo = ItemPart.Door.CompoList.Count - 1 Then Exit For
            Next
         Next
      End If
      Map.refSceneManagerVM.RefreshBtn()
   End Sub

   ' appena verifico che esiste anche solo una componente modificata esco
   Private Function IsThereModifyCompoParamRef(ByVal CompoList As ObservableCollection(Of Compo)) As Boolean
      For Each ItemCompo In CompoList
         If Not IsNothing(ItemCompo.refJambCompo) Then
            For Each ItemParam In ItemCompo.refJambCompo.CompoParamList
               If ItemParam.IsModifingRefCompoParam Then Return True
            Next
         End If
      Next
      Return False
   End Function

   ' è chiamata ogni volta che viene modificato un parametro del general dell'assemblato
   Public Sub UpDateAllCompo()
      Dim IdexDoorNumber As Integer = 0
      IdexDoorNumber = CInt(m_DoorNumber)
      If ListPartDoorOfDoor.Count < 1 Then Return
      For IndexDoor As Integer = 0 To IdexDoorNumber - 1
         For IndexCompo As Integer = 0 To ListPartDoorOfDoor(IndexDoor).Door.CompoList.Count - 1
            ' per ogni componente di ogni porta, se esiste una componente di riferimento
            Dim CurrCompo As Compo = ListPartDoorOfDoor(IndexDoor).Door.CompoList(IndexCompo)
            If Not IsNothing(CurrCompo.refJambCompo) Then
               ' ricerco il file lua che gestisce le associazioni delle componenti
               If LoadCompoParam(CurrCompo, ListPartDoorOfDoor(IndexDoor).Door.TypePart) Then
                  UpDateCurrCompoJamb(CurrCompo, ListPartDoorOfDoor(IndexDoor).Door.TypePart)
                  ResetCompoParam()
               Else
                  Dim Msg As String = String.Format(EgtMsg(50157), CurrCompo.CompoType.Path, MATCHING_FILE_NAME)
                  MessageBox.Show(Msg, EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
               End If
            End If
         Next
      Next
   End Sub

   ' quando carico un assemblato devo ricalcolare tutti i parametri OrigValue
   Public Sub UpDateAllOrigValue()
      Dim IdexDoorNumber As Integer = 0
      IdexDoorNumber = CInt(m_DoorNumber)
      If ListPartDoorOfDoor.Count < 1 Then Return
      For IndexDoor As Integer = 0 To IdexDoorNumber - 1
         For IndexCompo As Integer = 0 To ListPartDoorOfDoor(IndexDoor).Door.CompoList.Count - 1
            ' per ogni componente di ogni porta, se esiste una componente di riferimento
            Dim CurrCompo As Compo = ListPartDoorOfDoor(IndexDoor).Door.CompoList(IndexCompo)
            If Not IsNothing(CurrCompo.refJambCompo) Then
               ' ricerco il file lua che gestisce le associazioni delle componenti
               If LoadCompoParam(CurrCompo, ListPartDoorOfDoor(IndexDoor).Door.TypePart) Then
                  UpdateOrigValue(CurrCompo, ListPartDoorOfDoor(IndexDoor).Door.TypePart)
                  ResetCompoParam()
               End If
            End If
         Next
      Next
   End Sub

   ' Ricevuta la componente Compo aggiorna la refCompo - Usata fino alla versione 2.2e1 del 7/5/2020
   Public Sub UpDateCurrCompoJamb_OldVersion(ByRef CurrCompo As Compo, ByRef sCurrTypeDoor As String)
      CurrCompo.refJambCompo.IsReadOnly = False
      ' devo distinguere il caso della componente sulla porta o sul jamb
      ' se il numero di elementi presenti nella lista riferita al jamb sono diversi da quelli riferiti all'anta
      If CurrCompo.refJambCompo.CompoParamList.Count <> CurrCompo.CompoParamList.Count Then Return

      ' se il primo controllo è andato a buon fine passo al caricamento dei dati
      For IndexParam As Integer = 0 To CurrCompo.refJambCompo.CompoParamList.Count - 1
         If TypeOf CurrCompo.refJambCompo.CompoParamList(IndexParam) Is TextBoxOnOffParam AndAlso
            CurrCompo.CompoParamList(IndexParam).DDFName = CurrCompo.refJambCompo.CompoParamList(IndexParam).DDFName Then
            ' ho controllato che i nome ddf del parametro sul jamb è lo stesso che sta sull'anta
            Dim TBoxPar As TextBoxOnOffParam = DirectCast(CurrCompo.CompoParamList(IndexParam), TextBoxOnOffParam)
            Dim TBoxRefPar As TextBoxOnOffParam = DirectCast(CurrCompo.refJambCompo.CompoParamList(IndexParam), TextBoxOnOffParam)
            ' assegno i valori della componente dell'anta, e ricevo i valori da asseganre alla compente sul jamb
            CalcCompoParamValue(TBoxPar.DDFName, TBoxPar.m_Value, TBoxRefPar.m_Value, TBoxRefPar.IsReadOnly, sCurrTypeDoor, CurrCompo.refJambCompo.ConfigurationParameters)
            TBoxRefPar.SetIsActive(TBoxPar.IsActive)
         ElseIf TypeOf CurrCompo.refJambCompo.CompoParamList(IndexParam) Is ComboBoxOnOffParam AndAlso
            CurrCompo.CompoParamList(IndexParam).DDFName = CurrCompo.refJambCompo.CompoParamList(IndexParam).DDFName Then
            ' ho controllato che i nome ddf del parametro sul jamb è lo stesso che sta sull'anta
            ' l'unica operazione che eseguo è di abilitare la combobox
            Dim CBoxRefPar As ComboBoxOnOffParam = DirectCast(CurrCompo.refJambCompo.CompoParamList(IndexParam), ComboBoxOnOffParam)
            CBoxRefPar.IsReadOnly = False
            Dim CBoxPar As ComboBoxOnOffParam = DirectCast(CurrCompo.CompoParamList(IndexParam), ComboBoxOnOffParam)
            For Each ItemCombo In CBoxRefPar.ItemList
               If ItemCombo = CBoxPar.SelItem Then
                  CBoxRefPar.SetSelItem(ItemCombo)
                  Exit For
               End If
            Next
            CBoxRefPar.SetIsActive(CBoxPar.IsActive)
         ElseIf TypeOf CurrCompo.refJambCompo.CompoParamList(IndexParam) Is TextBoxParam AndAlso
            CurrCompo.CompoParamList(IndexParam).DDFName = CurrCompo.refJambCompo.CompoParamList(IndexParam).DDFName Then
            ' ho controllato che i nome ddf del parametro sul jamb è lo stesso che sta sull'anta
            Dim TBoxPar As TextBoxParam = DirectCast(CurrCompo.CompoParamList(IndexParam), TextBoxParam)
            Dim TBoxRefPar As TextBoxParam = DirectCast(CurrCompo.refJambCompo.CompoParamList(IndexParam), TextBoxParam)
            ' assegno i valori della componente dell'anta, e ricevo i valori da asseganre alla compente sul jamb
            CalcCompoParamValue(TBoxPar.DDFName, TBoxPar.m_Value, TBoxRefPar.m_Value, TBoxRefPar.IsReadOnly, sCurrTypeDoor, CurrCompo.refJambCompo.ConfigurationParameters)
         ElseIf TypeOf CurrCompo.refJambCompo.CompoParamList(IndexParam) Is ComboBoxParam AndAlso
            CurrCompo.CompoParamList(IndexParam).DDFName = CurrCompo.refJambCompo.CompoParamList(IndexParam).DDFName Then
            ' ho controllato che i nome ddf del parametro sul jamb è lo stesso che sta sull'anta
            ' l'unica operazione che eseguo è di abilitare la combobox
            Dim CBoxRefPar As ComboBoxParam = DirectCast(CurrCompo.refJambCompo.CompoParamList(IndexParam), ComboBoxParam)
            CBoxRefPar.IsReadOnly = False
            Dim CBoxPar As ComboBoxParam = DirectCast(CurrCompo.CompoParamList(IndexParam), ComboBoxParam)
            For Each ItemCombo In CBoxRefPar.ItemList
               If ItemCombo = CBoxPar.SelItem Then
                  CBoxRefPar.SetSelItem(ItemCombo)
                  Exit For
               End If
            Next
         End If
      Next
   End Sub

   ' Ricevuta la componente Compo aggiorna la refCompo - In uso dalla versione 2.2e1 del 8/5/2020
   Public Sub UpDateCurrCompoJamb(ByRef CurrCompo As Compo, ByRef sCurrTypeDoor As String, Optional bOverWrite As Boolean = True)
      CurrCompo.refJambCompo.IsReadOnly = False
      ' ad ogni parametro (sul compo frame) associo il parametro con lo stesso nome (sul compo door)
      For Each ItemCompoRef In CurrCompo.refJambCompo.CompoParamList
         ' cerco il parametro con lo stesso nome nella componente della porta
         For Each ItemCompo In CurrCompo.CompoParamList
            ' se trovo lo stesso nome 
            If ItemCompoRef.DDFName = ItemCompo.DDFName Then
               ' verifico che siano anche dello stesso tipo
               If TypeOf ItemCompoRef Is TextBoxOnOffParam AndAlso TypeOf ItemCompo Is TextBoxOnOffParam Then
                  Dim TBoxPar As TextBoxOnOffParam = DirectCast(ItemCompo, TextBoxOnOffParam)
                  Dim TBoxRefPar As TextBoxOnOffParam = DirectCast(ItemCompoRef, TextBoxOnOffParam)
                  ' non ricalcolo il parametro
                  If TBoxRefPar.IsModifingRefCompoParam AndAlso Not bOverWrite Then
                     CalcCompoParamValue(TBoxPar.DDFName, TBoxPar.m_Value, TBoxRefPar.OrigValue, TBoxRefPar.IsReadOnly, sCurrTypeDoor, CurrCompo.ConfigurationParameters, CurrCompo.refJambCompo.ConfigurationParameters)
                     Continue For
                  End If
                  ' assegno i valori della componente dell'anta, e ricevo i valori da asseganre alla compente sul jamb
                  CalcCompoParamValue(TBoxPar.DDFName, TBoxPar.m_Value, TBoxRefPar.m_Value, TBoxRefPar.IsReadOnly, sCurrTypeDoor, CurrCompo.ConfigurationParameters, CurrCompo.refJambCompo.ConfigurationParameters)
                  TBoxRefPar.OrigValue = TBoxRefPar.m_Value
                  TBoxRefPar.SetIsActive(TBoxPar.IsActive)
               ElseIf TypeOf ItemCompoRef Is ComboBoxOnOffParam AndAlso TypeOf ItemCompo Is ComboBoxOnOffParam Then
                  ' ho controllato che i nome ddf del parametro sul jamb è lo stesso che sta sull'anta
                  ' l'unica operazione che eseguo è di abilitare la combobox
                  Dim CBoxRefPar As ComboBoxOnOffParam = DirectCast(ItemCompoRef, ComboBoxOnOffParam)
                  CBoxRefPar.IsReadOnly = False
                  Dim CBoxPar As ComboBoxOnOffParam = DirectCast(ItemCompo, ComboBoxOnOffParam)
                  For Each ItemCombo In CBoxRefPar.ItemList
                     If ItemCombo = CBoxPar.SelItem Then
                        CBoxRefPar.SetSelItem(ItemCombo)
                        CBoxRefPar.OrigItem = CBoxPar.SelItem
                        Exit For
                     End If
                  Next
                  CBoxRefPar.SetIsActive(CBoxPar.IsActive)
               ElseIf TypeOf ItemCompoRef Is TextBoxParam AndAlso TypeOf ItemCompo Is TextBoxParam Then
                  ' ho controllato che i nome ddf del parametro sul jamb è lo stesso che sta sull'anta
                  Dim TBoxRefPar As TextBoxParam = DirectCast(ItemCompoRef, TextBoxParam)
                  Dim TBoxPar As TextBoxParam = DirectCast(ItemCompo, TextBoxParam)
                  If TBoxRefPar.IsModifingRefCompoParam AndAlso Not bOverWrite Then
                     CalcCompoParamValue(TBoxPar.DDFName, TBoxPar.m_Value, TBoxRefPar.OrigValue, TBoxRefPar.IsReadOnly, sCurrTypeDoor, CurrCompo.ConfigurationParameters, CurrCompo.refJambCompo.ConfigurationParameters)
                     Continue For
                  End If
                  ' assegno i valori della componente dell'anta, e ricevo i valori da asseganre alla compente sul jamb
                  CalcCompoParamValue(TBoxPar.DDFName, TBoxPar.m_Value, TBoxRefPar.m_Value, TBoxRefPar.IsReadOnly, sCurrTypeDoor, CurrCompo.ConfigurationParameters, CurrCompo.refJambCompo.ConfigurationParameters)
                  TBoxRefPar.OrigValue = TBoxRefPar.m_Value
               ElseIf TypeOf ItemCompoRef Is ComboBoxParam AndAlso TypeOf ItemCompo Is ComboBoxParam Then
                  ' ho controllato che i nome ddf del parametro sul jamb è lo stesso che sta sull'anta
                  ' l'unica operazione che eseguo è di abilitare la combobox
                  Dim CBoxRefPar As ComboBoxParam = DirectCast(ItemCompoRef, ComboBoxParam)
                  CBoxRefPar.IsReadOnly = False
                  Dim CBoxPar As ComboBoxParam = DirectCast(ItemCompo, ComboBoxParam)
                  For Each ItemCombo In CBoxRefPar.ItemList
                     If ItemCombo = CBoxPar.SelItem Then
                        CBoxRefPar.SetSelItem(ItemCombo)
                        CBoxRefPar.OrigItem = CBoxPar.SelItem
                        Exit For
                     End If
                  Next
               End If
               ' passo al parametro successivo della lista del CompoRef
               Exit For
            End If
         Next
      Next
   End Sub

   ' carico i valori OrigValue in fase di lettura di un assemblato nuovo
   Public Sub UpdateOrigValue(ByRef CurrCompo As Compo, ByRef sCurrTypeDoor As String)
      CurrCompo.refJambCompo.IsReadOnly = False
      ' ad ogni parametro (sul compo frame) associo il parametro con lo stesso nome (sul compo door)
      For Each ItemCompoRef In CurrCompo.refJambCompo.CompoParamList
         ' cerco il parametro con lo stesso nome nella componente della porta
         For Each ItemCompo In CurrCompo.CompoParamList
            ' se trovo lo stesso nome 
            If ItemCompoRef.DDFName = ItemCompo.DDFName Then
               ' verifico che siano anche dello stesso tipo
               If TypeOf ItemCompoRef Is TextBoxOnOffParam AndAlso TypeOf ItemCompo Is TextBoxOnOffParam Then
                  Dim TBoxPar As TextBoxOnOffParam = DirectCast(ItemCompo, TextBoxOnOffParam)
                  Dim TBoxRefPar As TextBoxOnOffParam = DirectCast(ItemCompoRef, TextBoxOnOffParam)
                  ' assegno i valori della componente dell'anta, e ricevo i valori da asseganre alla compente sul jamb
                  CalcCompoParamValue(TBoxPar.DDFName, TBoxPar.m_Value, TBoxRefPar.OrigValue, TBoxRefPar.IsReadOnly, sCurrTypeDoor, CurrCompo.ConfigurationParameters, CurrCompo.refJambCompo.ConfigurationParameters)
                  ' confronto il valore calcolato con il parametro caricato da DDF
                  If Trim(TBoxRefPar.m_Value) <> Trim(TBoxRefPar.OrigValue) Then
                     Dim dValue As Double
                     Dim dOrigValue As Double
                     If Not IsNothing(TBoxRefPar.m_Value) AndAlso Not IsNothing(TBoxRefPar.OrigValue) Then
                        StringToDouble(TBoxRefPar.m_Value, dValue)
                        StringToDouble(TBoxRefPar.OrigValue, dOrigValue)
                        If dValue <> dOrigValue Then
                           TBoxRefPar.IsModifingRefCompoParam = True
                        Else
                           TBoxRefPar.IsModifingRefCompoParam = False
                        End If
                     End If
                     'TBoxRefPar.IsModifingRefCompoParam = True
                  End If
               ElseIf TypeOf ItemCompoRef Is TextBoxParam AndAlso TypeOf ItemCompo Is TextBoxParam Then
                  ' ho controllato che i nome ddf del parametro sul jamb è lo stesso che sta sull'anta
                  Dim TBoxRefPar As TextBoxParam = DirectCast(ItemCompoRef, TextBoxParam)
                  Dim TBoxPar As TextBoxParam = DirectCast(ItemCompo, TextBoxParam)
                  ' assegno i valori della componente dell'anta, e ricevo i valori da asseganre alla compente sul jamb
                  CalcCompoParamValue(TBoxPar.DDFName, TBoxPar.m_Value, TBoxRefPar.OrigValue, TBoxRefPar.IsReadOnly, sCurrTypeDoor, CurrCompo.ConfigurationParameters, CurrCompo.refJambCompo.ConfigurationParameters)
                  ' confronto il valore calcolato con il parametro caricato da DDF
                  If Trim(TBoxRefPar.m_Value) <> Trim(TBoxRefPar.OrigValue) Then
                     Dim dValue As Double
                     Dim dOrigValue As Double
                     If Not IsNothing(TBoxRefPar.m_Value) AndAlso Not IsNothing(TBoxRefPar.OrigValue) Then
                        StringToDouble(TBoxRefPar.m_Value, dValue)
                        StringToDouble(TBoxRefPar.OrigValue, dOrigValue)
                        If dValue <> dOrigValue Then
                           TBoxRefPar.IsModifingRefCompoParam = True
                        Else
                           TBoxRefPar.IsModifingRefCompoParam = False
                        End If
                     End If
                     'TBoxRefPar.IsModifingRefCompoParam = True
                  End If
               End If
               ' passo al parametro successivo della lista del CompoRef
               Exit For
            End If
         Next
      Next
   End Sub

   ' copia i parametri di una componente (PrecCompo) su un'altra componente (NewCompo, solo se hanno lo stesso nome)
   Public Sub CopyParam(ByRef PrecCompo As Compo, ByRef NewCompo As Compo)
      If PrecCompo.TemplateSelItem <> NewCompo.TemplateSelItem Then Return
      For IndexParam As Integer = 0 To PrecCompo.CompoParamList.Count - 1
         If TypeOf PrecCompo.CompoParamList(IndexParam) Is TextBoxOnOffParam AndAlso
            PrecCompo.CompoParamList(IndexParam).DDFName = NewCompo.CompoParamList(IndexParam).DDFName Then
            Dim TBoxPar As TextBoxOnOffParam = DirectCast(PrecCompo.CompoParamList(IndexParam), TextBoxOnOffParam)
            Dim TBoxNewPar As TextBoxOnOffParam = DirectCast(NewCompo.CompoParamList(IndexParam), TextBoxOnOffParam)
            If TBoxPar.EnableCopy Then
               TBoxNewPar.SetValue(TBoxPar.Value)
               TBoxNewPar.SetIsActive(TBoxPar.IsActive)
            End If
         ElseIf TypeOf PrecCompo.CompoParamList(IndexParam) Is TextBoxParam AndAlso
            PrecCompo.CompoParamList(IndexParam).DDFName = NewCompo.CompoParamList(IndexParam).DDFName Then
            Dim TBoxPar As TextBoxParam = DirectCast(PrecCompo.CompoParamList(IndexParam), TextBoxParam)
            Dim TBoxNewPar As TextBoxParam = DirectCast(NewCompo.CompoParamList(IndexParam), TextBoxParam)
            If TBoxPar.EnableCopy Then
               TBoxNewPar.SetValue(TBoxPar.Value)
            End If
         ElseIf TypeOf PrecCompo.CompoParamList(IndexParam) Is ComboBoxOnOffParam AndAlso
            PrecCompo.CompoParamList(IndexParam).DDFName = NewCompo.CompoParamList(IndexParam).DDFName Then
            Dim CBoxPar As ComboBoxOnOffParam = DirectCast(PrecCompo.CompoParamList(IndexParam), ComboBoxOnOffParam)
            Dim CBoxNewPar As ComboBoxOnOffParam = DirectCast(NewCompo.CompoParamList(IndexParam), ComboBoxOnOffParam)
            If CBoxNewPar.EnableCopy Then
               CBoxNewPar.SetSelItem(CBoxNewPar.ItemList(CBoxPar.ItemList.IndexOf(CBoxPar.SelItem)))
               CBoxNewPar.SetIsActive(CBoxPar.IsActive)
            End If
         ElseIf TypeOf PrecCompo.CompoParamList(IndexParam) Is ComboBoxParam AndAlso
            PrecCompo.CompoParamList(IndexParam).DDFName = NewCompo.CompoParamList(IndexParam).DDFName Then
            Dim CBoxPar As ComboBoxParam = DirectCast(PrecCompo.CompoParamList(IndexParam), ComboBoxParam)
            Dim CBoxNewPar As ComboBoxParam = DirectCast(NewCompo.CompoParamList(IndexParam), ComboBoxParam)
            If CBoxNewPar.EnableCopy Then
               CBoxNewPar.SetSelItem(CBoxNewPar.ItemList(CBoxNewPar.ItemList.IndexOf(CBoxPar.SelItem)))
            End If
         End If
      Next
   End Sub



#End Region    ' UpDateRefCompo

#Region "HEIGHT"

   ' calcola l'altezza dei JambLeft e JambRight 
   Public Sub HeightJamb(ByVal Optional IsNewAssembly As Boolean = False)
      ' se ho impostanto l'area di lavoro non modifico l'altezza dei jamb
      If Dimension Then
         If Not IsNothing(m_JambL) Then m_JambL.SetHeight(m_AssemblyHeight)
         If Not IsNothing(m_JambR) Then m_JambR.SetHeight(m_AssemblyHeight)
         Return
      End If

      ' vericfico che almeno uno su due esista
      If (IsNothing(m_JambL) OrElse IsNothing(m_JambR)) AndAlso IsNothing(m_Door1) Then Return
      ' se almeno un jamb esiste continuo
      Dim dLightUp As Double
      Dim dLightBottom As Double
      Dim dThicknessHead As Double
      Dim dHeight As Double
      Dim dOverlapTop As Double
      Dim dThicknessJamb As Double
      Dim dThicknessBottm As Double
      Dim dOverlapBottom As Double
      StringToDouble(LightUp, dLightUp)
      StringToDouble(LightBottom, dLightBottom)
      StringToDouble(ThicknessHead, dThicknessHead)
      StringToDouble(m_Door1.Height, dHeight)
      StringToDouble(ThicknessBottom, dThicknessBottm)
      StringToDouble(OverlapBottom, dOverlapBottom)

      'If IsNothing(Map.refPartPageVM.CurrPart) OrElse Not Map.refPartPageVM.CurrPart.TypePart.Contains("DO_") Then
      '   StringToDouble(m_Door1.Height, dHeight)
      'Else
      '   StringToDouble(Map.refPartPageVM.CurrPart.Height, dHeight)
      'End If

      If Not IsNothing(Map.refPartPageVM.CurrPart) AndAlso Map.refPartPageVM.CurrPart.TypePart.Contains("DO_") AndAlso
         Map.refMainWindowVM.SelectedPage = MainWindowVM.ListPageEnum.nDDFPage AndAlso
         Not IsNewAssembly Then
         StringToDouble(Map.refPartPageVM.CurrPart.Height, dHeight)
      Else
         StringToDouble(m_Door1.Height, dHeight)
      End If

      StringToDouble(OverlapTop, dOverlapTop)
      StringToDouble(Width, dThicknessJamb)
      Dim HJamb As Double = dLightBottom + dHeight + dLightUp + dThicknessHead - dOverlapTop
      Dim HJambExterior As Double = HJamb + dThicknessBottm - dOverlapBottom
      ' se è exterior
      If Map.refAssemblyPageVM.CurrAssembly.Exterior Then
         If Not IsNothing(m_JambL) Then m_JambL.SetHeight(DoubleToString(HJambExterior, 4))
         If Not IsNothing(m_JambR) Then m_JambR.SetHeight(DoubleToString(HJambExterior, 4))
      Else
         If Not IsNothing(m_JambL) Then m_JambL.SetHeight(DoubleToString(HJamb, 4))
         If Not IsNothing(m_JambR) Then m_JambR.SetHeight(DoubleToString(HJamb, 4))
      End If
      NotifyPropertyChanged("AssemblyHeight")

   End Sub

   ' Ricalcola la dimensione di tutte le porte ricevendo come valore esterno la dimensione della porta modificata
   Public Sub HeightDoor(ByVal Optional IsNewAssembly As Boolean = False)
      Dim HeightDoor As String = String.Empty
      Dim nTH As Double = 0
      Dim nTB As Double = 0
      Dim nLU As Double = 0
      Dim nLB As Double = 0
      Dim nOLT As Double = 0
      Dim nOLB As Double = 0
      StringToDouble(m_LightUp, nLU)
      StringToDouble(m_LightBottom, nLB)
      StringToDouble(m_ThicknessHead, nTH)
      StringToDouble(m_OverlapTop, nOLT)
      StringToDouble(m_ThicknessBottom, nTB)
      StringToDouble(m_OverlapBottom, nOLB)

      ' carico il valore che è stato modificato
      If Not IsNewAssembly AndAlso Not IsNothing(Map.refPartPageVM.CurrPart) AndAlso Map.refPartPageVM.CurrPart.TypePart.Contains("DO_") Then
         HeightDoor = Map.refPartPageVM.CurrPart.Height
      Else
         ' altrienti prendo quello della prima porta
         If Not IsNothing(m_Door1) Then
            HeightDoor = m_Door1.Height
         Else
            Return
         End If
      End If

      ' devo verificare che l'altezza che è stata imposta non sia maggiore di quella consentita
      If Dimension Then
         Dim nHeightDoor As Double
         ' se riesco ad eseguire la conversione numerica
         If StringToDouble(HeightDoor, nHeightDoor) Then
            Dim nTotalHeight As Double = 0
            StringToDouble(m_AssemblyHeight, nTotalHeight)
            ' dimensiono la porta sempre in funzione delle dimensioni dell'assemblato
            nHeightDoor = nTotalHeight - (nLU + nLB) - nTH
            If Exterior Then
               nHeightDoor = nHeightDoor + nOLT + nOLB - nTB
            End If
            m_Door1.SetHeight(DoubleToString(nHeightDoor, 4))
            HeightDoor = m_Door1.Height
         End If
      End If

      Dim nDN As Integer = 1
      Int32.TryParse(m_DoorNumber, nDN)
      If nDN < 2 Then Return
      For Each PDOfDoor In ListPartDoorOfDoor
         PDOfDoor.Door.SetHeight(HeightDoor)
      Next
   End Sub

   ' riassegna il TicnkessHead
   Public Sub HeightJambTop()
      Dim nTH As Double = 0
      Dim nTB As Double = 0
      Dim nLU As Double = 0
      Dim nLB As Double = 0
      Dim nOLT As Double = 0
      Dim nOLB As Double = 0
      Dim nHD As Double = 0
      StringToDouble(m_LightUp, nLU)
      StringToDouble(m_LightBottom, nLB)
      StringToDouble(m_ThicknessHead, nTH)
      StringToDouble(m_OverlapTop, nOLT)
      StringToDouble(m_OverlapBottom, nOLB)
      StringToDouble(m_ThicknessBottom, nTB)

      If Not IsNothing(m_JambT) Then
         m_JambT.SetHeight(ThicknessHead)
      End If

      If IsNothing(m_Door1) Then Return
      StringToDouble(m_Door1.Height, nHD)
      ' se non sono definite le quote esterne del telaio esco
      If Not Dimension Then Return
      Dim nTotalHeight As Double = 0
      StringToDouble(AssemblyHeight, nTotalHeight)

      If nTotalHeight < nTH Then
         ' se le quote sono totalmente sbagliate
         nTH = nTotalHeight - (nLU + nLB) - nHD
         If Exterior Then
            nTH = nTH + nOLT - nTB
         End If
         ThicknessHead = DoubleToString(nTH, 4)
      Else
         ' ridimensiono la porta
         nHD = nTotalHeight - (nLU + nLB) - (nTH - nOLT)
         If Exterior Then
            nHD = nHD + nOLT - nTB
         End If
         For Each ItemListPDOD In ListPartDoorOfDoor
            ItemListPDOD.Door.SetHeight(DoubleToString(nHD, 4))
         Next
      End If

   End Sub

   ' riassegna il TicnkessBottom
   Public Sub HeightJambBottom()
      Dim nTB As Double = 0
      Dim nTH As Double = 0
      Dim nLU As Double = 0
      Dim nLB As Double = 0
      Dim nOLB As Double = 0
      Dim nOLT As Double = 0
      Dim nHD As Double = 0
      StringToDouble(m_LightUp, nLU)
      StringToDouble(m_LightBottom, nLB)
      StringToDouble(m_ThicknessBottom, nTB)
      StringToDouble(m_OverlapBottom, nOLB)
      StringToDouble(m_OverlapTop, nOLT)
      StringToDouble(m_ThicknessHead, nTH)

      If Not IsNothing(m_JambB) Then
         m_JambB.SetHeight(ThicknessBottom)
      End If

      If IsNothing(m_Door1) Then Return
      StringToDouble(m_Door1.Height, nHD)
      ' se non sono definite le quote esterne del telaio esco
      If Not Dimension Then Return

      Dim nTotalHeight As Double = 0
      StringToDouble(AssemblyHeight, nTotalHeight)

      If nTotalHeight < nTB Then
         ' se lo spessore è esageratamente grande è un erore
         nTB = nTotalHeight - (nLU + nLB) - nHD - nTH + nOLT
         ThicknessBottom = DoubleToString(nTB, 4)
      Else
         nHD = nTotalHeight - (nLU + nLB) - (nTH - nOLT) - (nTB - nOLB)
         For Each ItemListPDOD In ListPartDoorOfDoor
            ItemListPDOD.Door.SetHeight(DoubleToString(nHD, 4))
         Next
      End If

   End Sub

#End Region    ' Height

#Region "WIDTH"

   ' calcola la larghezza dei jamb orizzonatli
   Private Sub TopBottomWidth()
      ' vericfico che almeno uno su tre esista
      If (IsNothing(m_JambT) OrElse IsNothing(m_JambB)) AndAlso IsNothing(m_Door1) Then Return
      ' se almeno uno esiste
      Dim dLightHinge As Double
      Dim dLightLock As Double
      Dim dOverlapLock As Double
      Dim dOverlapHinge As Double
      Dim dWidth1 As Double
      Dim dWidth2 As Double
      Dim dActualWidth As Double
      Dim dThicknessJamb As Double
      StringToDouble(Map.refAssemblyPageVM.CurrAssembly.LightHinge, dLightHinge)
      StringToDouble(Map.refAssemblyPageVM.CurrAssembly.LightLock, dLightLock)
      StringToDouble(Map.refAssemblyPageVM.CurrAssembly.OverlapLock, dOverlapLock)
      StringToDouble(Map.refAssemblyPageVM.CurrAssembly.OverlapHinge, dOverlapHinge)
      StringToDouble(Map.refAssemblyPageVM.CurrAssembly.Thickness, dThicknessJamb)
      StringToDouble(m_Door1.Width, dWidth1)

      Select Case m_DoorNumber
         Case "1"
            dActualWidth = dLightHinge + dLightLock
            If Not IsNothing(m_JambB) Then m_JambB.SetWidth(DoubleToString(dWidth1 + dActualWidth, 4))
            If Not IsNothing(m_JambT) Then m_JambT.SetWidth(DoubleToString(dWidth1 + dActualWidth, 4))
         Case "2"
            If Not IsNothing(m_Door2) Then
               StringToDouble(m_Door2.Width, dWidth2)
            Else
               ' se la seconda anta non esiste allora devo ridimensionare il progetto ad una sola anta
               For Each sNumber In m_DoorListNumber
                  If Trim(sNumber) = "1" Then
                     m_DoorNumber = sNumber
                     Return
                  End If
               Next
               Return
            End If
            ' se la seconda anta esiste allora procedo nel calcolo
            dActualWidth = dLightHinge + dLightHinge + dLightLock + dWidth1
            If Not IsNothing(m_JambB) Then m_JambB.SetWidth(DoubleToString(dWidth2 + dActualWidth, 4))
            If Not IsNothing(m_JambT) Then m_JambT.SetWidth(DoubleToString(dWidth2 + dActualWidth, 4))
      End Select
      NotifyPropertyChanged("AssemblyWidth")

   End Sub

   ' calcola la larghezza dei Jamb laterali
   Public Sub SetWidthJamb()
      If Not IsNothing(m_JambR) Then m_JambR.SetWidth(m_Width)
      If Not IsNothing(m_JambL) Then m_JambL.SetWidth(m_Width)
      'If Not IsNothing(m_JambB) Then m_JambB.Height = m_Width

      ' ricalcolo la dimensione dell'anta
      If Not Dimension Then Return
      'Dim DO_1 As PartDoor = Map.refAssemblyManagerVM.ReserchPartDoor("DO_1")
      'Dim DO_2 As PartDoor = Map.refAssemblyManagerVM.ReserchPartDoor("DO_2")
      Dim LL As String = LightLock
      Dim LH As String = LightHinge
      Dim JW As String = Width
      Dim TotW As String = m_AssemblyWidth

      If Not IsNothing(m_Door1) Then
         Dim nDO_1Width As Double = 0
         Dim nDO_2Width As Double = 0
         StringToDouble(m_Door1.Width, nDO_1Width)
         Dim nJW As Double = 0
         StringToDouble(JW, nJW)
         Dim nLL As Double = 0
         StringToDouble(LL, nLL)
         Dim nLH As Double = 0
         StringToDouble(LH, nLH)
         Dim nTotW As Double = 0
         StringToDouble(TotW, nTotW)
         ' due ante
         If Not IsNothing(m_Door2) Then
            ' la seconda anta viene ricalcolata mantenedo fissa la dimensione della prima
            StringToDouble(m_Door2.Width, nDO_2Width)
            nDO_2Width = nTotW - (nLL + nLH * 2 + 2 * nJW + nDO_1Width)
            If Exterior Then
               Dim nOLL As Double = 0
               StringToDouble(OverlapLock, nOLL)
               Dim nOLH As Double = 0
               StringToDouble(OverlapHinge, nOLH)
               nDO_2Width = nDO_2Width + 2 * nOLH
            End If
            m_Door2.SetWidth(DoubleToString(nDO_2Width, 4))
         Else
            ' singol anta
            nDO_1Width = nTotW - (nLL + nLH + 2 * nJW)
            If Exterior Then
               Dim nOLL As Double = 0
               StringToDouble(OverlapLock, nOLL)
               Dim nOLH As Double = 0
               StringToDouble(OverlapHinge, nOLH)
               nDO_1Width = nDO_1Width + nOLH + nOLL
            End If
            m_Door1.SetWidth(DoubleToString(nDO_1Width, 4))
         End If
      End If
      TopBottomWidth()
      'm_BottomJamb.SetHeight(m_Width)
      'm_TopJamb.SetHeight(m_ThicknessHead)
      'm_LeftJamb.SetWidth(m_Width)
      'm_RightJamb.SetWidth(m_Width)
   End Sub

#End Region    ' Width

#Region "THICKNESS"

   ' calcola la dimensione spessore dei Jamb (per tutti lo stesso)
   Public Sub SetThicKnessJamb()
      If Not IsNothing(m_JambB) Then
         If m_Exterior Then
            m_JambB.Thickness = m_DepthBottom
         Else
            m_JambB.Thickness = m_Thickness
         End If
      End If
      If Not IsNothing(m_JambT) Then m_JambT.Thickness = m_Thickness
      If Not IsNothing(m_JambR) Then m_JambR.Thickness = m_Thickness
      If Not IsNothing(m_JambR) Then m_JambL.Thickness = m_Thickness
   End Sub

#End Region    ' Thickness

#Region "SWING"

   ' se sulla porta singola avviene cambio swing (da LeftHand a RightHand) allora devo invertire i Jamb laterali
   ' se eistono entrambi i Jamb laterali inverto allora li inverto
   Public Sub UpDateCompolistOnJamb()
      Dim sSwing1 As SwingItemTypeList = Nothing
      ' in AssemblyManager ho assegnato ai Jamb la lista completa degli swing
      For Each Item In OptionModule.m_SwingTypeList
         If Trim(m_Door1.SwingAlias.AliasName) = Trim(Item) Then
            OptionModule.SetCurrSwing(sSwing1, Item)
            Exit For
         End If
      Next
      If IsNothing(sSwing1) Then Return
      Select Case DoorNumber
         Case "1"
            ' passo da un'anta LeftHand ad una RightHand
            If Not IsNothing(m_JambL) Then
               If (m_JambL.SwingAlias.Name.Contains("LH") And sSwing1.Name.Contains("RH")) OrElse
                  (m_JambL.SwingAlias.Name.Contains("RH") And sSwing1.Name.Contains("LH")) Then
                  If Not IsNothing(m_JambR) Then
                     Dim TempJambL As Part = Map.refAssemblyManagerVM.ReserchPartDoor("FL_").Door.ShallowCopy()
                     Dim TempJambR As Part = Map.refAssemblyManagerVM.ReserchPartDoor("FR_").Door.ShallowCopy()
                     TempJambR.IsActive = TempJambL.IsActive
                     TempJambL.IsActive = Map.refAssemblyManagerVM.ReserchPartDoor("FR_").Door.IsActive
                     TempJambR.TypePart = ConstGen.PART_FRAME_LEFT
                     Map.refAssemblyManagerVM.ReserchPartDoor("FL_").Door = TempJambR
                     TempJambL.TypePart = ConstGen.PART_FRAME_RIGHT
                     Map.refAssemblyManagerVM.ReserchPartDoor("FR_").Door = TempJambL
                     ' aggiorno le copie presenti nell'assemblato
                     SetPartDoorCurrAssembly()
                  End If
               End If
            End If
         Case "2"
            ' passo da un'anta Active ad una Inactive
            If IsNothing(m_Door2) Then Return
            ' sicuramente la porta corrente è quella modificata
            If Map.refPartPageVM.CurrPart.TypePart.Contains("DO_1") Then
               SwingDoor(m_Door2, m_Door1)
            Else
               SwingDoor(m_Door1, m_Door2)
            End If
            ' in AssemblyManager ho assegnato ai Jamb la lista completa degli swing
            For Each Item In OptionModule.m_SwingTypeList
               If Trim(m_Door1.SwingAlias.AliasName) = Trim(Item) Then
                  OptionModule.SetCurrSwing(sSwing1, Item)
                  Exit For
               End If
            Next
            If Not IsNothing(m_JambL) Then
               If (m_JambL.SwingAlias.Name.Contains("I") And Not sSwing1.Name.Contains("I")) OrElse
                  (Not m_JambL.SwingAlias.Name.Contains("I") And sSwing1.Name.Contains("I")) Then
                  Dim TempDoor1 As Part = Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door.ShallowCopy()
                  Dim TempDoor2 As Part = Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door.ShallowCopy()
                  TempDoor2.IsActive = TempDoor1.IsActive
                  TempDoor1.IsActive = Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door.IsActive
                  TempDoor2.TypePart = "DO_1"
                  Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door = TempDoor2
                  Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door.refPartDoor = Map.refAssemblyManagerVM.ReserchPartDoor("DO_1")
                  Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door.SwingTypeList = OptionModule.m_SwingTypeListLeftDoor
                  Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door.SetSwing(TempDoor1.Swing)

                  TempDoor1.TypePart = "DO_2"
                  Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door = TempDoor1
                  Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door.refPartDoor = Map.refAssemblyManagerVM.ReserchPartDoor("DO_2")
                  Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door.SwingTypeList = OptionModule.m_SwingTypeListRightDoor
                  SwingDoor(Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door, Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door)

                  If Not IsNothing(m_JambR) Then
                     Dim TempJambL As Part = Map.refAssemblyManagerVM.ReserchPartDoor("FL_").Door.ShallowCopy()
                     Dim TempJambR As Part = Map.refAssemblyManagerVM.ReserchPartDoor("FR_").Door.ShallowCopy()
                     TempJambR.IsActive = TempJambL.IsActive
                     TempJambL.IsActive = Map.refAssemblyManagerVM.ReserchPartDoor("FR_").Door.IsActive
                     TempJambR.TypePart = ConstGen.PART_FRAME_LEFT
                     Map.refAssemblyManagerVM.ReserchPartDoor("FL_").Door = TempJambR
                     TempJambL.TypePart = ConstGen.PART_FRAME_RIGHT
                     Map.refAssemblyManagerVM.ReserchPartDoor("FR_").Door = TempJambL
                  End If
                  ' aggiorno le copie presenti nell'assemblato
                  SetPartDoorCurrAssembly()
               End If
               If Map.refPartPageVM.CurrPart.TypePart.Contains("DO_1") Then
                  Map.refPartPageVM.CurrPart = m_Door1
               Else
                  Map.refPartPageVM.CurrPart = m_Door2
               End If
            End If
      End Select
   End Sub

   Public Sub MaterialJamb()
      If Not IsNothing(m_JambB) Then
         m_JambB.SetMaterial(OptionModule.m_CurrMaterial)
         'CreateNewPropertiesListJamb(m_JambB.PropertiesList, m_JambB.SelectedMaterial)
         CreateNewPropertiesList(m_JambB)
      End If
      If Not IsNothing(m_JambT) Then
         m_JambT.SetMaterial(OptionModule.m_CurrMaterial)
         'CreateNewPropertiesListJamb(m_JambT.PropertiesList, m_JambT.SelectedMaterial)
         CreateNewPropertiesList(m_JambT)
      End If
      If Not IsNothing(m_JambR) Then
         m_JambR.SetMaterial(OptionModule.m_CurrMaterial)
         'CreateNewPropertiesListJamb(m_JambR.PropertiesList, m_JambR.SelectedMaterial)
         CreateNewPropertiesList(m_JambR)
      End If
      If Not IsNothing(m_JambR) Then
         m_JambL.SetMaterial(OptionModule.m_CurrMaterial)
         'CreateNewPropertiesListJamb(m_JambL.PropertiesList, m_JambL.SelectedMaterial)
         CreateNewPropertiesList(m_JambL)
      End If
   End Sub

   ' assegna gli swing ai jamb 
   Public Sub SwingJamb()
      ' se la prima anta non esiste allora interrompo 
      If IsNothing(m_Door1) Then Return
      Dim sSwing1 As String = String.Empty
      ' in AssemblyManager assegno ai Jamb la lista completa degli swing
      For Each Item In OptionModule.m_SwingTypeList
         If Trim(m_Door1.SwingAlias.AliasName) = Trim(Item) Then
            sSwing1 = Item
            Exit For
         End If
      Next

      Select Case DoorNumber
         Case "1"
            If Not IsNothing(m_JambB) Then m_JambB.SetSwing(sSwing1)
            If Not IsNothing(m_JambT) Then m_JambT.SetSwing(sSwing1)
            If Not IsNothing(m_JambL) Then m_JambL.SetSwing(sSwing1)
            If Not IsNothing(m_JambR) Then m_JambR.SetSwing(sSwing1)

            If Exterior Then
               ' se di tipo LeftHand
               If Not IsNothing(m_JambL) AndAlso Not IsNothing(m_JambR) AndAlso m_JambL.SwingAlias.Name.Contains("LH") Then
                  m_JambL.TypePart = ConstGen.PART_FRAME_LEFT & ConstGen.HINGE & ConstGen.EXTERIOR
                  m_JambR.TypePart = ConstGen.PART_FRAME_RIGHT & ConstGen.LOCK & ConstGen.EXTERIOR
               Else
                  If Not IsNothing(m_JambL) Then m_JambL.TypePart = ConstGen.PART_FRAME_LEFT & ConstGen.LOCK & ConstGen.EXTERIOR
                  If Not IsNothing(m_JambR) Then m_JambR.TypePart = ConstGen.PART_FRAME_RIGHT & ConstGen.HINGE & ConstGen.EXTERIOR
               End If
               If Not IsNothing(m_JambB) Then m_JambB.TypePart = ConstGen.PART_FRAME_BOTTOM & ConstGen.BOTTOM & ConstGen.EXTERIOR
               If Not IsNothing(m_JambT) Then m_JambT.TypePart = ConstGen.PART_FRAME_TOP & ConstGen.TOP & ConstGen.EXTERIOR
            Else
               If Not IsNothing(m_JambL) AndAlso Not IsNothing(m_JambR) AndAlso m_JambL.SwingAlias.Name.Contains("LH") Then
                  m_JambL.TypePart = ConstGen.PART_FRAME_LEFT & ConstGen.HINGE
                  m_JambR.TypePart = ConstGen.PART_FRAME_RIGHT & ConstGen.LOCK
               Else
                  If Not IsNothing(m_JambL) Then m_JambL.TypePart = ConstGen.PART_FRAME_LEFT & ConstGen.LOCK
                  If Not IsNothing(m_JambR) Then m_JambR.TypePart = ConstGen.PART_FRAME_RIGHT & ConstGen.HINGE
               End If
               If Not IsNothing(m_JambB) Then m_JambB.TypePart = ConstGen.PART_FRAME_BOTTOM & ConstGen.BOTTOM
               If Not IsNothing(m_JambT) Then m_JambT.TypePart = ConstGen.PART_FRAME_TOP & ConstGen.TOP
            End If

         Case "2"
            If IsNothing(m_Door2) Then
               ' se la seconda anta non esiste allora devo ridimensionare il progetto ad una sola anta
               For Each sNumber In m_DoorListNumber
                  If Trim(sNumber) = "1" Then
                     m_DoorNumber = sNumber
                     Return
                  End If
               Next
               Return
            End If
            ' sicuramente la porta corrente è quella modificata
            If Not IsNothing(Map.refPartPageVM.CurrPart) AndAlso Map.refPartPageVM.CurrPart.TypePart.Contains("DO_1") Then
               SwingDoor(m_Door2, m_Door1)
            Else
               SwingDoor(m_Door1, m_Door2)
            End If
            ' ricerco nell'elenco degli swing 
            Dim sSwing2 As String = String.Empty
            ' in AssemblyManager assegno ai Jamb la lista completa degli swing
            For Each Item In OptionModule.m_SwingTypeList
               If Trim(m_Door2.SwingAlias.Name) = Trim(Item) Then
                  sSwing2 = Item
                  Exit For
               End If
            Next
            ' assegno gli swing
            If Not IsNothing(m_JambB) Then m_JambB.SetSwing(sSwing2)
            If Not IsNothing(m_JambT) Then m_JambT.SetSwing(sSwing1)
            If Not IsNothing(m_JambL) Then m_JambL.SetSwing(sSwing1)
            If Not IsNothing(m_JambR) Then m_JambR.SetSwing(sSwing2)
            ' assegno il nome del tipo completo
            If Exterior Then
               If Not IsNothing(m_JambL) Then m_JambL.TypePart = ConstGen.PART_FRAME_LEFT & ConstGen.HINGE & ConstGen.EXTERIOR
               If Not IsNothing(m_JambR) Then m_JambR.TypePart = ConstGen.PART_FRAME_RIGHT & ConstGen.HINGE & ConstGen.EXTERIOR
               If Not IsNothing(m_JambB) Then m_JambB.TypePart = ConstGen.PART_FRAME_BOTTOM & ConstGen.BOTTOM & ConstGen.EXTERIOR
               If Not IsNothing(m_JambT) Then m_JambT.TypePart = ConstGen.PART_FRAME_TOP & ConstGen.TOP & ConstGen.EXTERIOR
            Else
               If Not IsNothing(m_JambL) Then m_JambL.TypePart = ConstGen.PART_FRAME_LEFT & ConstGen.HINGE
               If Not IsNothing(m_JambR) Then m_JambR.TypePart = ConstGen.PART_FRAME_RIGHT & ConstGen.HINGE
               If Not IsNothing(m_JambB) Then m_JambB.TypePart = ConstGen.PART_FRAME_BOTTOM & ConstGen.BOTTOM
               If Not IsNothing(m_JambT) Then m_JambT.TypePart = ConstGen.PART_FRAME_TOP & ConstGen.TOP
            End If
      End Select
   End Sub

   ' elimina tutti i riferimenti esistenti
   Public Sub ClearRefOnAssembly()
      ' elimino tutti i riferimenti esistenti
      If Not IsNothing(m_Door1) Then
         For Each ItemCompo In m_Door1.CompoList
            If Not IsNothing(ItemCompo.refJambCompo) Then
               m_Door1.RemoveCompo(ItemCompo, True)
            End If
         Next
      End If
      ' elimino tutti i riferimenti esistenti
      If Not IsNothing(m_Door2) Then
         For Each ItemCompo In m_Door2.CompoList
            If Not IsNothing(ItemCompo.refJambCompo) Then
               m_Door2.RemoveCompo(ItemCompo, True)
            End If
         Next
      End If
   End Sub

   ' costruisce i riferminti della prima anta
   Public Sub ReloadAllCompoDoor1()
      If IsNothing(m_Door1) Then Return
      ' ricalcolo tutti i riferimenti
      Map.refPartPageVM.CurrPart = m_Door1
      For Each ItemCompo In m_Door1.CompoList
         CreateCompoOnJamb(ItemCompo, "")
      Next
   End Sub

   ' inverte la prima anta con la seconda anta
   Public Sub ReverseDoor()
      If IsNothing(m_Door1) OrElse IsNothing(m_Door2) Then Return
      If Not m_Door1.SwingAlias.Name.Contains("I") Then Return
      ' copio l'anta uno al posto dell'anta due e viceversa
      Dim TempDoor1 As Part = Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door.ShallowCopy()
      Dim TempDoor2 As Part = Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door.ShallowCopy()
      TempDoor2.IsActive = TempDoor1.IsActive
      TempDoor1.IsActive = Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door.IsActive
      TempDoor2.TypePart = "DO_1"
      Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door = TempDoor2
      Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door.refPartDoor = Map.refAssemblyManagerVM.ReserchPartDoor("DO_1")
      Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door.SwingTypeList = OptionModule.m_SwingTypeListLeftDoor
      Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door.SetSwing(TempDoor1.Swing)

      TempDoor1.TypePart = "DO_2"
      Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door = TempDoor1
      Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door.refPartDoor = Map.refAssemblyManagerVM.ReserchPartDoor("DO_2")
      Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door.SwingTypeList = OptionModule.m_SwingTypeListRightDoor
      SwingDoor(Map.refAssemblyManagerVM.ReserchPartDoor("DO_2").Door, Map.refAssemblyManagerVM.ReserchPartDoor("DO_1").Door)

      If IsNothing(m_JambR) OrElse IsNothing(m_JambL) Then Return
      Dim TempJambL As Part = Map.refAssemblyManagerVM.ReserchPartDoor("FL_").Door.ShallowCopy()
      Dim TempJambR As Part = Map.refAssemblyManagerVM.ReserchPartDoor("FR_").Door.ShallowCopy()
      TempJambR.IsActive = TempJambL.IsActive
      TempJambL.IsActive = Map.refAssemblyManagerVM.ReserchPartDoor("FR_").Door.IsActive
      TempJambR.TypePart = ConstGen.PART_FRAME_LEFT
      Map.refAssemblyManagerVM.ReserchPartDoor("FL_").Door = TempJambR
      TempJambL.TypePart = ConstGen.PART_FRAME_RIGHT
      Map.refAssemblyManagerVM.ReserchPartDoor("FR_").Door = TempJambL

      ' aggiorno le copie presenti nell'assemblato
      SetPartDoorCurrAssembly()
   End Sub

   ' permette di settare lo swing della seconda anta in funzione della selezione dello swing sulla prima anta.
   ' riceve l'anta da modificare (ModifySwingDoor) e l'anta che comanda la modifica (ModifiedSwingDoor)
   Public Sub SwingDoor(ModifySwingDoor As Part, ModifiedSwingDoor As Part)
      If Not IsNothing(ModifiedSwingDoor) AndAlso Not IsNothing(ModifiedSwingDoor) Then
         For IndexSwing As Integer = 0 To ModifiedSwingDoor.SwingTypeList.Count - 1
            If ModifiedSwingDoor.Swing = ModifiedSwingDoor.SwingTypeList(IndexSwing) Then
               ModifySwingDoor.SetSwing(ModifySwingDoor.SwingTypeList(IndexSwing))
               Exit For
            End If
         Next
      End If
   End Sub

#End Region    ' Swing

   Public Sub RefreshJambCheck()
      For Each Item In ListPartDoor
         If Item.Door.TypePart.Contains("FL_") Then
            JambLIsChecked = Item.Door.IsActive
         ElseIf Item.Door.TypePart.Contains("FT_") Then
            JambTIsChecked = Item.Door.IsActive
         ElseIf Item.Door.TypePart.Contains("FB_") Then
            JambBIsChecked = Item.Door.IsActive
         ElseIf Item.Door.TypePart.Contains("FT_") Then
            JambTIsChecked = Item.Door.IsActive
         End If
      Next
   End Sub

   ' definisc le costanti dell'assemblato
   Public Sub SetVarAssembly()
      Dim dHeight As Double
      Dim dWidth As Double
      Dim dThickness As Double
      If Not IsNothing(m_Door1) Then
         If Not IsNothing(m_Door1.Height) AndAlso StringToDouble(m_Door1.Height, dHeight) Then
            EgtLuaSetGlobNumVar("H", dHeight)
            EgtLuaSetGlobNumVar("H1", dHeight)
         End If
         If Not IsNothing(m_Door1.Width) AndAlso StringToDouble(m_Door1.Width, dWidth) Then
            EgtLuaSetGlobNumVar("W", dWidth)
            EgtLuaSetGlobNumVar("W1", dWidth)
         End If
         If Not IsNothing(m_Door1.Thickness) AndAlso StringToDouble(m_Door1.Thickness, dThickness) Then
            EgtLuaSetGlobNumVar("T", dThickness)
            EgtLuaSetGlobNumVar("T1", dThickness)
         End If
      End If
      If Not IsNothing(m_Door2) Then
         If Not IsNothing(m_Door2.Height) AndAlso StringToDouble(m_Door2.Height, dHeight) Then
            EgtLuaSetGlobNumVar("H2", dHeight)
         End If
         If Not IsNothing(m_Door2.Width) AndAlso StringToDouble(m_Door2.Width, dWidth) Then
            EgtLuaSetGlobNumVar("W2", dWidth)
         End If
         If Not IsNothing(m_Door2.Thickness) AndAlso StringToDouble(m_Door2.Thickness, dThickness) Then
            EgtLuaSetGlobNumVar("T2", dThickness)
         End If
      End If

   End Sub

#Region "RABBET"

   ' restituisce l'indice della componente "rabbet"
   Private Function nCompoRabbet() As Integer
      Dim RabbetIndex As Integer = -1
      For Index As Integer = 0 To Map.refCompoPanelVM.CompoTypeList.Count - 1
         If Trim(Map.refCompoPanelVM.CompoTypeList(Index).DDFName) = "rabbet" Then
            RabbetIndex = Index
            Exit For
         End If
      Next
      Return RabbetIndex
   End Function

   ' clacola il rabbet sul profilo top dei Jamb (quindi solo su quelli laterali)
   Public Sub TopRabbetJamb()
      Dim sThicknessHead As String = Map.refAssemblyPageVM.CurrAssembly.ThicknessHead
      Dim sOverlapHinge As String = Map.refAssemblyPageVM.CurrAssembly.OverlapHinge
      Dim sOverLapLock As String = Map.refAssemblyPageVM.CurrAssembly.OverlapLock
      Dim sLightUp As String = Map.refAssemblyPageVM.CurrAssembly.LightUp
      Select Case DoorNumber
         Case "1"
            If Not m_JambL.SwingAlias.Name.Contains("L") Then
               If Not IsNothing(m_JambL) Then SetTopRabbetJamb(m_JambL, sThicknessHead, sOverLapLock, sLightUp)
               If Not IsNothing(m_JambR) Then SetTopRabbetJamb(m_JambR, sThicknessHead, sOverlapHinge, sLightUp)
            Else
               If Not IsNothing(m_JambL) Then SetTopRabbetJamb(m_JambL, sThicknessHead, sOverlapHinge, sLightUp)
               If Not IsNothing(m_JambR) Then SetTopRabbetJamb(m_JambR, sThicknessHead, sOverLapLock, sLightUp)
            End If
         Case "2"
            SetTopRabbetJamb(m_JambL, sThicknessHead, sOverlapHinge, sLightUp)
            SetTopRabbetJamb(m_JambR, sThicknessHead, sOverlapHinge, sLightUp)
      End Select
   End Sub

   ' ricerca la componente Rabbet, se non esiete la aggiunge e poi la modifica, altrimenti la modifica
   Private Sub SetTopRabbetJamb(ByRef Jamb As Part, sThicknessHead As String, sOverlap As String, sLightUp As String)
      If IsNothing(Jamb) Then Return
      Dim CurrCompo As Compo = Nothing
      Dim IndexCompoPanel As Integer = -1
      ' ricerco la posizione del rabbet nella lista dei componenti
      IndexCompoPanel = nCompoRabbet()
      ' se la ricerca ha dato un esito positivo allora procedo
      If IndexCompoPanel = -1 Then Return
      Dim bRabbet As Boolean = False
      Dim IndexCompo As Integer
      ' se esisteno delle componenti allora cerco la componente rabbet
      If Jamb.CompoList.Count > 0 Then
         ' inizio la ricerca della componente di tipo rabbet
         For IndexCompo = 0 To Jamb.CompoList.Count - 1
            If Jamb.CompoList(IndexCompo).CompoType.DDFName = OptionModule.m_CompoPaneOrder(IndexCompoPanel) Then
               ' controllo che il primo elemento selezionato nella ComboBox sia uguale al primo elemento della lista (questa cosa non mi convince) 
               If DirectCast(Jamb.CompoList(IndexCompo).CompoParamList(0), ComboBoxParam).SelItem = DirectCast(Jamb.CompoList(IndexCompo).CompoParamList(0), ComboBoxParam).ItemList(0) Then
                  bRabbet = True
                  Exit For
               End If
            End If
         Next
      End If
      ' se non eiste il rabbet lo aggiungo
      If Not bRabbet Then
         'Map.refPartPageVM.CurrPart = Jamb
         CurrCompo = Jamb.AddNewCompo(Map.refCompoPanelVM.CompoTypeList(IndexCompoPanel), True)
         DirectCast(CurrCompo.CompoParamList(0), ComboBoxParam).SelItem = DirectCast(CurrCompo.CompoParamList(0), ComboBoxParam).ItemList(0)
      Else
         CurrCompo = Jamb.CompoList(IndexCompo)
      End If
      ' mofico la componete rabbet
      If Not IsNothing(CurrCompo) Then
         Dim dVal3 As Double = 0
         StringToDouble(sOverlap, dVal3)
         If dVal3 <= 0 Then
            Jamb.CompoList.RemoveAt(IndexCompo)
         Else
            SetTopRabbetParam(sThicknessHead, sOverlap, CurrCompo, sLightUp)
         End If

      End If
   End Sub

   ' setta i parametri della componente Rabbet sul top
   Private Sub SetTopRabbetParam(sThicknessHead As String, sOverlapTop As String, CurrCompo As Compo, sLightUp As String)
      Dim CurrCompoParam As CompoParam = CurrCompo.CompoParamList(1)
      If TypeOf CurrCompoParam Is TextBoxParam Then
         Dim TextParam As TextBoxParam = DirectCast(CurrCompoParam, TextBoxParam)
         TextParam.m_Value = sThicknessHead
         TextParam.NotifyPropertyChanged("Value")
      End If
      CurrCompoParam = CurrCompo.CompoParamList(2)
      If TypeOf CurrCompoParam Is TextBoxParam Then
         Dim TextParam As TextBoxParam = DirectCast(CurrCompoParam, TextBoxParam)
         Dim sRabbetDepth As String = sOverlapTop
         TextParam.m_Value = sRabbetDepth
         TextParam.NotifyPropertyChanged("Value")
      End If
      CurrCompoParam = CurrCompo.CompoParamList(3)
      If TypeOf CurrCompoParam Is TextBoxOnOffParam Then
         Dim TextParam As TextBoxOnOffParam = DirectCast(CurrCompoParam, TextBoxOnOffParam)
         TextParam.SetIsActive(False)
         TextParam.NotifyPropertyChanged("Value")
      End If
   End Sub

   ' calcola il rabbet sul lato Bottom solo se è stata selezionata la proprietà exterior
   Public Sub BottomRabbetJamb()
      Dim sThicknessDoor As String
      If Not IsNothing(m_Door1) Then
         sThicknessDoor = m_Door1.Thickness
      Else
         sThicknessDoor = "0"
      End If
      Dim sOverLapHinge As String = Map.refAssemblyPageVM.CurrAssembly.OverlapHinge
      Dim sOverLapLock As String = Map.refAssemblyPageVM.CurrAssembly.OverlapLock
      Dim sOverLapTop As String = Map.refAssemblyPageVM.CurrAssembly.OverlapTop
      'Dim sWidthJamb As String = Map.refAssemblyPageVM.CurrAssembly.Width
      Dim sOverlapBottom As String = Map.refAssemblyPageVM.CurrAssembly.OverlapBottom
      Dim sDeltaT As String = Map.refAssemblyPageVM.CurrAssembly.DeltaThickness
      Dim sThicknessBottm As String = Map.refAssemblyPageVM.CurrAssembly.ThicknessBottom
      Dim sDeltaBottom As String = Map.refAssemblyPageVM.CurrAssembly.DeltaBottom
      Dim IndexBottom As Integer = 1
      Dim IndexHinge As Integer = 2

      Dim dValBottom As Double = 0
      StringToDouble(sDeltaBottom, dValBottom)
      Dim dValDoor As Double = 0
      StringToDouble(sDeltaT, dValDoor)
      Dim DeltaTotal As String = DoubleToString(dValDoor - dValBottom, 4)

      Select Case DoorNumber
         Case "1"
            If Not m_JambL.SwingAlias.Name.Contains(ConstGen.LOCK) Then
               RabbetExterior(m_JambL, sThicknessDoor, sThicknessBottm, sOverLapLock, IndexBottom)
               RabbetExterior(m_JambR, sThicknessDoor, sThicknessBottm, sOverLapHinge, IndexBottom)
               SetHingeRabbetJamb(m_JambB, sThicknessDoor, DeltaTotal, sOverlapBottom, IndexHinge)
            Else
               RabbetExterior(m_JambL, sThicknessDoor, sThicknessBottm, sOverLapHinge, IndexBottom)
               RabbetExterior(m_JambR, sThicknessDoor, sThicknessBottm, sOverLapLock, IndexBottom)
               SetHingeRabbetJamb(m_JambB, sThicknessDoor, DeltaTotal, sOverlapBottom, IndexHinge)
            End If
         Case "2"
            RabbetExterior(m_JambL, sThicknessDoor, sThicknessBottm, sOverLapHinge, IndexBottom)
            RabbetExterior(m_JambR, sThicknessDoor, sThicknessBottm, sOverLapHinge, IndexBottom)
            SetHingeRabbetJamb(m_JambB, sThicknessDoor, DeltaTotal, sOverlapBottom, IndexHinge)
      End Select
   End Sub

   ' calcola il rabbet sul lato Hinge solo se è stata selezionata la proprietà exterior
   Public Sub HingeRabbetJamb()
      Dim sThicknessDoor As String
      If Not IsNothing(m_Door1) Then
         sThicknessDoor = m_Door1.Thickness
      Else
         sThicknessDoor = "0"
      End If
      Dim sDeltaT As String = Map.refAssemblyPageVM.CurrAssembly.DeltaThickness
      Dim sOverLapHinge As String = Map.refAssemblyPageVM.CurrAssembly.OverlapHinge
      Dim sOverLapLock As String = Map.refAssemblyPageVM.CurrAssembly.OverlapLock
      Dim sOverLapTop As String = Map.refAssemblyPageVM.CurrAssembly.OverlapTop
      Dim sOverlapBottom As String = Map.refAssemblyPageVM.CurrAssembly.OverlapBottom
      ' questo flag, che è poi passato alla funzione RabbetExterior, ha lo scopo di identificare chi sta esegunedo la chiamata
      Dim IndexHinge As Integer = 2
      Dim IndexLock As Integer = 3
      Select Case DoorNumber
         Case "1"
            If Not m_JambL.SwingAlias.Name.Contains(ConstGen.LOCK) Then
               SetHingeRabbetJamb(m_JambL, sThicknessDoor, sDeltaT, sOverLapLock, IndexLock)
               SetHingeRabbetJamb(m_JambR, sThicknessDoor, sDeltaT, sOverLapHinge, IndexHinge)
               SetHingeRabbetJamb(m_JambT, sThicknessDoor, sDeltaT, sOverLapTop, IndexHinge)
            Else
               SetHingeRabbetJamb(m_JambL, sThicknessDoor, sDeltaT, sOverLapHinge, IndexHinge)
               SetHingeRabbetJamb(m_JambR, sThicknessDoor, sDeltaT, sOverLapLock, IndexLock)
               SetHingeRabbetJamb(m_JambT, sThicknessDoor, sDeltaT, sOverLapTop, IndexHinge)
            End If
         Case "2"
            SetHingeRabbetJamb(m_JambL, sThicknessDoor, sDeltaT, sOverLapHinge, IndexHinge)
            SetHingeRabbetJamb(m_JambR, sThicknessDoor, sDeltaT, sOverLapHinge, IndexHinge)
            SetHingeRabbetJamb(m_JambT, sThicknessDoor, sDeltaT, sOverLapTop, IndexHinge)
      End Select
   End Sub

   Public Sub SetHingeRabbetJamb(ByRef Jamb As Part, sThicknessDoor As String, sDeltaT As String, sOverLap As String, nIndexSide As Integer)
      If IsNothing(Jamb) Then Return
      'Dim IndexHinge As Integer = 2
      'Dim IndexBottom As Integer = 1
      Dim CompoListIndex As Integer = nCompoRabbet()
      If CompoListIndex = -1 Then Return
      Dim Local_Compo As Compo
      Dim bRabbet As Boolean = False
      Dim IndexCompo As Integer
      ' cerco la componente
      If Jamb.CompoList.Count > 0 Then
         For IndexCompo = 0 To Jamb.CompoList.Count - 1
            If Jamb.CompoList(IndexCompo).CompoType.DDFName = Map.refCompoPanelVM.CompoTypeList(CompoListIndex).DDFName Then
               If DirectCast(Jamb.CompoList(IndexCompo).CompoParamList(0), ComboBoxParam).SelItem = DirectCast(Jamb.CompoList(IndexCompo).CompoParamList(0), ComboBoxParam).ItemList(nIndexSide) Then
                  bRabbet = True
                  Exit For
               End If
            End If
         Next
      End If
      ' se il rabbet non esiste
      If Not bRabbet Then
         ' lo aggiungo
         Local_Compo = Jamb.AddNewCompo(Map.refCompoPanelVM.CompoTypeList(CompoListIndex), True)
         DirectCast(Local_Compo.CompoParamList(0), ComboBoxParam).SetSelItem(DirectCast(Local_Compo.CompoParamList(0), ComboBoxParam).ItemList(nIndexSide))
      Else
         Local_Compo = Jamb.CompoList(IndexCompo)
      End If
      If Not IsNothing(Local_Compo) Then
         Dim dVal1 As Double = 0
         Dim dVal2 As Double = 0
         Dim dVal3 As Double = 0
         StringToDouble(sThicknessDoor, dVal1)
         StringToDouble(sDeltaT, dVal2)
         StringToDouble(sOverLap, dVal3)
         If nIndexSide = 3 Then nIndexSide = 2
         If dVal1 + dVal2 <= 0 OrElse dVal3 <= 0 Then
            Jamb.CompoList.RemoveAt(IndexCompo)
         Else
            SetHingeRabbetParam(sThicknessDoor, sDeltaT, sOverLap, Local_Compo, nIndexSide)
         End If
      End If
   End Sub

   ' cerca la compo Rabbet sul lato indicato (Top o Bottom)
   Public Sub RabbetExterior(ByRef Jamb As Part, sThicknessDoor As String, sDeltaT As String, sOverLap As String, nIndexSide As Integer)
      If IsNothing(Jamb) Then Return
      'Dim IndexHinge As Integer = 2
      'Dim IndexBottom As Integer = 1
      Dim CompoListIndex As Integer = nCompoRabbet()
      If CompoListIndex = -1 Then Return
      Dim Local_Compo As Compo
      Dim bRabbet As Boolean = False
      Dim IndexCompo As Integer
      ' cerco la componente
      If Jamb.CompoList.Count > 0 Then
         For IndexCompo = 0 To Jamb.CompoList.Count - 1
            If Jamb.CompoList(IndexCompo).CompoType.DDFName = Map.refCompoPanelVM.CompoTypeList(CompoListIndex).DDFName Then
               If DirectCast(Jamb.CompoList(IndexCompo).CompoParamList(0), ComboBoxParam).SelItem = DirectCast(Jamb.CompoList(IndexCompo).CompoParamList(0), ComboBoxParam).ItemList(nIndexSide) Then
                  bRabbet = True
                  Exit For
               End If
            End If
         Next
      End If

      If m_Exterior Then
         ' se il rabbet non esiste
         If Not bRabbet Then
            ' lo aggiungo
            Local_Compo = Jamb.AddNewCompo(Map.refCompoPanelVM.CompoTypeList(CompoListIndex), True)
            DirectCast(Local_Compo.CompoParamList(0), ComboBoxParam).SetSelItem(DirectCast(Local_Compo.CompoParamList(0), ComboBoxParam).ItemList(nIndexSide))
         Else
            Local_Compo = Jamb.CompoList(IndexCompo)
         End If
         If Not IsNothing(Local_Compo) Then
            Dim dVal1 As Double = 0
            Dim dVal2 As Double = 0
            Dim dVal3 As Double = 0
            StringToDouble(sThicknessDoor, dVal1)
            StringToDouble(sDeltaT, dVal2)
            StringToDouble(sOverLap, dVal3)
            If dVal1 + dVal2 <= 0 OrElse dVal3 <= 0 Then
               Jamb.CompoList.RemoveAt(IndexCompo)
            Else
               SetHingeRabbetParam(sThicknessDoor, sDeltaT, sOverLap, Local_Compo, nIndexSide)
            End If
         End If
      Else
         ' rimuovo dalla lista
         If bRabbet Then Jamb.CompoList.RemoveAt(IndexCompo)
      End If

   End Sub
   ' assegna i valori ai parametri del rabbet 
   Private Sub SetHingeRabbetParam(sThicknessDoor As String, sDeltaT As String, sOverlap As String, CurrCompo As Compo, IndexSide As Integer)
      Dim dThicknessDoor As Double
      Dim dDeltaT As Double
      StringToDouble(sThicknessDoor, dThicknessDoor)
      StringToDouble(sDeltaT, dDeltaT)

      Select Case IndexSide
         ' se è stata passata sul lato cerniera/serrattura
         Case 2
            Dim CurrCompoParam As CompoParam = CurrCompo.CompoParamList(0)
            Dim Index As Integer = 0
            ' width
            CurrCompoParam = CurrCompo.CompoParamList(1)
            If TypeOf DirectCast(CurrCompoParam, CompoParam) Is TextBoxParam Then
               Dim TextParam As TextBoxParam = DirectCast(CurrCompoParam, TextBoxParam)
               ' definisce l'affondamento della porta nel telaio
               If dDeltaT + dThicknessDoor < 0 Then
                  TextParam.m_Value = "0"
               Else
                  TextParam.m_Value = DoubleToString(dDeltaT + dThicknessDoor, 4)
               End If
               TextParam.NotifyPropertyChanged("Value")
            End If
            ' depth
            CurrCompoParam = CurrCompo.CompoParamList(2)
            If TypeOf DirectCast(CurrCompoParam, CompoParam) Is TextBoxParam Then
               Dim TextParam As TextBoxParam = DirectCast(CurrCompoParam, TextBoxParam)
               Dim sRabbetDepth As String = sOverlap
               ' la profondità deve essere la stessa che è stata definita sul rabbet top
               TextParam.m_Value = sRabbetDepth
               TextParam.NotifyPropertyChanged("Value")
            End If
            ' angle
            CurrCompoParam = CurrCompo.CompoParamList(3)
            If TypeOf DirectCast(CurrCompoParam, CompoParam) Is TextBoxOnOffParam Then
               Dim TextOnOffParam As TextBoxOnOffParam = DirectCast(CurrCompoParam, TextBoxOnOffParam)
               ' disaativo il paramtro Angle
               TextOnOffParam.SetIsActive(False)
               TextOnOffParam.NotifyPropertyChanged("Value")
            End If

         Case 1
            ' inseriamo i parametri per la creazione del rabbet sul fondo
            Dim CurrCompoParam As CompoParam = CurrCompo.CompoParamList(0)
            Dim Index As Integer = 0
            ' width
            CurrCompoParam = CurrCompo.CompoParamList(1)
            If TypeOf DirectCast(CurrCompoParam, CompoParam) Is TextBoxParam Then
               Dim TextParam As TextBoxParam = DirectCast(CurrCompoParam, TextBoxParam)
               TextParam.m_Value = DoubleToString(dDeltaT, 4)
               TextParam.NotifyPropertyChanged("Value")
            End If
            ' Depth
            CurrCompoParam = CurrCompo.CompoParamList(2)
            If TypeOf DirectCast(CurrCompoParam, CompoParam) Is TextBoxParam Then
               Dim TextParam As TextBoxParam = DirectCast(CurrCompoParam, TextBoxParam)
               Dim sRabbetDepth As String = sOverlap
               TextParam.m_Value = sRabbetDepth
               TextParam.NotifyPropertyChanged("Value")
            End If
            ' Angle
            CurrCompoParam = CurrCompo.CompoParamList(3)
            If TypeOf DirectCast(CurrCompoParam, CompoParam) Is TextBoxOnOffParam Then
               Dim TextOnOffParam As TextBoxOnOffParam = DirectCast(CurrCompoParam, TextBoxOnOffParam)
               Dim sAngle As String = "2"
               TextOnOffParam.m_Value = sAngle
               TextOnOffParam.SetIsActive(True)
               TextOnOffParam.NotifyPropertyChanged("Value")
            End If
      End Select

   End Sub

#End Region    ' Rabbet 

#End Region    ' Rules Assembly

   Public Event PropertyChanged As PropertyChangedEventHandler Implements INotifyPropertyChanged.PropertyChanged

   Public Sub NotifyPropertyChanged(propName As String)
      RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs(propName))
   End Sub
End Class