Nicola Pievani
31a338b625
-> miglioramento gestione riferimenti componenti su assemblato, -> nuovo bottone per generare le componenti sul telaio, -> rimossa l'immagine di modifica.
2893 lines
129 KiB
VB.net
2893 lines
129 KiB
VB.net
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 Shared FirstReadingWeight 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
|
|
|
|
#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 "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_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()
|
|
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
|
|
NotifyPropertyChanged("JambBIsChecked")
|
|
Map.refAssemblyManagerVM.CurrProject.SelAssemblyName.IsModified = True
|
|
HingeRabbetJamb()
|
|
BottomRabbetJamb()
|
|
End Set
|
|
End Property
|
|
Public Sub SetExterior(bExterior As Boolean)
|
|
m_Exterior = bExterior
|
|
NotifyPropertyChanged("Exterior")
|
|
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
|
|
If Not IsNothing(m_Door1) Then
|
|
Dim nLU As Double = 0
|
|
Dim nLB As Double = 0
|
|
Dim nTH As Double = 0
|
|
Dim nJH As Double = 0
|
|
Dim nDO_1H As Double = 0
|
|
StringToDouble(LightUp, nLU)
|
|
StringToDouble(LightBottom, nLB)
|
|
StringToDouble(ThicknessHead, nTH)
|
|
StringToDouble(Width, nJH)
|
|
StringToDouble(m_Door1.Height, nDO_1H)
|
|
m_AssemblyHeight = DoubleToString(nLU + nLB + nTH + nDO_1H, 4)
|
|
If Exterior Then
|
|
Dim nOLT As Double
|
|
StringToDouble(OverlapTop, nOLT)
|
|
m_AssemblyHeight = DoubleToString(nLU + nLB + nTH + nJH + nDO_1H - nOLT, 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 IsNothing(Map.refAssemblyManagerVM.ReserchPartDoor("FT_")) AndAlso
|
|
Not IsNothing(Map.refAssemblyManagerVM.ReserchPartDoor("FT_").Door.Width) Then
|
|
Dim nFTW As Double = 0
|
|
StringToDouble(Map.refAssemblyManagerVM.ReserchPartDoor("FT_").Door.Width, nFTW)
|
|
Dim nJW As Double = 0
|
|
StringToDouble(Width, nJW)
|
|
Dim nOLL As Double
|
|
StringToDouble(OverlapLock, nOLL)
|
|
Dim nOLH As Double
|
|
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
|
|
|
|
#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 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"
|
|
|
|
Public Enum ResultReadingAssembInfo
|
|
MissingAssembInfo
|
|
ErrorInAssembInfo
|
|
CorrectAssembInfo
|
|
End Enum
|
|
|
|
Public bOk As ResultReadingAssembInfo = ResultReadingAssembInfo.CorrectAssembInfo
|
|
|
|
Private FileContent() As String
|
|
Shared Sub ReadDDFAssembly(sPathDDF As String, ByRef ReadAssembly As Assembly)
|
|
BuiltReffCompo = False
|
|
' restituisce un problema nella lettura di un valore della compo
|
|
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
|
|
MessageBox.Show(EgtMsg(50107), EgtMsg(50101), MessageBoxButton.OK, MessageBoxImage.Error)
|
|
End If
|
|
'---------------------------------------------------------------------------------------------------------------------------------
|
|
' leggo riga per riga
|
|
Dim IndexLine As Integer = 0
|
|
Map.refAssemblyManagerVM.LoadAssemblyInformation(ReadAssembly)
|
|
ReadAssembly.bOk = ReadAssembly.GetGeneralAssembly(IndexLine, sErrorInfo)
|
|
'---------------------------------------------------------------------------------------------------------------------------------
|
|
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
|
|
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
|
|
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
|
|
|
|
Private Function GetGeneralAssembly(ByRef IndexLine As Integer, sErrorInfo As String) As ResultReadingAssembInfo
|
|
IndexLine = SkipWhiteSpace(IndexLine)
|
|
' Size
|
|
If IndexLine < FileContent.Count - 1 Then
|
|
If SearchKey(FileContent(IndexLine), ConstIni.S_SIZE_INI) Then
|
|
IndexLine = GetSize(IndexLine + 1)
|
|
If IndexLine = -1 Then
|
|
sErrorInfo += String.Format(EgtMsg(50102), ConstIni.S_SIZE_INI + vbCrLf)
|
|
Return ResultReadingAssembInfo.ErrorInAssembInfo
|
|
End If
|
|
End If
|
|
End If
|
|
If IndexLine = 0 Then Return ResultReadingAssembInfo.MissingAssembInfo
|
|
IndexLine = SkipWhiteSpace(IndexLine)
|
|
' Light
|
|
If IndexLine < FileContent.Count - 1 Then
|
|
If SearchKey(FileContent(IndexLine), ConstIni.S_LIGHT) Then
|
|
IndexLine = GetLight(IndexLine + 1)
|
|
If IndexLine = -1 Then
|
|
sErrorInfo += String.Format(EgtMsg(50102), ConstIni.S_LIGHT + vbCrLf)
|
|
Return ResultReadingAssembInfo.ErrorInAssembInfo
|
|
End If
|
|
End If
|
|
End If
|
|
IndexLine = SkipWhiteSpace(IndexLine)
|
|
' Overlap
|
|
If IndexLine < FileContent.Count - 1 Then
|
|
If SearchKey(FileContent(IndexLine), ConstIni.S_OVERLAP) Then
|
|
IndexLine = GetOverlap(IndexLine + 1)
|
|
If IndexLine = -1 Then
|
|
sErrorInfo += String.Format(EgtMsg(50102), ConstIni.S_OVERLAP + vbCrLf)
|
|
Return ResultReadingAssembInfo.ErrorInAssembInfo
|
|
End If
|
|
End If
|
|
End If
|
|
IndexLine = SkipWhiteSpace(IndexLine)
|
|
' Exterior
|
|
If IndexLine < FileContent.Count - 1 Then
|
|
If SearchKey(FileContent(IndexLine), ConstIni.K_EXTERIOR) Then
|
|
IndexLine = GetExterior(IndexLine + 1)
|
|
If IndexLine = -1 Then
|
|
sErrorInfo += String.Format(EgtMsg(50102), ConstIni.K_EXTERIOR + vbCrLf)
|
|
Return ResultReadingAssembInfo.ErrorInAssembInfo
|
|
End If
|
|
End If
|
|
End If
|
|
IndexLine = SkipWhiteSpace(IndexLine)
|
|
' Profiles
|
|
If IndexLine < FileContent.Count - 1 Then
|
|
If SearchKey(FileContent(IndexLine), ConstIni.S_PROFILES) Then
|
|
IndexLine = GetProfiles(IndexLine + 1)
|
|
If IndexLine = -1 Then
|
|
sErrorInfo += String.Format(EgtMsg(50102), ConstIni.S_PROFILES + vbCrLf)
|
|
Return ResultReadingAssembInfo.ErrorInAssembInfo
|
|
End If
|
|
End If
|
|
End If
|
|
IndexLine = SkipWhiteSpace(IndexLine)
|
|
' Doors
|
|
If IndexLine < FileContent.Count Then
|
|
If SearchKey(FileContent(IndexLine), ConstIni.S_DOORS_ASSEMBY) Then
|
|
' in questo modo non passo dalla proprietà ( in breve quello che accadrebbe usando il metodo Set)
|
|
IndexLine = GetValue(IndexLine, ConstIni.S_DOORS_ASSEMBY, m_DoorNumber)
|
|
SetDoorNumber(m_DoorNumber)
|
|
If IndexLine = -1 Then
|
|
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_OverlapTop = OptionModule.m_OverlapTop
|
|
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) 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
|
|
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
|
|
|
|
' 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
|
|
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
|
|
m_Exterior = True
|
|
If Index = -1 Then Return -1
|
|
Index = GetValue(Index, K_TOP, m_OverlapTop)
|
|
'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)
|
|
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)
|
|
If IsNothing(Local_Door) Then Return -1
|
|
If String.IsNullOrEmpty(Local_Door.TypePart) Then Local_Door.TypePart = ConstGen.PART_DO_ & "1"
|
|
Dim sDoorPiece As String = Local_Door.TypePart
|
|
|
|
' per eliminare lo swing associato al jamb FL_L --> FL_
|
|
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
|
|
sErrorInfo = "The current ddf is an Assembly. Any modify will be saved as single door."
|
|
Continue While
|
|
End If
|
|
Local_Door.IsActive = True
|
|
Local_PartDoor.Door = Local_Door
|
|
Local_PartDoor.Door.SwingTypeList = OptionModule.m_SwingTypeList
|
|
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
|
|
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
|
|
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
|
|
ListPartDoor.Add(Local_PartDoor)
|
|
'm_LeftJamb = Local_Door
|
|
Case ConstGen.PART_FRAME_RIGHT
|
|
Local_PartDoor.Door = Local_Door
|
|
Local_Door.SwingTypeList = m_SwingTypeList
|
|
ListPartDoor.Add(Local_PartDoor)
|
|
'm_RightJamb = Local_Door
|
|
Case ConstGen.PART_FRAME_TOP
|
|
Local_PartDoor.Door = Local_Door
|
|
Local_Door.SwingTypeList = m_SwingTypeList
|
|
ListPartDoor.Add(Local_PartDoor)
|
|
'm_TopJamb = Local_Door
|
|
Case ConstGen.PART_FRAME_BOTTOM
|
|
Local_PartDoor.Door = Local_Door
|
|
Local_Door.SwingTypeList = m_SwingTypeList
|
|
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()
|
|
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 ddf does not contains jambs!
|
|
ErrorMessages = EgtMsg(50516)
|
|
Dim sVal As String = Utility.DoubleToString(ListPartDoor.Count, 0)
|
|
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
|
|
|
|
#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
|
|
'For IndexDoor As Integer = 0 To CInt(DoorNumber) - 1
|
|
' ResearchMatchJamb(GetArrayPartDoor(IndexDoor).Door, Map.refAssemblyPageVM.CurrAssembly.LeftJamb)
|
|
' ResearchMatchJamb(GetArrayPartDoor(IndexDoor).Door, Map.refAssemblyPageVM.CurrAssembly.RightJamb)
|
|
' ResearchMatchJamb(GetArrayPartDoor(IndexDoor).Door, Map.refAssemblyPageVM.CurrAssembly.TopJamb)
|
|
' ResearchMatchJamb(GetArrayPartDoor(IndexDoor).Door, Map.refAssemblyPageVM.CurrAssembly.BottomJamb)
|
|
'Next
|
|
'If CInt(DoorNumber) > 1 Then
|
|
' ResearchMatchDoor(GetArrayPartDoor(0).Door, GetArrayPartDoor(1).Door)
|
|
' ResearchMatchDoor(GetArrayPartDoor(1).Door, GetArrayPartDoor(0).Door)
|
|
'End If
|
|
End Sub
|
|
|
|
Private Sub ResearchMatchJamb(Door As Part, Jamb As Part)
|
|
For IndexCompo As Integer = 0 To Door.CompoList.Count - 1
|
|
If Not String.IsNullOrEmpty(Door.CompoList(IndexCompo).IdCode) Then
|
|
' cerco l'associazione delle compo
|
|
For IndexCompoJamb As Integer = 0 To Jamb.CompoList.Count - 1
|
|
If Jamb.CompoList(IndexCompoJamb).IdCode = Door.CompoList(IndexCompo).IdCode Then
|
|
Door.CompoList(IndexCompo).refJambCompo = Jamb.CompoList(IndexCompoJamb)
|
|
Door.CompoList(IndexCompo).refJambCompo.IsReadOnly = False
|
|
Door.CompoList(IndexCompo).IsReadOnly = True
|
|
|
|
If Not LoadCompoParam(Door.CompoList(IndexCompo), Door.TypePart) Then Return
|
|
|
|
For IndexParam As Integer = 0 To Door.CompoList(IndexCompo).refJambCompo.CompoParamList.Count - 1
|
|
Dim CmpPar As CompoParam = Door.CompoList(IndexCompo).CompoParamList(IndexParam)
|
|
Dim CmpRefPar As CompoParam = Door.CompoList(IndexCompo).refJambCompo.CompoParamList(IndexParam)
|
|
If 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
|
|
ElseIf 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
|
|
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
|
|
End If
|
|
Next
|
|
ResetCompoParam()
|
|
Exit For
|
|
End If
|
|
Next
|
|
Else
|
|
Door.CompoList(IndexCompo).IsReadOnly = True
|
|
End If
|
|
Next
|
|
End Sub
|
|
|
|
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
|
|
If DoorInactive.CompoList(IndexCompoInactiveDoor).IdCode = DoorActive.CompoList(IndexCompo).IdCode Then
|
|
DoorActive.CompoList(IndexCompo).refJambCompo = DoorInactive.CompoList(IndexCompoInactiveDoor)
|
|
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 DoorActive.CompoList(IndexCompo).refJambCompo.CompoParamList.Count - 1
|
|
Dim CmpPar As CompoParam = DoorActive.CompoList(IndexCompo).CompoParamList(IndexParam)
|
|
Dim CmpRefPar As CompoParam = DoorActive.CompoList(IndexCompo).refJambCompo.CompoParamList(IndexParam)
|
|
If 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
|
|
ElseIf 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
|
|
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
|
|
End If
|
|
Next
|
|
ResetCompoParam()
|
|
Exit For
|
|
End If
|
|
Next
|
|
Else
|
|
DoorActive.CompoList(IndexCompo).IsReadOnly = True
|
|
End If
|
|
Next
|
|
End If
|
|
|
|
End Sub
|
|
|
|
#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, Optional sSide As String = "") As Boolean
|
|
' se è la configurazione è di songola porta allora interrompi la costruzione
|
|
If OptionModule.m_ConfigurationSoftware = ConfigType.Door Then Return False
|
|
' nome del file da caricare da tabella Matchting.ini
|
|
Dim FrameFile As String = String.Empty
|
|
' percorso del file di configurazione del file caricato da tabella (da costruire)
|
|
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
|
|
' se non è stato passato nessun termine che specfica il lato allora lo cerco nella configurazione
|
|
If String.IsNullOrEmpty(Side) Then GetPrivateProfileJambSide(S_POSITIONSIDE, K_SIDE, Side, CurrCompo.CompoType.Path & "\" & CONFIGINI_FILE_NAME)
|
|
If String.IsNullOrEmpty(Side) Then
|
|
' controllo 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
|
|
Exit For
|
|
End If
|
|
Next
|
|
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(Map.refPartPageVM.CurrPart) Then Return False
|
|
Dim nSide As Integer = 0
|
|
Select Case Side
|
|
Case "Lock"
|
|
' se è LeftHand
|
|
If Map.refPartPageVM.CurrPart.SwingAlias.Name.Contains("L") Then
|
|
nSide = 100
|
|
Else
|
|
nSide = 300
|
|
End If
|
|
Case "Hinge"
|
|
If Map.refPartPageVM.CurrPart.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 Corrente
|
|
Dim refPartDoor As PartDoor = Nothing
|
|
' ricerco il PartDoor Corrente
|
|
For Each ItemPartDoor In ListPartDoor
|
|
If ItemPartDoor.Type = Map.refPartPageVM.CurrPart.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
|
|
End If
|
|
Next
|
|
Exit For
|
|
End If
|
|
Next
|
|
' se non è stata trovata nessuna associazione esco
|
|
If IsNothing(refPartDoor) Then Return False
|
|
|
|
' verifico che il nome non sia scritto direttamente nel file lua
|
|
Dim CurrDoorHArdwareFile As String = CurrCompo.CompoType.Path & "\" & CurrCompo.TemplateSelItem
|
|
If Path.GetExtension(CurrDoorHArdwareFile) <> NGE_EXTENSION Then
|
|
CurrDoorHArdwareFile &= LUA_EXTENSION
|
|
End If
|
|
If File.Exists(CurrDoorHArdwareFile) Then
|
|
Dim ReadCurrCompo() As String = File.ReadAllLines(CurrDoorHArdwareFile)
|
|
For LineIndex = 0 To ReadCurrCompo.Count - 1
|
|
' cerco il titolo [Match File]: se lo trovo
|
|
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
|
|
' quando termino il ciclo while posso uscire anche dal for
|
|
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
|
|
Map.refPartPageVM.CurrPart.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)
|
|
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
|
|
Map.refPartPageVM.CurrPart.RemoveCompo(CurrCompo, True)
|
|
CurrCompo.refJambCompo = Nothing
|
|
End If
|
|
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
|
|
Map.refPartPageVM.CurrPart.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)
|
|
|
|
' se non esiste una componente di riferiento, allora deve essere creata per la prima volta
|
|
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)
|
|
CurrCompo.refJambCompo = refPartDoor.Door.AddNewCompo(refCompoType, True)
|
|
CurrCompo.refJambCompo.refCompoDoor = CurrCompo
|
|
End If
|
|
' setto il nome della componente da caricare
|
|
If Not IsNothing(CurrCompo.refJambCompo) Then
|
|
CurrCompo.refJambCompo.SplitBrandFile(FrameFile)
|
|
Else
|
|
MessageBox.Show("File '" & FrameFile & "' exist, but it is not in the correct Directory!", EgtMsg(50144), MessageBoxButton.OK, MessageBoxImage.Warning)
|
|
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, Map.refPartPageVM.CurrPart.TypePart) Then
|
|
UpDateCurrCompoJamb(CurrCompo, Map.refPartPageVM.CurrPart.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
|
|
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()
|
|
' 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()
|
|
TopBottomWidth()
|
|
HeightDoor()
|
|
TopRabbetJamb()
|
|
HingeRabbetJamb()
|
|
BottomRabbetJamb()
|
|
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()
|
|
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"
|
|
|
|
Public Sub CreateAssembly()
|
|
If ListPartDoorOfDoor.Count < 1 Then Return
|
|
'If Not JambExists Then SetDimension("JambIsCheked")
|
|
Select Case ListPartDoorOfDoor.Count
|
|
Case 1
|
|
Dim IndexCompo As Integer = 0
|
|
Dim EndIndex As Integer = m_Door1.CompoList.Count
|
|
For IndexCompo = 0 To EndIndex - 1
|
|
CreateCompoOnJamb(m_Door1.CompoList(IndexCompo))
|
|
Next
|
|
Case 2
|
|
|
|
Case Else
|
|
|
|
End Select
|
|
End Sub
|
|
|
|
' è 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
|
|
|
|
' Ricevuta la componente Compo aggiorna la refCompo
|
|
Public Sub UpDateCurrCompoJamb(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 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
|
|
DirectCast(CurrCompo.refJambCompo.CompoParamList(IndexParam), ComboBoxParam).IsReadOnly = False
|
|
ElseIf 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)
|
|
End If
|
|
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 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)
|
|
TBoxNewPar.Value = TBoxPar.Value
|
|
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)
|
|
CBoxNewPar.SelItem = CBoxNewPar.ItemList(CBoxNewPar.ItemList.IndexOf(CBoxPar.SelItem))
|
|
ElseIf 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)
|
|
TBoxNewPar.Value = TBoxPar.Value
|
|
TBoxNewPar.IsActive = TBoxPar.IsActive
|
|
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)
|
|
CBoxNewPar.SelItem = CBoxNewPar.ItemList(CBoxPar.ItemList.IndexOf(CBoxPar.SelItem))
|
|
CBoxNewPar.IsActive = CBoxPar.IsActive
|
|
End If
|
|
Next
|
|
End Sub
|
|
|
|
#End Region ' UpDateRefCompo
|
|
|
|
#Region "HEIGHT"
|
|
|
|
' calcola l'altezza dei JambLeft e JambRight
|
|
Public Sub HeightJamb()
|
|
' 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 dThichknessJamb As Double
|
|
StringToDouble(LightUp, dLightUp)
|
|
StringToDouble(LightBottom, dLightBottom)
|
|
StringToDouble(ThicknessHead, dThicknessHead)
|
|
' la modifica dell'altezza può arrivare solo da un'anta
|
|
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
|
|
StringToDouble(OverlapTop, dOverlapTop)
|
|
StringToDouble(Width, dThichknessJamb)
|
|
Dim HJamb As Double = dLightBottom + dHeight + dLightUp + dThicknessHead
|
|
Dim HJambExterior As Double = HJamb + dThichknessJamb - dOverlapTop
|
|
' 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()
|
|
Dim HeightDoor As String = String.Empty
|
|
Dim nTH As Double = 0
|
|
Dim nTJ As Double = 0
|
|
Dim nLU As Double = 0
|
|
Dim nLB As Double = 0
|
|
Dim nOLT As Double = 0
|
|
StringToDouble(m_LightUp, nLU)
|
|
StringToDouble(m_LightBottom, nLB)
|
|
StringToDouble(m_ThicknessHead, nTH)
|
|
StringToDouble(m_OverlapTop, nOLT)
|
|
StringToDouble(m_Width, nTJ)
|
|
|
|
' carico il valore che è stato modificato
|
|
If 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 - nTJ
|
|
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 nTJ As Double = 0
|
|
Dim nLU As Double = 0
|
|
Dim nLB As Double = 0
|
|
Dim nOLT 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_Width, nTJ)
|
|
|
|
If Not IsNothing(m_JambT) Then
|
|
m_JambT.SetHeight(ThicknessHead)
|
|
End If
|
|
|
|
If IsNothing(m_Door1) Then Return
|
|
StringToDouble(m_Door1.Height, nHD)
|
|
If Not Dimension Then Return
|
|
|
|
Dim nTotalHeight As Double = 0
|
|
StringToDouble(AssemblyHeight, nTotalHeight)
|
|
|
|
If nTotalHeight < nTH Then
|
|
nTH = nTotalHeight - (nLU + nLB) - nHD
|
|
If Exterior Then
|
|
nTH = nTH + nOLT - nTJ
|
|
End If
|
|
ThicknessHead = DoubleToString(nTH, 4)
|
|
Else
|
|
nHD = nTotalHeight - (nLU + nLB) - nTH
|
|
If Exterior Then
|
|
nHeightDoor = nHD + nOLT - nTJ
|
|
End If
|
|
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
|
|
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(m_Door1.Width, dWidth1)
|
|
|
|
Select Case m_DoorNumber
|
|
Case "1"
|
|
If Exterior Then
|
|
dActualWidth = dLightHinge + dLightLock
|
|
If Not IsNothing(m_JambB) Then m_JambB.SetWidth(DoubleToString(dWidth1 + dActualWidth, 4))
|
|
Else
|
|
dActualWidth = dLightHinge + dLightLock + dOverlapLock + dOverlapHinge
|
|
End If
|
|
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
|
|
If Exterior Then
|
|
dActualWidth = dLightHinge + dLightHinge + dLightLock + dWidth1
|
|
If Not IsNothing(m_JambB) Then m_JambB.SetWidth(DoubleToString(dWidth2 + dActualWidth, 4))
|
|
Else
|
|
dActualWidth = dLightHinge + dLightHinge + dLightLock + dOverlapHinge + dOverlapHinge + dWidth1
|
|
End If
|
|
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.Width = m_Width
|
|
If Not IsNothing(m_JambL) Then m_JambL.Width = 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(DO_1) Then
|
|
Dim nDO_1Width As Double = 0
|
|
Dim nDO_2Width As Double = 0
|
|
StringToDouble(DO_1.Door.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(DO_2) Then
|
|
' la seconda anta viene ricalcolata mantenedo fissa la dimensione della prima
|
|
StringToDouble(DO_2.Door.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
|
|
DO_2.Door.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
|
|
DO_1.Door.SetWidth(DoubleToString(nDO_1Width, 4))
|
|
End If
|
|
End If
|
|
|
|
'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 m_JambB.Thickness = m_Thickness
|
|
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
|
|
|
|
' 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 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"
|
|
|
|
' 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
|
|
For Index As Integer = 0 To Map.refCompoPanelVM.CompoTypeList.Count - 1
|
|
If Trim(Map.refCompoPanelVM.CompoTypeList(Index).DDFName) = "rabbet" Then
|
|
IndexCompoPanel = Index
|
|
Exit For
|
|
End If
|
|
Next
|
|
' 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 esistenon 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
|
|
CurrCompo = Jamb.CompoList(IndexCompo)
|
|
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)
|
|
Else
|
|
CurrCompo = Jamb.CompoList(IndexCompo)
|
|
End If
|
|
' mofico la componete rabbet
|
|
If Not IsNothing(CurrCompo) Then SetTopRabbetParam(sThicknessHead, sOverlap, CurrCompo, sLightUp)
|
|
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 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 IndexBottom As Integer = 1
|
|
Select Case DoorNumber
|
|
Case "1"
|
|
If Not m_JambL.SwingAlias.Name.Contains(ConstGen.LOCK) Then
|
|
RabbetExterior(m_JambL, sThicknessDoor, sWidthJamb, sOverLapLock, IndexBottom)
|
|
RabbetExterior(m_JambR, sThicknessDoor, sWidthJamb, sOverLapHinge, IndexBottom)
|
|
Else
|
|
RabbetExterior(m_JambL, sThicknessDoor, sWidthJamb, sOverLapHinge, IndexBottom)
|
|
RabbetExterior(m_JambR, sThicknessDoor, sWidthJamb, sOverLapLock, IndexBottom)
|
|
End If
|
|
Case "2"
|
|
RabbetExterior(m_JambL, sThicknessDoor, sWidthJamb, sOverLapHinge, IndexBottom)
|
|
RabbetExterior(m_JambR, sThicknessDoor, sWidthJamb, sOverLapHinge, IndexBottom)
|
|
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
|
|
' questo flag, che è poi passato alla funzione RabbetExterior, ha lo scopo di identificare chi sta esegunedo la chiamata
|
|
Dim IndexHinge As Integer = 2
|
|
Select Case DoorNumber
|
|
Case "1"
|
|
If Not m_JambL.SwingAlias.Name.Contains(ConstGen.LOCK) Then
|
|
RabbetExterior(m_JambL, sThicknessDoor, sDeltaT, sOverLapLock, IndexHinge)
|
|
RabbetExterior(m_JambR, sThicknessDoor, sDeltaT, sOverLapHinge, IndexHinge)
|
|
RabbetExterior(m_JambT, sThicknessDoor, sDeltaT, sOverLapTop, IndexHinge)
|
|
Else
|
|
RabbetExterior(m_JambL, sThicknessDoor, sDeltaT, sOverLapHinge, IndexHinge)
|
|
RabbetExterior(m_JambR, sThicknessDoor, sDeltaT, sOverLapLock, IndexHinge)
|
|
RabbetExterior(m_JambT, sThicknessDoor, sDeltaT, sOverLapTop, IndexHinge)
|
|
End If
|
|
Case "2"
|
|
RabbetExterior(m_JambL, sThicknessDoor, sDeltaT, sOverLapHinge, IndexHinge)
|
|
RabbetExterior(m_JambR, sThicknessDoor, sDeltaT, sOverLapHinge, IndexHinge)
|
|
RabbetExterior(m_JambT, sThicknessDoor, sDeltaT, sOverLapTop, IndexHinge)
|
|
End Select
|
|
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 = Map.refCompoPanelVM.CompoTypeList.Count - 1
|
|
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 SetHingeRabbetParam(sThicknessDoor, sDeltaT, sOverLap, Local_Compo, nIndexSide)
|
|
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
|
|
TextParam.m_Value = DoubleToString(dDeltaT + dThicknessDoor, 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
|
|
' 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
|
|
CurrCompoParam = CurrCompo.CompoParamList(1)
|
|
' width
|
|
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
|
|
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
|