Imports EgtWPFLib5
Imports EgtUILib
Imports OmagOFFICE.ChangeTableVM

Public Class NestingTabVM
   Inherits VMBase

#Region "FIELDS & PROPERTIES"

   ' Flag per pezzi selezionati in tavola o fuori
   Private m_nPartPos As Integer = PART_POS.NONE_TABLE
   Enum PART_POS As Integer
      IN_TABLE = -1
      NONE_TABLE = 0
      OUT_TABLE = 1
   End Enum
   ' Identificativi per pezzo da selezionare/deselezionare
   Private m_nIdToSel As Integer = GDB_ID.NULL
   Private m_nIdToDesel As Integer = GDB_ID.NULL
   ' Dati del grezzo
   Private m_dMinDist As Double = 0
   ' Dati movimento
   Private m_dMaxStep As Double = 0
   ' Dati per Drag
   Private m_nRestRadius As Integer = 3
   Private m_bDrag As Boolean = False
   Private m_bDragToStart As Boolean = False
   Private m_bVerify As Boolean = False
   Private m_bFromParking As Boolean = False
   Private m_bDragging As Boolean = False
   Private m_locPrev As System.Drawing.Point
   Private m_ptPrev As Point3d
   Private m_vtTotMove As Vector3d
   Private m_dSnapDist As Double = 0
   ' Gestione rotazione pezzi in fase di Drag
   Private m_bKeyCtrlPressed As Boolean = False
   Private m_bKeyLeftShiftPressed As Boolean = False
   Private m_dAngTotal As Double = 0
   Private m_dStartAng As Double = 0
   Private m_bStartRot As Boolean = False
   Private m_bStartMove As Boolean = False
   ' Abilitazioni TrfData e CsvData
   Private m_bTrfData As Boolean = False
   Private m_bCsvData As Boolean = False

   ' Id del rettangolo, del traglio e della curva da modificare tramite Drag
   Private m_nIdSelectedOutLoopRectangle As Integer = GDB_ID.NULL
   Private m_nIdSelectedRegionRectangle As Integer = GDB_ID.NULL
   Private m_nIdSelectedSawRectangle As Integer = GDB_ID.NULL
   Private m_nIdSelectedCurvRectangle As Integer = GDB_ID.NULL
   Private m_nIdSelectedTextRectangle As Integer = GDB_ID.NULL
   Private m_nIdSelectedTextTopRectangle As Integer = GDB_ID.NULL
   Private m_nIdSelectedFlatSurfRectangle As Integer = GDB_ID.NULL
   Private m_SideListRectangle(4) As Integer
   Private m_sTextContent As String = String.Empty

   ' Id dei lato WJ da separare tramite comando ON_OFF
   Private m_nIdSelectedSideWJ As Integer = GDB_ID.NULL
   Private m_nIdSelectedWaterJet As Integer = GDB_ID.NULL

   Private m_CsvImportWindow As CsvWindowV
   Friend ReadOnly Property CsvImportWindow As CsvWindowV
      Get
         Return m_CsvImportWindow
      End Get
   End Property

   Private m_CsvImport_IsChecked As Boolean
   Public Property CsvImport_IsChecked As Boolean
      Get
         Return m_CsvImport_IsChecked
      End Get
      Set(value As Boolean)
         If value <> m_CsvImport_IsChecked Then
            m_CsvImport_IsChecked = value
            If m_CsvImport_IsChecked Then
               m_CsvImportWindow = New CsvWindowV(Application.Current.MainWindow, New CsvWindowVM)
               m_CsvImportWindow.Show()
            Else
               m_CsvImportWindow.Close()
               m_CsvImportWindow = Nothing
            End If
            NotifyPropertyChanged("CsvImport_IsChecked")
         End If
      End Set
   End Property

   Private m_MaxMoveIsChecked As Boolean
   Public Property MaxMoveIsChecked As Boolean
      Get
         Return m_MaxMoveIsChecked
      End Get
      Set(value As Boolean)
         If value <> m_MaxMoveIsChecked Then
            m_MaxMoveIsChecked = value
            NotifyPropertyChanged("MaxMoveIsChecked")
         End If
      End Set
   End Property

   Private m_dStepMove As Double
   Public Property StepMove As String
      Get
         Return LenToString(m_dStepMove, 2)
      End Get
      Set(value As String)
         Dim dValue As Double
         'StringToLen(value, m_dStepMove)
         If StringToLen(value, dValue) Then
            If dValue < 0 Then
               dValue = 0
            ElseIf dValue > 1000 Then
               dValue = 1000
            End If
            m_dStepMove = dValue
            WriteMainPrivateProfileString(S_NEST, K_STEP, DoubleToString(m_dStepMove, 2))
         End If
         NotifyPropertyChanged("StepMove")
      End Set
   End Property

   Private m_dRotationAngle As Double
   Public Property RotationAngle As String
      Get
         Return DoubleToString(m_dRotationAngle, 2)
      End Get
      Set(value As String)
         Dim dValue As Double
         If StringToDouble(value, dValue) Then
            If dValue < 0 Then
               dValue = 0
            ElseIf dValue > 180 Then
               dValue = 180
            End If
            m_dRotationAngle = dValue
            WriteMainPrivateProfileString(S_NEST, K_ANGSTEP, DoubleToString(m_dRotationAngle, 2))
         End If
         NotifyPropertyChanged("RotationAngle")
      End Set
   End Property

   Private m_bMagnetic As Boolean
   Public Property MagneticIsChecked As Boolean
      Get
         Return m_bMagnetic
      End Get
      Set(value As Boolean)
         If value <> m_bMagnetic Then
            m_bMagnetic = value
            NotifyPropertyChanged("MagneticIsChecked")
         End If
      End Set
   End Property

   Private m_CsvData_Visibility As Visibility = Visibility.Collapsed
   Public Property CsvData_Visibility As Visibility
      Get
         Return m_CsvData_Visibility
      End Get
      Set(value As Visibility)
         m_CsvData_Visibility = value
         NotifyPropertyChanged("CsvData_Visibility")
      End Set
   End Property

   Private m_CountColumn As Integer = 2
   Public ReadOnly Property CountColumn As Integer
      Get
         Return m_CountColumn
      End Get
   End Property

   Private m_bManageParts_IsExpanded As Boolean = True
   Public Property bManageParts_IsExpanded As Boolean
      Get
         Return m_bManageParts_IsExpanded
      End Get
      Set(value As Boolean)
         m_bManageParts_IsExpanded = value
         NotifyPropertyChanged(NameOf(bManageParts_IsExpanded))
         WriteMainPrivateProfileString("Nest", "ManageParts", If(m_bManageParts_IsExpanded, "1", "0"))
      End Set
   End Property

   Private m_bSelectionParts_IsExpanded As Boolean = True
   Public Property bSelectionParts_IsExpanded As Boolean
      Get
         Return m_bSelectionParts_IsExpanded
      End Get
      Set(value As Boolean)
         m_bSelectionParts_IsExpanded = value
         NotifyPropertyChanged(NameOf(bSelectionParts_IsExpanded))
         WriteMainPrivateProfileString("Nest", "SelectionParts", If(m_bSelectionParts_IsExpanded, "1", "0"))
      End Set
   End Property

   Private m_bManageWJ_IsExpanded As Boolean = True
   Public Property bManageWJ_IsExpanded As Boolean
      Get
         Return m_bManageWJ_IsExpanded
      End Get
      Set(value As Boolean)
         m_bManageWJ_IsExpanded = value
         NotifyPropertyChanged(NameOf(bManageWJ_IsExpanded))
         WriteMainPrivateProfileString("Nest", "ManageWJ", If(m_bManageWJ_IsExpanded, "1", "0"))
      End Set
   End Property

#Region "Messages"

   Public ReadOnly Property InsertPartMsg As String
      Get
         Return EgtMsg(MSG_NESTPAGEUC + 1)
      End Get
   End Property

   Public ReadOnly Property StorePartMsg As String
      Get
         Return EgtMsg(MSG_NESTPAGEUC + 2)
      End Get
   End Property

   Public ReadOnly Property RemovePartMsg As String
      Get
         Return EgtMsg(MSG_NESTPAGEUC + 3)
      End Get
   End Property

   Public ReadOnly Property DragRectangleMsg As String
      Get
         Return EgtMsg(91670)
      End Get
   End Property

   Public ReadOnly Property SplitCurvWJMsg As String
      Get
         '91133=Separa
         Return EgtMsg(91133)
      End Get
   End Property

   Public ReadOnly Property StartCurvWJMsg As String
      Get
         '91132=Start
         Return EgtMsg(91132)
      End Get
   End Property

   Public ReadOnly Property SelectAllMsg As String
      Get
         Return EgtMsg(MSG_NESTPAGEUC + 4)
      End Get
   End Property

   Public ReadOnly Property DeselectAllMsg As String
      Get
         Return EgtMsg(MSG_NESTPAGEUC + 5)
      End Get
   End Property

   Public ReadOnly Property ResetMsg As String
      Get
         Return EgtMsg(MSG_NESTPAGEUC + 6)
      End Get
   End Property

   Public ReadOnly Property CsvDataMsg As String
      Get
         Return EgtMsg(90398)            'Dati Csv
      End Get
   End Property

   Public ReadOnly Property DrawingMsg As String
      Get
         Return EgtMsg(91657)
      End Get
   End Property

   Public ReadOnly Property ManagePartsMsg As String
      Get
         Return EgtMsg(91660)
      End Get
   End Property

   Public ReadOnly Property SelectionPartMsg As String
      Get
         Return EgtMsg(91661)
      End Get
   End Property

   Public ReadOnly Property ManageWJMsg As String
      Get
         Return EgtMsg(91662)
      End Get
   End Property

#End Region    ' Messages

#Region "ToolTip"

   Public ReadOnly Property ParametricToolTip As String
      Get
         Return EgtMsg(91657)
      End Get
   End Property

   Public ReadOnly Property ImportDrawToolTip As String
      Get
         Return EgtMsg(91658)
      End Get
   End Property

   Public ReadOnly Property ImportCSVToolTip As String
      Get
         Return EgtMsg(91659)
      End Get
   End Property

#End Region    ' ToolTip

   ' Definizione comandi
   Private m_cmdDraw As ICommand
   Private m_cmdImportDxf As ICommand
   Private m_cmdPartRotOn As ICommand
   Private m_cmdPartRotOff As ICommand
   Private m_cmdUp As ICommand
   Private m_cmdLeft As ICommand
   Private m_cmdRight As ICommand
   Private m_cmdDown As ICommand
   Private m_cmdCClockwiseRot As ICommand
   Private m_cmdClockwiseRot As ICommand
   Private m_cmdInsertPart As ICommand
   Private m_cmdStorePart As ICommand
   Private m_cmdRemovePart As ICommand
   Private m_cmdSelectAll As ICommand
   Private m_cmdDeselectAll As ICommand
   Private m_cmdReset As ICommand
   Private m_cmdCsvData As ICommand

#End Region    ' FIELDS & PROPERTIES

#Region "CONSTRUCTOR"

   Sub New()
      If GetMainPrivateProfileInt(S_NEST, K_DRAGRECTANGLE, 1) <> 0 Then
         m_DragRectangle_Visibility = Visibility.Visible
         m_CountColumn += 1
      Else
         m_DragRectangle_Visibility = Visibility.Collapsed
      End If
      NotifyPropertyChanged("DragRectangle_Visibility")
      NotifyPropertyChanged("CountColumn")
      ' Creo riferimento a questa classe in OmagOFFICEMap
      OmagOFFICEMap.SetRefNestingTabVM(Me)
   End Sub

#End Region    ' CONSTRUCTOR

#Region "METHODS"

   Friend Function InitNesting() As Boolean
      m_bManageParts_IsExpanded = GetMainPrivateProfileInt("Nest", "ManageParts", 0) <> 0
      NotifyPropertyChanged(NameOf(bManageParts_IsExpanded))
      m_bSelectionParts_IsExpanded = GetMainPrivateProfileInt("Nest", "SelectionParts", 0) <> 0
      NotifyPropertyChanged(NameOf(bSelectionParts_IsExpanded))
      m_bManageWJ_IsExpanded = GetMainPrivateProfileInt("Nest", "ManageWJ", 0) <> 0
      NotifyPropertyChanged(NameOf(bManageWJ_IsExpanded))
      ' Se previsto, abilito bottone VeinMatching
      If Not IsNothing(OmagOFFICEMap.refMainWindowVM.VeinMatchingWnd) Then
         OmagOFFICEMap.refVeinMatchPanelVM.VeinMatchIsEnabled = True
      End If
      ' Abilitazione TrfData
      m_bTrfData = OmagOFFICEMap.refMainWindowVM.MainWindowM.GetKeyOption(KEY_OPT.TRF_IMPORT) And
                   (GetMainPrivateProfileInt(S_COMPO, K_TRFDATA, 0) <> 0)
      ' Abilitazione CsvData
      m_bCsvData = Not m_bTrfData And
                   (GetMainPrivateProfileInt(S_COMPO, K_CSVDATA, 0) <> 0)
      ' Se previsto, abilito bottone CsvData
      CsvData_Visibility = If(m_bCsvData, Visibility.Visible, Visibility.Collapsed)
      ' Imposto il corretto contesto
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' aggiorno dati del grezzo
      EstCalc.UpdateRawPart()
      ' calcolo valore di minima distanza (da spessore lama corrente)
      Dim dSawThick As Double = 0
      If EgtTdbSetCurrTool(CurrentMachine.sCurrSaw) AndAlso
         EgtTdbGetCurrToolParam(MCH_TP.THICK, dSawThick) Then
         m_dMinDist = dSawThick
      Else
         EgtOutLog("Not found current saw for nesting mindist")
         m_dMinDist = 0
      End If
      ' carico e calcolo i parametri di movimento e drag
      m_dStepMove = GetMainPrivateProfileDouble(S_NEST, K_STEP, 10)
      NotifyPropertyChanged("StepMove")
      Dim ptRawDiag As Vector3d = GetRawPtMax() - GetRawPtMin()
      m_dMaxStep = Math.Max(ptRawDiag.x, ptRawDiag.y)
      m_dRotationAngle = GetMainPrivateProfileDouble(S_NEST, K_ANGSTEP, 15)
      NotifyPropertyChanged("RotationAngle")
      m_nRestRadius = GetMainPrivateProfileInt(S_NEST, K_RESTRADIUS, 3)
      m_dSnapDist = GetMainPrivateProfileDouble(S_NEST, K_SNAPDIST, 50)
      ' Garantisco visibilità pezzi parcheggiati
      EstCalc.ShowParkedParts()
      ' Garantisco visibilità eventuale contorno da foto
      EstPhoto.ShowContour(True)
      ' Se abilitato CSV ne visualizzo la finestra
      If m_CsvImport_IsChecked Then
         m_CsvImportWindow = New CsvWindowV(Application.Current.MainWindow, New CsvWindowVM)
         m_CsvImportWindow.Show()
      End If
      ' Per sicurezza spengo la visualizzazione di tutti i percorsi di lavorazione
      HideAllMachinings()
      EgtZoom(ZM.ALL)
      Return True
   End Function

   Private Sub StandardInsert()
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      Dim bWrongTrf As Boolean = False
      OmagOFFICEMap.refStatusBarVM.ClearOutputMessage()
      ' Ciclo di inserimento in tavola dei pezzi selezionati
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         ' Recupero successivo selezionato
         Dim nNextId = EgtGetNextSelectedObj()
         ' Se pezzo da Trf, verifico compatibilità
         If Not VerifyTrfData(nId) Then
            bWrongTrf = True
            EgtSetStatus(nId, GDB_ST.ON_)
            ' Passo al successivo selezionato
            nId = nNextId
            Continue While
         End If
         ' Lo metto in tavola, se possibile
         If EstCalc.InsertOnePart(nId, CurrentMachine.bAligned, CurrentMachine.bReducedCut) Then
            ' Eventuale notifica al VeinMatching
            VeinMatching.OnInsertPartInRaw(nId)
         Else
            VeinMatching.OnDeselectPart(nId)
         End If
         ' Costringo ad aggiornare UI
         UpdateUI()
         ' Passo al successivo selezionato
         nId = nNextId
      End While
      ' Aggiorno flag selezionati
      m_nPartPos = If(EgtGetSelectedObjCount() > 0, PART_POS.IN_TABLE, PART_POS.NONE_TABLE)
      ' Aggiorno vista
      EgtZoom(ZM.ALL)
      ' Eventuale segnalazione di pezzi Trf non adatti
      If bWrongTrf Then
         ' Pezzi con spessore, materiale o finitura non compatibili
         OmagOFFICEMap.refStatusBarVM.SetOutputMessage(EgtMsg(MSG_NESTPAGEUC + 7), MSG_TYPE.WARNING)
      End If
   End Sub

   Private Sub AutomaticInsert()
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      OmagOFFICEMap.refStatusBarVM.SetOutputMessage(EgtMsg(90340))       ' Nesting Automatico in corso
      Dim bWrongTrf As Boolean = False
      Dim vParts As New List(Of Integer)
      ' Ciclo di pre-inserimento in tavola dei pezzi selezionati
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         ' Recupero successivo selezionato
         Dim nNextId = EgtGetNextSelectedObj()
         ' Se pezzo da Trf, verifico compatibilità
         If Not VerifyTrfData(nId) Then
            bWrongTrf = True
            EgtSetStatus(nId, GDB_ST.ON_)
            ' Passo al successivo selezionato
            nId = nNextId
            Continue While
         End If
         ' Lo preparo in tavola, se possibile
         If PreInsertOnePart(nId) Then
            vParts.Add(nId)
         Else
            EgtSetStatus(nId, GDB_ST.ON_)
            VeinMatching.OnDeselectPart(nId)
         End If
         ' Costringo ad aggiornare UI
         UpdateUI()
         ' Passo al successivo selezionato
         nId = nNextId
      End While
      ' Aggiorno le regioni per il nesting
      UpdateNestRegions()
      Dim bAligned As Boolean = (GetPrivateProfileInt(S_MACH_NEST, K_MACH_NEST_ALIGNED, 0, CurrentMachine.sMachIniFile) <> 0)
      EnableReferenceRegion(bAligned)
      ' Eseguo nesting automatico
      Dim bOpimizeOnX As Boolean = (GetMainPrivateProfileInt(S_NEST, K_AUTOMATICOPTIMIZE, 2) = 1)
      Dim bGuillotineMode As Boolean = bAligned
      Dim nAutomaticMaxTime As Integer = GetMainPrivateProfileInt(S_NEST, K_AUTOMATICMAXTIME, 20)
      Dim dPartTime As Double = If(bGuillotineMode, 1.0, 0.5)
      Dim nMaxTime As Integer = Math.Min(CInt(2 + dPartTime * vParts.Count()), nAutomaticMaxTime)
      EgtAutomaticPackParts(vParts, bOpimizeOnX, CurrentMachine.bReducedCut, bGuillotineMode, nMaxTime)
      ' Sistemo i pezzi
      For Each nPartId As Integer In vParts
         ' se pezzo inserito
         If nPartId > 0 Then
            VeinMatching.OnInsertPartInRaw(nPartId)
            ' Eventuale aggiunta solido per taglio da sotto
            UpdateSolidForDrip(nPartId)
            ' altrimenti rifiutato
         Else
            ' Ripristino lo stato originale
            PreRemoveOnePart(Math.Abs(nPartId))
            VeinMatching.OnDeselectPart(Math.Abs(nPartId))
         End If
      Next
      ' Aggiorno flag selezionati
      m_nPartPos = If(EgtGetSelectedObjCount() > 0, PART_POS.IN_TABLE, PART_POS.NONE_TABLE)
      ' Aggiorno vista
      EgtZoom(ZM.ALL)
      OmagOFFICEMap.refStatusBarVM.ClearOutputMessage()
      ' Eventuale segnalazione di pezzi Trf non adatti
      If bWrongTrf Then
         ' Pezzi con spessore, materiale o finitura non compatibili
         OmagOFFICEMap.refStatusBarVM.SetOutputMessage(EgtMsg(MSG_NESTPAGEUC + 7), MSG_TYPE.WARNING)
      End If
   End Sub

   Private Sub VerifyMove()
      If m_bVerify Then
         ' Determino cosa verificare
         Dim nMoveId = If(m_nIdToSel <> GDB_ID.NULL, m_nIdToSel, GDB_ID.SEL)
         ' Aggiorno regioni per nesting
         UpdateNestRegions()
         EnableReferenceRegion(False)
         ' Eseguo verifica
         If VerifyTrfData(nMoveId) And EgtVerifyPart(nMoveId, CurrentMachine.bReducedCut) Then
            EstCalc.ResetOrderMachiningFlag()
            ' Non superata riporto alla posizione iniziale
         Else
            If m_bFromParking Then
               OmagOFFICEMap.refStatusBarVM.ClearOutputMessage()
               PreRemoveOnePart(nMoveId)
               VeinMatching.OnRemovePartFromRaw(nMoveId)
            Else
               EgtMove(nMoveId, -m_vtTotMove)
               ' Eventuale notifica al VeinMatching
               If nMoveId = GDB_ID.SEL Then
                  Dim nId As Integer = EgtGetFirstSelectedObj()
                  While nId <> GDB_ID.NULL
                     VeinMatching.OnMovePartInRaw(nId)
                     nId = EgtGetNextSelectedObj()
                  End While
               Else
                  VeinMatching.OnMovePartInRaw(nMoveId)
               End If
            End If
            '---------------------- COUNTER PART ----------------------
            ' solo se pezzo disposto in tavola
            If m_bFromParking Then
               Dim sRefGroup As String = String.Empty
               If EgtGetInfo(nMoveId, INFO_REFGROUP, sRefGroup) Then
                  ' accendo il layer che contiene il contatore (spento in fase di Drag)
                  Dim nCounterLayer As Integer = EgtGetFirstNameInGroup(nMoveId, INFO_COUNTERLY)
                  EgtSetStatus(nCounterLayer, GDB_ST.ON_)
                  ' aggiorno il layer che indica il numero di pezzi in parcheggio
                  CountPartInFamily(sRefGroup)
               End If
            End If
            '---------------------- COUNTER PART ----------------------
         End If
         m_bFromParking = False
      End If
   End Sub

   Private Sub VerifyRot()
      ' se comando Shift è stato attivato
      If m_bKeyLeftShiftPressed Then
         ' Determino cosa verificare
         Dim nMoveId = If(m_nIdToSel <> GDB_ID.NULL, m_nIdToSel, GDB_ID.SEL)
         If Not EgtVerifyPart(nMoveId, CurrentMachine.bReducedCut) Then
            Dim ptCen As Point3d
            If Not EgtGetPartPartClusterCenterGlob(nMoveId, ptCen) Then Return
            EgtRotate(nMoveId, ptCen, Vector3d.Z_AX(), -m_dAngTotal, GDB_RT.GLOB)
         End If
      End If
      ' resetto i valori 
      m_dStartAng = 0
      m_dAngTotal = 0
      m_bStartRot = False
   End Sub

   Friend Function RotateAllRawParts(dAngDeg As Double, Optional bIsReg As Boolean = True) As Boolean
      ' Recupero rotazione totale
      Dim dRegRot As Double = CamAuto.GetRegistrationRotation()
      ' Recupero il centro del grezzo iniziale per usarlo come centro della rotazione
      Dim ptCen As New Point3d
      GetRawCenter(ptCen)
      ' Provo la rotazione
      Dim bMoveOk As Boolean = True
      Dim nPhase As Integer = 1
      Dim nRawId As Integer = GDB_ID.NULL
      While nPhase <= EgtGetPhaseCount()
         EgtSetCurrPhase(nPhase)
         nRawId = EgtGetFirstRawPart()
         While nRawId <> GDB_ID.NULL
            If EgtVerifyRawPartPhase(nRawId, nPhase) Then
               ' Rotazione del centro come spostamento grezzo più rotazione grezzo attorno al suo centro
               Dim ptRawCen As New Point3d
               EgtGetRawPartCenter(nRawId, ptRawCen)
               Dim ptMovCen As New Point3d(ptRawCen)
               ptMovCen.Rotate(ptCen, Vector3d.Z_AX(), dAngDeg)
               If Not EgtMoveRawPart(nRawId, ptMovCen - ptRawCen) Then
                  bMoveOk = False
                  Exit While
               End If
               If Not EgtRotateRawPart(nRawId, Vector3d.Z_AX(), dAngDeg) Then
                  EgtMoveRawPart(nRawId, -(ptMovCen - ptRawCen))
                  bMoveOk = False
                  Exit While
               End If
            End If
            nRawId = EgtGetNextRawPart(nRawId)
         End While
         If Not bMoveOk Then Exit While
         nPhase += 1
      End While
      ' Se rotazione impossibile, ripristino posizione dei grezzi già spostati
      If Not bMoveOk Then
         Dim nRevPhase As Integer = 1
         Dim nRevRawId As Integer = GDB_ID.NULL
         While nRevPhase <= nPhase
            EgtSetCurrPhase(nRevPhase)
            nRevRawId = EgtGetFirstRawPart()
            While nRevRawId <> GDB_ID.NULL And (nRevPhase < nPhase Or nRevRawId <> nRawId)
               If EgtVerifyRawPartPhase(nRevRawId, nRevPhase) Then
                  ' Eseguo al contrario
                  EgtRotateRawPart(nRevRawId, Vector3d.Z_AX(), -dAngDeg)
                  Dim ptRawCen As New Point3d
                  EgtGetRawPartCenter(nRevRawId, ptRawCen)
                  Dim ptMovCen As New Point3d(ptRawCen)
                  ptMovCen.Rotate(ptCen, Vector3d.Z_AX(), -dAngDeg)
                  EgtMoveRawPart(nRevRawId, (ptMovCen - ptRawCen))
               End If
               nRevRawId = EgtGetNextRawPart(nRevRawId)
            End While
            nRevPhase += 1
         End While
         ' Altrimenti eseguo sistemazioni
      Else
         ' Origine della tavola
         Dim ptOri As Point3d
         EgtGetTableRef(1, ptOri)
         ' Annullo rotazioni dei grezzi e le rifaccio sulle parti componenti
         Dim nRevPhase As Integer = 1
         Dim nRevRawId As Integer = GDB_ID.NULL
         While nRevPhase <= EgtGetPhaseCount()
            EgtSetCurrPhase(nRevPhase)
            nRevRawId = EgtGetFirstRawPart()
            While nRevRawId <> GDB_ID.NULL
               If EgtVerifyRawPartPhase(nRevRawId, nRevPhase) Then
                  ' Eseguo al contrario
                  EgtRotateRawPart(nRevRawId, Vector3d.Z_AX(), -dAngDeg)
                  Dim ptRawCen As New Point3d
                  EgtGetRawPartCenter(nRevRawId, ptRawCen)
                  Dim ptMovCen As New Point3d(ptRawCen)
                  ptMovCen.Rotate(ptCen, Vector3d.Z_AX(), -dAngDeg)
                  EgtMoveRawPart(nRevRawId, (ptMovCen - ptRawCen))
                  ' Rifaccio sugli oggetti contenuti nel grezzo
                  Dim nId As Integer = EgtGetFirstInGroup(nRevRawId)
                  While nId <> GDB_ID.NULL
                     EgtRotate(nId, ptCen, Vector3d.Z_AX(), dAngDeg, GDB_RT.GLOB)
                     nId = EgtGetNext(nId)
                  End While
                  ' Imposto posizione esatta del grezzo dopo rotazione
                  Dim b3Raw As New BBox3d
                  EgtGetRawPartBBox(nRevRawId, b3Raw)
                  EgtMoveToCornerRawPart(nRevRawId, (b3Raw.Min() - ptOri) + Point3d.ORIG(), MCH_CR.BL)
               End If
               nRevRawId = EgtGetNextRawPart(nRevRawId)
            End While
            nRevPhase += 1
         End While
         ' Ruoto opportunamente anche i dati di movimento
         Dim nOpeId As Integer = EgtGetFirstActiveOperation()
         While nOpeId <> GDB_ID.NULL
            If EgtGetOperationType(nOpeId) = MCH_OY.DISP Then
               ' Recupero i gruppi con i dati
               Dim nRpmId As Integer = EgtGetFirstNameInGroup(nOpeId, "Rpm*")
               While nRpmId <> GDB_ID.NULL
                  ' Recupero le informazioni
                  Dim vtRawMove As New Vector3d
                  If EgtGetInfo(nRpmId, "Mv", vtRawMove) Then
                     vtRawMove.Rotate(Vector3d.Z_AX(), dAngDeg)
                     EgtSetInfo(nRpmId, "Mv", vtRawMove)
                  End If
                  Dim vtDelta As New Vector3d
                  If EgtGetInfo(nRpmId, "Dt", vtDelta) Then
                     vtDelta.Rotate(Vector3d.Z_AX(), dAngDeg)
                     EgtSetInfo(nRpmId, "Dt", vtDelta)
                  End If
                  Dim dAngRotDeg As Double = 0
                  If EgtGetInfo(nRpmId, "Ad", dAngRotDeg) Then
                     EgtSetInfo(nRpmId, "Ad", dAngRotDeg + dAngDeg)
                  End If
                  ' Cerco un altro gruppo
                  nRpmId = EgtGetNextName(nRpmId, "Rpm*")
               End While
            End If
            nOpeId = EgtGetNextActiveOperation(nOpeId)
         End While
         ' Se non è registrazione, ruoto anche l'eventuale foto della lastra
         'If Not bIsReg Then
         '   Dim nPhotoId = m_CurrProjPage.GetPhoto()
         '   If nPhotoId <> GDB_ID.NULL then EgtRotatePhoto(nPhotoId, ptCen, Vector3d.Z_AX(), dAngDeg)
         'End If
         ' Aggiorno rotazione totale
         If bIsReg Then
            CamAuto.SetRegistrationRotation(dRegRot + dAngDeg)
         Else
            CamAuto.SetRegistrationRotation(0)
         End If
         ' Dichiaro grezzo per punti
         EgtSetInfo(GetCurrentRaw(), KEY_RAWBYPOINTS, 1)
      End If
      ' Ruoto i punti SpotReg disegnati in Office
      If bMoveOk Then
         RotateAllSpotRegistration(dAngDeg, ptCen)
      End If
      ' Ripristino lo stato iniziale
      EgtSetCurrPhase(1)
      HideAllMachinings()
      Return bMoveOk
   End Function

   ' Ruoto solo gli elementi SpotReg creati nel programma OFFICE
   Private Sub RotateAllSpotRegistration(dAngRot As Double, ptCen As Point3d)
      Dim nId As Integer = EgtGetFirstInGroup(OmagOFFICEMap.refRawPartTabVM.m_nRegGroupId)
      While nId <> GDB_ID.NULL
         Dim sName As String = String.Empty
         EgtGetName(nId, sName)
         If Not sName.Contains("CUT") Then
            EgtRotate(nId, ptCen, Vector3d.Z_AX, dAngRot)
         End If
         nId = EgtGetNext(nId)
      End While
      EgtDraw()
   End Sub

   Private Sub MoveAllRawParts(vtMove As Vector3d)
      ' Provo il movimento
      Dim bMoveOk As Boolean = True
      Dim nPhase As Integer = 1
      Dim nRawId As Integer = GDB_ID.NULL
      While nPhase <= EgtGetPhaseCount()
         EgtSetCurrPhase(nPhase)
         nRawId = EgtGetFirstRawPart()
         While nRawId <> GDB_ID.NULL
            If EgtVerifyRawPartPhase(nRawId, nPhase) Then
               If Not EgtMoveRawPart(nRawId, vtMove) Then
                  bMoveOk = False
                  Exit While
               End If
            End If
            nRawId = EgtGetNextRawPart(nRawId)
         End While
         If Not bMoveOk Then Exit While
         nPhase += 1
      End While
      ' Se movimento impossibile, ripristino posizione dei grezzi già spostati
      If Not bMoveOk Then
         Dim nRevPhase As Integer = 1
         Dim nRevRawId As Integer = GDB_ID.NULL
         While nRevPhase <= nPhase
            EgtSetCurrPhase(nRevPhase)
            nRevRawId = EgtGetFirstRawPart()
            While nRevRawId <> GDB_ID.NULL And (nRevPhase < nPhase Or nRevRawId <> nRawId)
               If EgtVerifyRawPartPhase(nRevRawId, nRevPhase) Then
                  EgtMoveRawPart(nRevRawId, -vtMove)
               End If
               nRevRawId = EgtGetNextRawPart(nRevRawId)
            End While
            nRevPhase += 1
         End While
      End If
      ' Muovo i punti SpotReg generati nel programma OFFICE
      If bMoveOk Then
         OmagOFFICEMap.refRawPartTabVM.MoveAllSpotRegistration(vtMove)
      End If
      ' Ripristino lo stato iniziale
      EgtSetCurrPhase(1)
      HideAllMachinings()
   End Sub

   ' verifica che la rotazione sia ammessa
   Private Function RotatePartInsideBond(dAngRotDeg As Double, nIdMove As Integer) As Boolean
      ' Verifico se ci sono dei pezzi bloccati in rotazione
      Dim bLockedRot As Boolean = GetLockOnRotation(nIdMove)
      ' Se tutti i pezzi possono ruotare
      If Not bLockedRot Then
         ' Calcolo il centro di rotazione come centro del cluster
         Dim ptCen As Point3d
         If Not EgtGetPartPartClusterCenterGlob(nIdMove, ptCen) Then Return False
         ' Aggiorno regioni per nesting
         UpdateNestRegions()
         EnableReferenceRegion(False)
         ' Verifico rotazione complessiva
         EgtRotate(nIdMove, ptCen, Vector3d.Z_AX(), dAngRotDeg, GDB_RT.GLOB)
         If EgtVerifyPart(nIdMove, CurrentMachine.bReducedCut) Then Return True
         ' Provo rotazione parziale (dopo aver annullato la complessiva)
         EgtRotate(nIdMove, ptCen, Vector3d.Z_AX(), -dAngRotDeg, GDB_RT.GLOB)
         Return EgtRotatePart(nIdMove, CurrentMachine.bReducedCut, ptCen, dAngRotDeg)
      Else
         Return False
      End If
   End Function

   Private Function RotateCluster(ByVal dAngRotDeg As Double) As Boolean
      ' Se non ci sono pezzi selezionati, esco
      If EgtGetSelectedObjCount() = 0 Then Return True

      ' Se pezzi in parcheggio, li ruoto liberamente e li risistemo (sempre possibile) 
      If m_nPartPos <> PART_POS.IN_TABLE Then
         Dim nId As Integer = EgtGetFirstSelectedObj()
         While nId <> GDB_ID.NULL
            ' Se pezzo con rotazione libera
            If Not EgtExistsInfo(nId, INFO_PARTROT) Then
               ' Calcolo il centro di rotazione come centro del pezzo
               Dim ptCen As Point3d
               If Not EgtGetPartPartClusterCenterGlob(nId, ptCen) Then Return False
               ' Rotazione del pezzo attorno al suo centro
               EgtRotate(nId, ptCen, Vector3d.Z_AX(), dAngRotDeg, GDB_RT.GLOB)

               '---------------------- COUNTER PART ----------------------
               ' Aggiorno il Guid assegnando la nuova rotazione
               Dim sRefGroup As String = String.Empty
               If EgtGetInfo(nId, INFO_REFGROUP, sRefGroup) Then
                  Dim sCurrRefGroup As String = sRefGroup
                  If UppDateGuidCode(sRefGroup, CreatePreGuidCode(nId)) Then
                     EgtSetInfo(nId, INFO_REFGROUP, sRefGroup)
                  End If
                  ' aggiorno il layer che indica il numero di pezzi in parcheggio
                  CountPartInFamily(sCurrRefGroup)
               End If
               ' se esiste almento un pezzo del gruppo in parcheggio esco
               If Not ParkInGroupFamily(nId) Then
                  PackPartInStore(nId)
               End If
               ' ricarico l'lelenco dei pezzi in parcheggio
               GetFamilyGroupInPark()
               '---------------------- COUNTER PART ----------------------


               '' Sistemazione nel parcheggio
               'PackPartInStore(nId)
            End If
            ' Passo al successivo selezionato
            nId = EgtGetNextSelectedObj()
         End While
         Return True
         ' Altrimenti li ruoto tenendo conto delle collisioni
      Else
         Return RotatePartInsideBond(dAngRotDeg, GDB_ID.SEL)
      End If
   End Function

   Private Function GetLockOnRotation(nPartId As Integer) As Boolean
      ' Se singolo pezzo
      If nPartId <> GDB_ID.SEL Then
         Return EgtExistsInfo(nPartId, INFO_PARTROT)
         ' Altrimenti tutti i selezionati
      Else
         Dim bLockedRot As Boolean = False
         Dim nId As Integer = EgtGetFirstSelectedObj()
         While nId <> GDB_ID.NULL
            If EgtExistsInfo(nId, INFO_PARTROT) Then
               bLockedRot = True
               Exit While
            End If
            nId = EgtGetNextSelectedObj()
         End While
         Return bLockedRot
      End If
   End Function

   Friend Sub Refresh(PrevMeasureUnit As MeasureUnitOpt)
      NotifyPropertyChanged("StepMove")
   End Sub

   Friend Function SelectPart(nPartId As Integer, bNotifyVM As Boolean, ByRef nOtherMgrpId As Integer) As Boolean
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Determino se pezzo in tavola, in parcheggio o in altro gruppo
      Dim bPartInTable As Boolean = (EgtGetParent(nPartId) = EstCalc.GetRawId())
      Dim bPartFree As Boolean = PartIsFree(nPartId)
      ' Se ci sono pezzi già selezionati nella posizione opposta, restituisco selezione non possibile
      If (bPartInTable And m_nPartPos = PART_POS.OUT_TABLE) Or
         (bPartFree And m_nPartPos = PART_POS.IN_TABLE) Then
         nOtherMgrpId = GDB_ID.NULL
         Return False
      End If
      ' Se il pezzo appartiene ad un altro gruppo di lavoro, restituisco selezione non possibile
      If Not bPartInTable And Not bPartFree Then
         nOtherMgrpId = EstCalc.GetPartMachGroup(nPartId)
         Return False
      End If
      ' Eseguo la selezione
      EgtSelectObj(nPartId)
      ' Eventuale aggiornamento VeinMatching
      If bNotifyVM Then VeinMatching.OnSelectPart(nPartId)
      ' Set flag posizione selezionati
      m_nPartPos = If(bPartInTable, PART_POS.IN_TABLE, PART_POS.OUT_TABLE)
      ' Selezione effettuata
      EgtDraw()
      Return True
   End Function

   Friend Function DeselectPart(nPartId As Integer, bNotifyVM As Boolean) As Boolean
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Eseguo la deselezione
      EgtDeselectObj(nPartId)
      ' Eventuale aggiornamento VeinMatching
      If bNotifyVM Then VeinMatching.OnDeselectPart(nPartId)
      ' Se nessun pezzo selezionato, reset flag posizione selezionati
      If EgtGetSelectedObjCount() = 0 Then m_nPartPos = PART_POS.NONE_TABLE
      ' Deselezione effettuata
      EgtDraw()
      Return True
   End Function

   Friend Function DeselectAllParts(bNotifyVM As Boolean) As Boolean
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Eseguo
      EgtDeselectAll()
      ' Eventuale notifica al VeinMatching
      If bNotifyVM Then VeinMatching.OnDeselectAll()
      ' Imposto flag posizione pezzi
      m_nPartPos = PART_POS.NONE_TABLE
      Return True
   End Function

   Friend Function ExitNesting(bChange As Boolean) As Boolean
      If m_CsvImport_IsChecked Then
         m_CsvImportWindow.Close()
         m_CsvImportWindow = Nothing
      End If
      If bChange Then
         OmagOFFICEMap.refVeinMatchPanelVM.SetVeinMatchIsChecked(False)
         OmagOFFICEMap.refVeinMatchPanelVM.VeinMatchIsEnabled = False
      End If
      Return True
   End Function

#Region "DRAG RECTANGLE"

   ' funzione chiamata da OnMyMouseMoveScene: verifica che la selezione sia corretta (deve essere il lato di una figura rettangolare)
   Private Sub OnMyMouseDownSceneSelSideRectangle(sender As Object, e As System.Windows.Forms.MouseEventArgs)
      ' Si può selezionare solo con il tasto sinistro
      If e.Button <> Windows.Forms.MouseButtons.Left Then Return
      ' Verifico se selezionato indicativo di pezzo
      EgtSetObjFilterForSelWin(False, True, False, False, False)
      Dim nSelMy As Integer
      EgtSelect(e.Location, Scene.DIM_SEL, Scene.DIM_SEL, nSelMy)
      Dim nIdMy As Integer = EgtGetFirstObjInSelWin()
      While nIdMy <> GDB_ID.NULL
         Dim sLayer As String = String.Empty
         ' layer di origine
         Dim nIdParent As Integer = EgtGetParent(nIdMy)
         ' recupero il nome del Layer
         EgtGetName(nIdParent, sLayer)
         ' solo se il nome del layer è quello associato ad un lato esterno allora procedo con l'evidenziazione
         If sLayer = NAME_OUTLOOP Then
            If EgtGetType(nIdMy) = GDB_TY.CRV_LINE Then
               ' -------------------------------- INIZIO VERIFICHE --------------------------------
               m_nIdSelectedOutLoopRectangle = nIdParent
               If Not IsRectangle(m_SideListRectangle) Then
                  'm_CurrProjPage.ClearMessage()
                  'm_CurrProjPage.SetWarningMessage("Non è un rettangolo (0)")
                  Return
               End If
               ' recupero il gruppo della lavorazione associata
               Dim nIdParentPart As Integer = EgtGetParent(nIdParent)
               Dim nIdPV As Integer = EgtGetFirstNameInGroup(nIdParentPart, NAME_PREVIEW)
               ' se non esiste un gruppo di lavorazione associato allora esco
               If nIdPV = GDB_ID.NULL Then
                  'm_CurrProjPage.ClearMessage()
                  'm_CurrProjPage.SetWarningMessage("Pezzo in parcheggio (1)")
                  Return
               End If
               ' se esiste ma è vuoto (pezzo scaricato da tavola)
               If EgtGetFirstInGroup(nIdPV) = GDB_ID.NULL Then
                  'm_CurrProjPage.ClearMessage()
                  'm_CurrProjPage.SetWarningMessage("Pezzo in parcheggio (2)")
                  Return
               End If
               ' Devo verificare che sia una lavorazione solo di lama?
               Dim nIdSaw As Integer = EgtGetFirstNameInGroup(nIdPV, "Saw" & nIdMy.ToString)
               ' -------------------------------- FINE VERIFICHE --------------------------------

               If EgtGetGroupObjs(nIdSaw) <> 0 Then
                  m_nIdSelectedSawRectangle = nIdSaw
                  m_nIdSelectedCurvRectangle = nIdMy

                  m_nIdSelectedRegionRectangle = EgtGetFirstNameInGroup(nIdParentPart, NAME_REGION)
                  ' recupero i testi contenuti nel layer Region
                  If m_nIdSelectedRegionRectangle <> GDB_ID.NULL Then
                     Dim nCurrId As Integer = EgtGetFirstInGroup(m_nIdSelectedRegionRectangle)
                     While nCurrId <> GDB_ID.NULL
                        If EgtGetType(nCurrId) = GDB_TY.EXT_TEXT Then
                           Dim sVal As String = String.Empty
                           EgtTextGetContent(nCurrId, sVal)
                           If sVal = "*TOP*" Then
                              m_nIdSelectedTextTopRectangle = nCurrId
                           Else
                              m_nIdSelectedTextRectangle = nCurrId
                              m_sTextContent = GetMyRectangleText(sVal)
                           End If
                        ElseIf EgtGetType(nCurrId) = GDB_TY.SRF_FRGN Then
                           m_nIdSelectedFlatSurfRectangle = nCurrId
                        End If
                        nCurrId = EgtGetNext(nCurrId)
                     End While
                  End If
                  ' seleziono ed evidenzio il lato selezionato
                  EgtSelectObj(nIdSaw)
                  EgtSetMark(nIdSaw)
                  EgtSelectObj(nIdMy)
                  EgtDraw()
                  Exit While
               End If
            End If
            ' se l'elemento corrente non è una linea
         End If
         ' se l'elemento corrente non appartiene al layer OutLoop passo al prossimo elemento dell'elenco
         nIdMy = EgtGetNextObjInSelWin()
      End While
   End Sub

   ' restituisce il valore del Text ripulito dalle dimensioni
   Private Function GetMyRectangleText(sTextPz As String) As String
      ' da DrawPageUC.xaml.vb/MultipleInsert
      Dim sText As String = String.Empty
      If sTextPz.Contains("<br/>") Then
         Dim nLastIndex As Integer = sTextPz.LastIndexOf(">")
         sText = sTextPz.Remove(nLastIndex + 1)
         Return sText
      End If
      If sTextPz.Contains("  ") Then
         Dim sInfo() As String = sTextPz.Split(" "c)
         If sInfo.Count > 3 Then
            sText = sInfo(0) & "  " & sInfo(1) & "  "
            Return sText
         End If
      End If
      Return sText
   End Function

   ' verifico che la figura selezionata sia realmente un rettangolo
   Private Function IsRectangle(ByRef IdSideList() As Integer) As Boolean
      ' creo una lista con i lati del rettangolo
      Dim nCounter As Integer = 0
      ' recupero i lati dal leyer "OutLoop"
      Dim IdSideRectangle As Integer = EgtGetFirstInGroup(m_nIdSelectedOutLoopRectangle)
      While IdSideRectangle <> GDB_ID.NULL And nCounter < 4
         Dim sVal As String = String.Empty
         Dim dPrevAng As Double = 0
         EgtGetInfo(IdSideRectangle, "PrevAng", sVal)
         StringToDouble(sVal, dPrevAng)
         Dim dNextAng As Double = 0
         EgtGetInfo(IdSideRectangle, "NextAng", sVal)
         StringToDouble(sVal, dNextAng)
         ' se gli angoli non sono retti allora esco senza caricare il lato corrente
         If Math.Abs(dPrevAng - 90) > EPS_ANG_SMALL OrElse Math.Abs(dNextAng - 90) > EPS_ANG_SMALL Then
            Exit While
         End If
         IdSideList(nCounter) = IdSideRectangle
         nCounter += 1
         IdSideRectangle = EgtGetNext(IdSideRectangle)
      End While
      ' verifico che siano solo quattro lati
      If IdSideRectangle = GDB_ID.NULL And nCounter = 4 Then
         ' solo se la figura ha 4 lati ortogonali
         Return True
      End If

      m_nIdSelectedOutLoopRectangle = GDB_ID.NULL
      ' la figura presenta più/meno di 4 lati    
      Return False
   End Function

   ' recupero le informazioni correnti per sapere se la figura è mdificabile
   Private Function GetRectangleInfoScale(ByRef frFixed As Frame3d, ByRef MaxLen As Double, ByRef MinLen As Double) As Vector3d
      ' determino la direzione del lato selezionato
      Dim vtDirSelectedCurv As New Vector3d
      EgtStartVector(m_nIdSelectedCurvRectangle, GDB_ID.ROOT, vtDirSelectedCurv)

      ' recupero il lato successivo a quello selezionato 
      Dim Index As Integer = 0
      Dim Len As Double = 0
      For Ind As Integer = 0 To 3
         If m_SideListRectangle(Ind) = m_nIdSelectedCurvRectangle Then
            ' verifico se esiste un lato Precedente altrimenti recupero l'ultimo della lista
            If Ind = 0 Then
               Index = 3
            Else
               Index = Ind - 1
            End If
         End If
      Next
      ' recupero la dimensione del lato
      EgtCurveLength(m_SideListRectangle(Index), MaxLen)
      EgtCurveLength(m_nIdSelectedCurvRectangle, MinLen)

      ' verifico che il lato selezionato sia il maggiore
      If MinLen > MaxLen Then Return Nothing

      ' determimo il versore dal lato appena calcolato
      Dim vtDir As New Vector3d

      EgtStartVector(m_SideListRectangle(Index), GDB_ID.ROOT, vtDir)
      vtDir.Normalize()
      Dim dProjectionBaseX As Double = vtDir * Vector3d.X_AX
      Dim ptFixed As New Point3d
      EgtStartPoint(m_SideListRectangle(Index), GDB_ID.ROOT, ptFixed)

      Dim vtPerp As New Vector3d(vtDir.x, vtDir.y, vtDir.z)
      vtPerp.Rotate(Vector3d.Z_AX, 90)

      ' determino il Frame corrente
      frFixed = New Frame3d(ptFixed, vtDir, vtPerp, Vector3d.Z_AX)

      Return vtDir

   End Function

   ' funzione chiamata da OnMyMouseMoveScene: gestisce la modifica lungo una dimensione del rettangolo selezionato
   Private Sub OnMyMouseMoveSawRectangle(sender As Object, e As System.Windows.Forms.MouseEventArgs)
      ' Se drag non abilitato o già in esecuzione, esco
      If Not m_bDrag Or m_bDragging Then Return
      ' Se primo movimento di drag, verifico di aver superato la soglia di movimento in pixel
      If m_bDragToStart Then
         If Math.Abs(e.Location.X - m_locPrev.X) < m_nRestRadius And
            Math.Abs(e.Location.Y - m_locPrev.Y) < m_nRestRadius Then
            Return
         End If
         m_bDragToStart = False
      End If

      ' riferiemento che deve rimanere fisso del rettangolo 
      Dim frFixed As Frame3d = Nothing
      ' lunghezza del lato da modificare
      Dim MaxLen As Double = 0
      Dim MinLen As Double = 0
      ' recupero info sul rettangolo selezionato
      Dim vtDir As Vector3d = GetRectangleInfoScale(frFixed, MaxLen, MinLen)
      If vtDir.Equals(Vector3d.NULL) Then
         Return
      End If

      ' Inizio esecuzione di drag
      m_bDragging = True

      ' Ricavo il punto corrente in coordinate mondo
      Dim ptCurr As Point3d
      EgtUnProjectPoint(e.Location, ptCurr)
      ' Ricavo il vettore di movimento
      Dim vtMove As Vector3d = ptCurr - m_ptPrev
      ' ricavo il valore efficace di allungamento (la proiezione)
      Dim dProjection As Double = vtMove * vtDir
      vtMove = vtDir * dProjection
      ' recupero il valore di scalatura
      Dim dScalefactor = dProjection / MaxLen + 1

      ' Modifico dimensione figura
      If Math.Abs(dScalefactor) > EPS_SMALL * EPS_SMALL Then
         EgtScale(m_nIdSelectedOutLoopRectangle, frFixed, dScalefactor, 1, 1, GDB_RT.GLOB)
         EgtScale(m_nIdSelectedFlatSurfRectangle, frFixed, dScalefactor, 1, 1, GDB_RT.GLOB)
         Dim ptCen As Point3d
         EgtCenterPoint(m_nIdSelectedTextRectangle, ptCen)
         EgtModifyText(m_nIdSelectedTextRectangle, m_sTextContent & LenToString(MaxLen + dProjection, 2) & " x " & LenToString(MinLen, 2))
         EgtMove(m_nIdSelectedTextRectangle, vtMove * 0.5, GDB_RT.GLOB)
         If m_nIdSelectedTextTopRectangle <> GDB_ID.NULL Then
            EgtMove(m_nIdSelectedTextTopRectangle, vtMove * 0.5, GDB_RT.GLOB)
         End If
      End If

      ' verifico che il il lato  maggiore rimanga semore il lato maggiore
      Dim bRectangleCorrect As Boolean = False
      If (MaxLen + dProjection - MinLen) > EPS_SMALL Then bRectangleCorrect = True

      Dim nWarn As Integer = 0
      ResetAllMachinings(nWarn)
      EnableReferenceRegion(False)
      ' se la modifica genera un errore allora ripristino la figura prima della defomrazione
      If Not EgtVerifyPart(EgtGetParent(m_nIdSelectedOutLoopRectangle), True) Or Not bRectangleCorrect Then
         EgtScale(m_nIdSelectedOutLoopRectangle, frFixed, 1 / dScalefactor, 1, 1, GDB_RT.GLOB)
         EgtScale(m_nIdSelectedFlatSurfRectangle, frFixed, 1 / dScalefactor, 1, 1, GDB_RT.GLOB)
         Dim ptCen As Point3d
         EgtCenterPoint(m_nIdSelectedTextRectangle, ptCen)
         EgtModifyText(m_nIdSelectedTextRectangle, m_sTextContent & LenToString(MaxLen, 2) & " x " & LenToString(MinLen, 2))
         EgtMove(m_nIdSelectedTextRectangle, -vtMove * 0.5, GDB_RT.GLOB)
         If m_nIdSelectedTextTopRectangle <> GDB_ID.NULL Then
            EgtMove(m_nIdSelectedTextTopRectangle, -vtMove * 0.5, GDB_RT.GLOB)
         End If
      End If

      EgtDraw()
      ' Aggiorno il punto precedente
      m_ptPrev = ptCurr
      ' Terminata esecuzione di drag
      m_bDragging = False
   End Sub

   ' funzione chiamata da OnMyMouseUp: gestisce il reset di tutti gli indici in uso 
   Public Sub ResetDragRectangleParam()
      ' deseleziono l'elemento corrente
      EgtDeselectObj(m_nIdSelectedSawRectangle)
      EgtDeselectObj(m_nIdSelectedCurvRectangle)
      EgtResetMark(m_nIdSelectedSawRectangle)
      ' resetto gli indici
      m_nIdSelectedOutLoopRectangle = GDB_ID.NULL
      m_nIdSelectedRegionRectangle = GDB_ID.NULL
      m_nIdSelectedSawRectangle = GDB_ID.NULL
      m_nIdSelectedCurvRectangle = GDB_ID.NULL
      m_nIdSelectedTextRectangle = GDB_ID.NULL
      m_nIdSelectedTextTopRectangle = GDB_ID.NULL
      m_nIdSelectedFlatSurfRectangle = GDB_ID.NULL
      m_SideListRectangle = {GDB_ID.NULL, GDB_ID.NULL, GDB_ID.NULL, GDB_ID.NULL}
      m_sTextContent = String.Empty
      ' disattivo il drag
      m_bDrag = False
      ' aggiorno le lavorazioni
      Dim nWarn As Integer = 0
      ResetAllMachinings(nWarn)
      EgtDraw()
   End Sub

#End Region    ' Drag Rettangolo

#End Region    ' METHODS

   Private m_bDragRectangle As Boolean
   Public Property bDragRectangle As Boolean
      Get
         Return m_bDragRectangle
      End Get
      Set(value As Boolean)
         m_bDragRectangle = value
         m_bSplitCurvWJ = False
         ResetSplitCurvWJParam(True)
         m_bStartCurvWJ = False
         ResetStartCurvWJParam(True)
         NotifyPropertyChanged("bSplitCurvWJ")
         NotifyPropertyChanged("bStartCurvWJ")
      End Set
   End Property

   Private m_DragRectangle_Visibility As Visibility = Visibility.Collapsed
   Public ReadOnly Property DragRectangle_Visibility As Visibility
      Get
         Return m_DragRectangle_Visibility
      End Get
   End Property

#Region "WATERJET SPLIT CURVE"

   ' funzione per la selezione dei lati su cui operare la separazione del tagli waterjet
   Private Sub OnMyMouseDownSceneSplitCurv(sender As Object, e As System.Windows.Forms.MouseEventArgs)
      ' Si può selezionare solo con il tasto sinistro e se il bottone TEST Attivo
      If e.Button <> Windows.Forms.MouseButtons.Left Or
         Not m_bSplitCurvWJ Then
         Return
      End If
      ' Se esiste un elemento selezionato
      EgtResetMark(m_nIdSelectedWaterJet)
      ' Verifico se selezionato indicativo di pezzo
      EgtSetObjFilterForSelWin(False, True, False, False, False)
      Dim nSelMy As Integer
      EgtSelect(e.Location, Scene.DIM_SEL, Scene.DIM_SEL, nSelMy)
      Dim nIdMy As Integer = EgtGetFirstObjInSelWin()
      While nIdMy <> GDB_ID.NULL
         Dim sLayer As String = String.Empty
         ' layer di origine
         Dim nIdParent As Integer = EgtGetParent(nIdMy)
         ' recupero il nome del Layer
         EgtGetName(nIdParent, sLayer)
         ' solo se il nome del layer è quello associato ad un lato esterno allora procedo con l'evidenziazione
         If sLayer = NAME_OUTLOOP Then
            If EgtGetType(nIdMy) = GDB_TY.CRV_ARC OrElse EgtGetType(nIdMy) = GDB_TY.CRV_COMPO OrElse EgtGetType(nIdMy) = GDB_TY.CRV_LINE Then
               If m_nIdSelectedSideWJ <> GDB_ID.NULL Or m_nIdSelectedSideWJ = nIdMy Then
                  EgtDeselectObj(m_nIdSelectedSideWJ)
               End If
               ' recupero il gruppo della lavorazione associata
               Dim nIdParentPart As Integer = EgtGetParent(nIdParent)
               Dim nIdPV As Integer = EgtGetFirstNameInGroup(nIdParentPart, NAME_PREVIEW)
               ' VERIFICA: recupero l'elenco delle Preview di Tipo WaterJet associate a questo Part
               Dim ListGroup As List(Of Integer) = ResearchGropuWJ(nIdParent, nIdPV)
               ' VERIFICA: se esistono delle lavorazioni associate al percorso OutLoop di tipo Saw allora non procedo
               Dim ListGroupSaw As List(Of Integer) = ResearchGropuSaw(nIdParent, nIdPV)
               ' se non esiste almeno 1 Preview di tipo WaterJet
               If ListGroup.Count > 0 And ListGroupSaw.Count = 0 Then
                  m_nIdSelectedSideWJ = nIdMy
                  Dim nValInfo As Integer = 1
                  Dim nNewValInfo As Integer = nValInfo
                  If EgtGetInfo(nIdMy, INFO_JOINTENTITY, nValInfo) Then
                     If nValInfo = 1 Then
                        nNewValInfo = 0
                     Else
                        nNewValInfo = 1
                     End If
                  Else
                     ' se manca l'info allora il taglio sValInfo = "1" quindi separo il taglio
                     nNewValInfo = 0
                  End If
                  EgtSetInfo(nIdMy, INFO_JOINTENTITY, nNewValInfo)
                  ' Ricalcolo tutte le lavorazioni
                  Dim nWarn As Integer = 0
                  ResetAllMachinings(nWarn)
                  ' recupero l'indice del PreView che deve essere acceso per indicare la selezione
                  ListGroup = ResearchGropuWJ(nIdParent, nIdPV)
                  Dim nIdWJ As Integer = GetPVIdFromIdSide(ListGroup, nIdMy)
                  GetCurrentPVFromIdSide(ListGroup, nIdMy, nIdWJ, nIdParent)
                  ' assegno un identificativo grafico per inidcare che è un taglio separato
                  If nNewValInfo = 0 Then
                     AssignFlagOnGraphic(nIdMy, nIdParentPart)
                  Else
                     EraseFlagOnGraphic(nIdMy, nIdParentPart)
                  End If
                  ' salvo il valore del PreView evidenziato
                  m_nIdSelectedWaterJet = nIdWJ
                  EgtSetMark(nIdWJ)
                  EgtSelectObj(nIdMy)
                  EgtDraw()
                  Exit While
               End If

            End If
         End If
         nIdMy = EgtGetNextObjInSelWin()
      End While
      Return
   End Sub

   ' restituisce l'elenco dei Gruppi Waterjet associati al contorno indicato
   Public Function ResearchGropuWJ(nIdOutLoop As Integer, nIdPV As Integer) As List(Of Integer)
      Dim ListOfGroupPV As New List(Of Integer)
      Dim nIdGroup As Integer = GDB_ID.NULL
      Dim nIdMy As Integer = GDB_ID.NULL
      ' recupero il primo lato dall'elenco dei lati della figura
      nIdMy = EgtGetFirstInGroup(nIdOutLoop)
      ' altrimenti cerco all'interno del layer OutLoop per ogni lato la lavorazione associata
      While nIdMy <> GDB_ID.NULL
         ' verifico se esiste una Preview associata al lato
         nIdGroup = EgtGetFirstNameInGroup(nIdPV, "Waterjet" & nIdMy.ToString & "S")
         If nIdGroup <> GDB_ID.NULL Then
            ListOfGroupPV.Add(nIdGroup)
         End If
         nIdMy = EgtGetNext(nIdMy)
      End While
      Return ListOfGroupPV
   End Function

   ' restituisce l'elenco dei Gruppi Saw associati al contorno indicato
   Public Function ResearchGropuSaw(nIdOutLoop As Integer, nIdPV As Integer) As List(Of Integer)
      Dim ListOfGroupPV As New List(Of Integer)
      Dim nIdGroup As Integer = GDB_ID.NULL
      Dim nIdMy As Integer = GDB_ID.NULL
      ' recupero il primo lato dall'elenco dei lati della figura
      nIdMy = EgtGetFirstInGroup(nIdOutLoop)
      ' altrimenti cerco all'interno del layer OutLoop per ogni lato la lavorazione associata
      While nIdMy <> GDB_ID.NULL
         ' verifico se esiste una Preview associata al lato
         nIdGroup = EgtGetFirstNameInGroup(nIdPV, "Saw" & nIdMy.ToString)
         If nIdGroup <> GDB_ID.NULL Then
            ListOfGroupPV.Add(nIdGroup)
         End If
         nIdMy = EgtGetNext(nIdMy)
      End While
      Return ListOfGroupPV
   End Function

   Public Function GetPVIdFromIdSide(ListGroup As List(Of Integer), nIdMy As Integer) As Integer
      Dim IdWaterjetPV As Integer = GDB_ID.NULL
      For Each nIdItem As Integer In ListGroup
         Dim sName As String = String.Empty
         If EgtGetName(nIdItem, sName) Then
            If sName.Contains(nIdMy.ToString) Then
               IdWaterjetPV = nIdItem
               Exit For
            End If
         End If
      Next
      Return IdWaterjetPV
   End Function

   Public Sub GetCurrentPVFromIdSide(ListGroup As List(Of Integer), nIdMy As Integer, ByRef nIdWj As Integer, nIdParent As Integer)
      Dim nObjInGroup As Integer = EgtGetGroupObjs(nIdParent)
      Dim nCount As Integer = 0
      GetNextSideJoint(ListGroup, nIdMy, nIdWj, nCount, nObjInGroup)
      If nIdWj <> GDB_ID.NULL Then Return
      GetPrevSideJoint(ListGroup, nIdMy, nIdWj, nCount, nObjInGroup)
   End Sub

   ' funzione ricorsiva per la ricerca del lato al quale è associata la PreView
   Private Sub GetNextSideJoint(ListGroup As List(Of Integer), nIdMy As Integer, ByRef nIdWj As Integer, ByRef nCount As Integer, nObjInGroup As Integer)
      Dim nValInfo As Integer = 1
      ' espressione di controllo per evitare di generare Loop infinito
      If nCount > nObjInGroup Then Return
      If nIdWj = GDB_ID.NULL Then
         Dim nIdWJNext As Integer = EgtGetNext(nIdMy)
         If nIdWJNext = GDB_ID.NULL Then nIdWJNext = EgtGetFirstInGroup(EgtGetParent(nIdMy))
         nCount += 1
         EgtGetInfo(nIdWJNext, "JoinEntity", nValInfo)
         If nValInfo = 1 Then
            nIdWj = GetPVIdFromIdSide(ListGroup, nIdWJNext)
            If nIdWj <> GDB_ID.NULL Then Return
         Else
            Return
         End If
         'nIdWJNext = EgtGetNext(nIdWJNext)
         GetNextSideJoint(ListGroup, nIdWJNext, nIdWj, nCount, nObjInGroup)
         If nIdWj <> GDB_ID.NULL Then Return
      End If
   End Sub

   ' funzione ricorsiva per la ricerca del lato al quale è associata la PreView
   Private Sub GetPrevSideJoint(ListGroup As List(Of Integer), nIdMy As Integer, ByRef nIdWj As Integer, ByRef nCount As Integer, nObjInGroup As Integer)
      Dim nValInfo As Integer = 1
      ' espressione di controllo per evitare di generare Loop infinito
      If nCount > nObjInGroup Then Return
      If nIdWj = GDB_ID.NULL Then
         Dim nIdWJPrev As Integer = EgtGetPrev(nIdMy)
         ' se arrivato al primo valore allora continuo la ricerca dall'ultimo
         If nIdWJPrev = GDB_ID.NULL Then nIdWJPrev = EgtGetLastInGroup(EgtGetParent(nIdMy))
         nCount += 1
         EgtGetInfo(nIdWJPrev, INFO_JOINTENTITY, nValInfo)
         If nValInfo = 1 Then
            nIdWj = GetPVIdFromIdSide(ListGroup, nIdWJPrev)
            If nIdWj <> GDB_ID.NULL Then Return
         Else
            Return
         End If
         'nIdWJPrev = EgtGetPrev(nIdWJPrev)
         GetPrevSideJoint(ListGroup, nIdWJPrev, nIdWj, nCount, nObjInGroup)
         If nIdWj <> GDB_ID.NULL Then Return

      End If
   End Sub

   Public Sub ResetSplitCurvWJParam(Optional bAllParam As Boolean = True)
      If bAllParam Then
         EgtDeselectObj(m_nIdSelectedSideWJ)
         EgtResetMark(m_nIdSelectedWaterJet)
      End If
      m_nIdSelectedSideWJ = GDB_ID.NULL
      m_nIdSelectedWaterJet = GDB_ID.NULL
      EgtDraw()
   End Sub

   ' ricevo l'ID del percorso di lavorazione WJ al quale associo una etichetta grafica con scritto "S"
   Private Sub AssignFlagOnGraphic(nIdMy As Integer, IdParentPart As Integer)
      ' cerco se esiste già un layer nominato "AUX_SPLIT_WJ", altrimenti lo creo
      Dim IdAuxLayer As Integer = EgtGetFirstNameInGroup(IdParentPart, INFO_AUX_SPLIT_WJ)
      If IdAuxLayer = GDB_ID.NULL Then
         IdAuxLayer = EgtCreateGroup(IdParentPart)
         EgtSetName(IdAuxLayer, INFO_AUX_SPLIT_WJ)
      End If
      ' recupero il punto medio del segmento selezionato
      Dim MidPoint As Point3d
      EgtMidPoint(nIdMy, GDB_RT.GLOB, MidPoint)
      'Dim nIdTextFlag As Integer = EgtCreateText(IdAuxLayer, MidPoint, "*", 20, GDB_RT.GLOB)
      Dim nIdTextFlag As Integer = GetCreateFlagText(nIdMy, IdAuxLayer)
      EgtSetColor(nIdTextFlag, New Color3d(255, 0, 0))
      EgtSetName(nIdTextFlag, "RefSide_" & nIdMy.ToString)
   End Sub

   Private Function GetCreateFlagText(nId As Integer, nIdLayer As Integer, Optional sText As String = "*") As Integer
      ' recupero il punto medio
      Dim MidPoint As Point3d
      EgtMidPoint(nId, GDB_RT.GLOB, MidPoint)
      ' recupero la direzione del vettore nel punto medio
      Dim vVers As Vector3d
      EgtMidVector(nId, GDB_RT.GLOB, vVers)
      vVers.Normalize()
      vVers.Rotate(Vector3d.Z_AX, 90)
      ' Ingombro complessivo della lavorazione
      Dim ptMin, ptMax As Point3d
      EgtStartPoint(nId, GDB_RT.GLOB, ptMin)
      EgtEndPoint(nId, GDB_RT.GLOB, ptMax)
      ' Metto il numero nel centro
      Dim dRadXY = Point3d.DistXY(ptMin, ptMax)
      Dim dHtxt As Double = 50
      Dim dRat As Double = 0.75
      If dRadXY < 200 Then
         dHtxt = 40
         dRat = 0.6
      ElseIf dRadXY < 25 Then
         dHtxt = 25
         dRat = 0.5
      End If
      ' determino la posizione del flag
      MidPoint.x += vVers.x * dHtxt / 2
      MidPoint.y += vVers.y * dHtxt / 2

      Return EgtCreateTextAdv(nIdLayer, MidPoint, 0, sText, "", 300, False, dHtxt, dRat, 0, INS_POS.MC, GDB_RT.GLOB)
   End Function

   Private Sub EraseFlagOnGraphic(nIdMy As Integer, IdParentPart As Integer)
      ' cerco se esiste già un layer nominato "AUX_SPLIT_WJ", altrimenti lo creo
      Dim IdAuxLayer As Integer = EgtGetFirstNameInGroup(IdParentPart, INFO_AUX_SPLIT_WJ)
      If IdAuxLayer = GDB_ID.NULL Then Return
      Dim nIdTextFlag As Integer = EgtGetFirstNameInGroup(IdAuxLayer, "RefSide_" & nIdMy.ToString)
      EgtErase(nIdTextFlag)
   End Sub

#End Region    ' WaterJet Section and StartPoint

   Private m_bSplitCurvWJ As Boolean
   Public Property bSplitCurvWJ As Boolean
      Get
         Return m_bSplitCurvWJ
      End Get
      Set(value As Boolean)
         m_bSplitCurvWJ = value
         If Not m_bSplitCurvWJ Then
            ' resetto i parametri di selezione dei lati
            ResetSplitCurvWJParam(True)
         End If
         m_bDragRectangle = False
         m_bStartCurvWJ = False
         ResetStartCurvWJParam(True)
         NotifyPropertyChanged("bDragRectangle")
         NotifyPropertyChanged("bStartCurvWJ")
      End Set
   End Property

   Private m_WJ_Cmd_Visibility As Visibility = Visibility.Collapsed
   Public ReadOnly Property WJ_Cmd_Visibility As Visibility
      Get
         Return m_WJ_Cmd_Visibility
      End Get
   End Property

   ' in funzione della macchinata attiva predispone la visualizzazione del bottone SplitCurv (abilitato solo per WaterJet Machine)
   Public Sub Set_WJ_Cmd_Visibility()
      ' gestisco la visualizzazione del comando ON_OFF (per i tagli waterjet)
      If CurrentMachine.WaterJettingActive Then
         m_WJ_Cmd_Visibility = Visibility.Visible
      Else
         m_WJ_Cmd_Visibility = Visibility.Collapsed
      End If
      NotifyPropertyChanged("WJ_Cmd_Visibility")
   End Sub

#Region "WATERJET START POINT"

   ' funzione per la selezione del punto di inizio tagli waterjet (percorso chiuso)
   Private Sub OnMyMouseDownSceneStartCurv(sender As Object, e As System.Windows.Forms.MouseEventArgs)
      ' Si può selezionare solo con il tasto sinistro e se il bottone TEST Attivo
      If e.Button <> Windows.Forms.MouseButtons.Left Or
         Not m_bStartCurvWJ Then
         Return
      End If

      ' Acquisisco punto da disegno
      Dim ptStartCurv As New Point3d
      EgtUnProjectPoint(e.Location, ptStartCurv)
      ' Aggiusto Z punto acquisito (è in globale)
      Dim ptRawMax As New Point3d
      Dim ptRawMin As New Point3d
      If GetRawBox(ptRawMin, ptRawMax) Then
         ptStartCurv.z = ptRawMax.z
      End If

      ' Se esiste un elemento selezionato
      EgtResetMark(m_nIdSelectedWaterJet)
      ' Verifico se selezionato indicativo di pezzo
      EgtSetObjFilterForSelWin(False, True, False, False, False)
      Dim nSelMy As Integer
      EgtSelect(e.Location, Scene.DIM_SEL, Scene.DIM_SEL, nSelMy)
      Dim nIdMy As Integer = EgtGetFirstObjInSelWin()
      While nIdMy <> GDB_ID.NULL
         Dim sLayer As String = String.Empty
         ' layer di origine
         Dim nIdParent As Integer = EgtGetParent(nIdMy)
         ' recupero il nome del Layer
         EgtGetName(nIdParent, sLayer)
         ' solo se il nome del layer è quello associato ad un lato esterno allora procedo con l'evidenziazione
         If sLayer = NAME_OUTLOOP Or sLayer = NAME_INLOOP Then
            If EgtGetType(nIdMy) = GDB_TY.CRV_ARC OrElse EgtGetType(nIdMy) = GDB_TY.CRV_COMPO OrElse EgtGetType(nIdMy) = GDB_TY.CRV_LINE Then
               ' verifico che il contorno sia chiuso, altrimenti esco
               If Not VerifyOutLoopIsClosed(nIdParent) Then
                  '91131=Il contorno non è chiuso
                  OmagOFFICEMap.refStatusBarVM.SetOutputMessage(EgtMsg(91131), MSG_TYPE.WARNING)
                  Exit While
               End If
               ' recupero il gruppo della lavorazione associata
               Dim nIdParentPart As Integer = EgtGetParent(nIdParent)
               Dim nIdPV As Integer = EgtGetFirstNameInGroup(nIdParentPart, NAME_PREVIEW)
               ' VERIFICA: recupero l'elenco delle Preview di Tipo WaterJet_n_S associate a questo Part
               Dim ListGroup As List(Of Integer) = ResearchGropuWJ(nIdParent, nIdPV)
               ' VERIFICA: se esistono delle lavorazioni associate al percorso OutLoop di tipo Saw allora non procedo
               Dim ListGroupSaw As List(Of Integer) = ResearchGropuSaw(nIdParent, nIdPV)
               ' se non esiste almeno 1 Preview di tipo WaterJet
               If ListGroup.Count = 1 And ListGroupSaw.Count = 0 Then
                  EgtSetInfo(nIdParent, INFO_START, ptStartCurv)
                  ' Ricalcolo tutte le lavorazioni
                  Dim nWarn As Integer = 0
                  ResetAllMachinings(nWarn)
                  ' recupero l'indice del PreView che deve essere acceso per indicare la selezione
                  ListGroup = ResearchGropuWJ(nIdParent, nIdPV)
                  Dim nIdWJ As Integer = GetPVIdFromIdSide(ListGroup, nIdMy)
                  GetCurrentPVFromIdSide(ListGroup, nIdMy, nIdWJ, nIdParent)
                  m_nIdSelectedWaterJet = nIdWJ
                  EgtSetMark(nIdWJ)
                  EgtDraw()
                  Exit While
               Else
                  '91131=Il contorno non è chiuso
                  OmagOFFICEMap.refStatusBarVM.SetOutputMessage(EgtMsg(91131), MSG_TYPE.WARNING)
                  Exit While
               End If

            End If
         End If
         nIdMy = EgtGetNextObjInSelWin()
      End While
      Return
   End Sub

#End Region    ' Water Start Point

   Private m_bStartCurvWJ As Boolean
   Public Property bStartCurvWJ As Boolean
      Get
         Return m_bStartCurvWJ
      End Get
      Set(value As Boolean)
         m_bStartCurvWJ = value
         If Not m_bStartCurvWJ Then
            ResetStartCurvWJParam(True)
         End If
         m_bDragRectangle = False
         m_bSplitCurvWJ = False
         ResetSplitCurvWJParam(True)
         NotifyPropertyChanged("bDragRectangle")
         NotifyPropertyChanged("bSplitCurvWJ")
      End Set
   End Property

   Public Sub ResetStartCurvWJParam(Optional bAllParam As Boolean = True)
      If bAllParam Then
         EgtDeselectObj(m_nIdSelectedSideWJ)
         EgtResetMark(m_nIdSelectedWaterJet)
      End If
      m_nIdSelectedSideWJ = GDB_ID.NULL
      m_nIdSelectedWaterJet = GDB_ID.NULL
      EgtDraw()
   End Sub

#Region "COMMANDS"

#Region "DrawCommand"

   Public ReadOnly Property DrawCommand As ICommand
      Get
         If m_cmdDraw Is Nothing Then
            m_cmdDraw = New Command(AddressOf Draw)
         End If
         Return m_cmdDraw
      End Get
   End Property

   Public Sub Draw(ByVal param As Object)
      Dim CompoWindow As New CompoWindowV(Application.Current.MainWindow, New CompoWindowVM)
      CompoWindow.Height = 700
      CompoWindow.ShowDialog()
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
   End Sub

#End Region     ' DrawCommand

#Region "ImportDxfCommand"

   Public ReadOnly Property ImportDxfCommand As ICommand
      Get
         If m_cmdImportDxf Is Nothing Then
            m_cmdImportDxf = New Command(AddressOf ImportDxf)
         End If
         Return m_cmdImportDxf
      End Get
   End Property

   Public Sub ImportDxf(ByVal param As Object)
      Dim DxfImportWindow As New DxfImportWindowV(Application.Current.MainWindow, New DxfImportWindowVM)
      DxfImportWindow.ShowDialog()
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
   End Sub

#End Region ' ImportDxfCommand

#Region "PartRotOnCommand"

   Public ReadOnly Property PartRotOnCommand As ICommand
      Get
         If m_cmdPartRotOn Is Nothing Then
            m_cmdPartRotOn = New Command(AddressOf PartRotOn)
         End If
         Return m_cmdPartRotOn
      End Get
   End Property

   Public Sub PartRotOn(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Se non ci sono pezzi selezionati o non sono in parcheggio, esco
      If EgtGetSelectedObjCount() = 0 OrElse m_nPartPos <> PART_POS.OUT_TABLE Then Return
      ' Tolgo blocco rotazione sui pezzi selezionati
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         ' Se rotazione bloccata, tolgo blocco e aggiorno info
         If EgtExistsInfo(nId, INFO_PARTROT) Then
            ' Rimuovo flag di rotazione bloccata
            EgtRemoveInfo(nId, INFO_PARTROT)
            ' Tolgo da info sul pezzo Codice
            Dim nTextId As Integer = EgtGetFirstInGroup(EgtGetFirstNameInGroup(nId, NAME_REGION))
            While nTextId <> GDB_ID.NULL
               If EgtGetType(nTextId) = GDB_TY.EXT_TEXT Then
                  Dim sText As String = ""
                  EgtTextGetContent(nTextId, sText)
                  sText = sText.Replace("<br/>(X)", "")
                  EgtModifyText(nTextId, sText)
                  Exit While
               End If
               nTextId = EgtGetNext(nTextId)
            End While
         End If
         ' Passo al successivo selezionato
         nId = EgtGetNextSelectedObj()
      End While
      ' Aggiorno visualizzazione
      EgtDraw()
   End Sub

#End Region ' PartRotOnCommand

#Region "PartRotOffCommand"

   Public ReadOnly Property PartRotOffCommand As ICommand
      Get
         If m_cmdPartRotOff Is Nothing Then
            m_cmdPartRotOff = New Command(AddressOf PartRotOff)
         End If
         Return m_cmdPartRotOff
      End Get
   End Property

   Public Sub PartRotOff(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Se non ci sono pezzi selezionati o non sono in parcheggio, esco
      If EgtGetSelectedObjCount() = 0 OrElse m_nPartPos <> PART_POS.OUT_TABLE Then Return
      ' Metto blocco rotazione sui pezzi selezionati
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         ' Se rotazione libera, applico blocco e aggiorno info
         If Not EgtExistsInfo(nId, INFO_PARTROT) Then
            ' Imposto flag di rotazione bloccata
            EgtSetInfo(nId, INFO_PARTROT, 0)
            ' Inserisco in info sul pezzo Codice
            Dim nTextId As Integer = EgtGetFirstInGroup(EgtGetFirstNameInGroup(nId, NAME_REGION))
            While nTextId <> GDB_ID.NULL
               If EgtGetType(nTextId) = GDB_TY.EXT_TEXT Then
                  Dim sText As String = ""
                  EgtTextGetContent(nTextId, sText)
                  sText &= "<br/>(X)"
                  EgtModifyText(nTextId, sText)
                  Exit While
               End If
               nTextId = EgtGetNext(nTextId)
            End While
         End If
         ' Passo al successivo selezionato
         nId = EgtGetNextSelectedObj()
      End While
      ' Aggiorno visualizzazione
      EgtDraw()
   End Sub

#End Region ' PartRotOffCommand

#Region "UpCommand"

   Public ReadOnly Property UpCommand As ICommand
      Get
         If m_cmdUp Is Nothing Then
            m_cmdUp = New Command(AddressOf Up)
         End If
         Return m_cmdUp
      End Get
   End Property

   Public Sub Up(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Aggiorno regioni per nesting
      UpdateNestRegions()
      EnableReferenceRegion(False)
      ' eseguo movimento
      Dim dStep As Double = If(m_MaxMoveIsChecked, m_dMaxStep, m_dStepMove)
      EgtMovePart(GDB_ID.SEL, CurrentMachine.bReducedCut, New Vector3d(0, dStep, 0))
      EgtSaveCollInfo()
      ' se abilitato magnetico (allineamento + snap), lo provo
      Dim bAlignMoved As Boolean = False
      Dim bSnapMoved As Boolean = False
      If m_bMagnetic Then
         If Not GetLockOnRotation(GDB_ID.SEL) Then
            EgtAlignPartOnCollision(GDB_ID.SEL, CurrentMachine.bReducedCut, bAlignMoved)
         End If
         If m_dSnapDist > EPS_SMALL Then
            EgtRestoreCollInfo()
            EgtMovePartToSnapPointOnCollision(GDB_ID.SEL, CurrentMachine.bReducedCut, m_dSnapDist, bSnapMoved)
         End If
      End If
      EstCalc.ResetOrderMachiningFlag()
      EgtDraw()
      ' Eventuale notifica al VeinMatching
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         VeinMatching.OnMovePartInRaw(nId)
         nId = EgtGetNextSelectedObj()
      End While
   End Sub

#End Region ' UpCommand

#Region "LeftCommand"

   Public ReadOnly Property LeftCommand As ICommand
      Get
         If m_cmdLeft Is Nothing Then
            m_cmdLeft = New Command(AddressOf Left)
         End If
         Return m_cmdLeft
      End Get
   End Property

   Public Sub Left(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Aggiorno regioni per nesting
      UpdateNestRegions()
      EnableReferenceRegion(False)
      ' eseguo movimento
      Dim dStep As Double = If(m_MaxMoveIsChecked, m_dMaxStep, m_dStepMove)
      EgtMovePart(GDB_ID.SEL, CurrentMachine.bReducedCut, New Vector3d(-dStep, 0, 0))
      EgtSaveCollInfo()
      ' se abilitato magnetico (allineamento + snap), lo provo
      Dim bAlignMoved As Boolean = False
      Dim bSnapMoved As Boolean = False
      If m_bMagnetic Then
         If Not GetLockOnRotation(GDB_ID.SEL) Then
            EgtAlignPartOnCollision(GDB_ID.SEL, CurrentMachine.bReducedCut, bAlignMoved)
         End If
         If m_dSnapDist > EPS_SMALL Then
            EgtRestoreCollInfo()
            EgtMovePartToSnapPointOnCollision(GDB_ID.SEL, CurrentMachine.bReducedCut, m_dSnapDist, bSnapMoved)
         End If
      End If
      EstCalc.ResetOrderMachiningFlag()
      EgtDraw()
      ' Eventuale notifica al VeinMatching
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         VeinMatching.OnMovePartInRaw(nId)
         nId = EgtGetNextSelectedObj()
      End While
   End Sub

#End Region ' LeftCommand

#Region "RightCommand"

   Public ReadOnly Property RightCommand As ICommand
      Get
         If m_cmdRight Is Nothing Then
            m_cmdRight = New Command(AddressOf Right)
         End If
         Return m_cmdRight
      End Get
   End Property

   Public Sub Right(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Aggiorno regioni per nesting
      UpdateNestRegions()
      EnableReferenceRegion(False)
      ' eseguo movimento
      Dim dStep As Double = If(m_MaxMoveIsChecked, m_dMaxStep, m_dStepMove)
      EgtMovePart(GDB_ID.SEL, CurrentMachine.bReducedCut, New Vector3d(dStep, 0, 0))
      EgtSaveCollInfo()
      ' se abilitato magnetico (allineamento + snap), lo provo
      Dim bAlignMoved As Boolean = False
      Dim bSnapMoved As Boolean = False
      If m_bMagnetic Then
         If Not GetLockOnRotation(GDB_ID.SEL) Then
            EgtAlignPartOnCollision(GDB_ID.SEL, CurrentMachine.bReducedCut, bAlignMoved)
         End If
         If m_dSnapDist > EPS_SMALL Then
            EgtRestoreCollInfo()
            EgtMovePartToSnapPointOnCollision(GDB_ID.SEL, CurrentMachine.bReducedCut, m_dSnapDist, bSnapMoved)
         End If
      End If
      EstCalc.ResetOrderMachiningFlag()
      EgtDraw()
      ' Eventuale notifica al VeinMatching
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         VeinMatching.OnMovePartInRaw(nId)
         nId = EgtGetNextSelectedObj()
      End While
   End Sub

#End Region ' RightCommand

#Region "DownCommand"

   Public ReadOnly Property DownCommand As ICommand
      Get
         If m_cmdDown Is Nothing Then
            m_cmdDown = New Command(AddressOf Down)
         End If
         Return m_cmdDown
      End Get
   End Property

   Public Sub Down(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Aggiorno regioni per nesting
      UpdateNestRegions()
      EnableReferenceRegion(False)
      ' eseguo movimento
      Dim dStep As Double = If(m_MaxMoveIsChecked, m_dMaxStep, m_dStepMove)
      EgtMovePart(GDB_ID.SEL, CurrentMachine.bReducedCut, New Vector3d(0, -dStep, 0))
      EgtSaveCollInfo()
      ' se abilitato magnetico (allineamento + snap), lo provo
      Dim bAlignMoved As Boolean = False
      Dim bSnapMoved As Boolean = False
      If m_bMagnetic Then
         If Not GetLockOnRotation(GDB_ID.SEL) Then
            EgtAlignPartOnCollision(GDB_ID.SEL, CurrentMachine.bReducedCut, bAlignMoved)
         End If
         If m_dSnapDist > EPS_SMALL Then
            EgtRestoreCollInfo()
            EgtMovePartToSnapPointOnCollision(GDB_ID.SEL, CurrentMachine.bReducedCut, m_dSnapDist, bSnapMoved)
         End If
      End If
      EstCalc.ResetOrderMachiningFlag()
      EgtDraw()
      ' Eventuale notifica al VeinMatching
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         VeinMatching.OnMovePartInRaw(nId)
         nId = EgtGetNextSelectedObj()
      End While
   End Sub

#End Region ' DownCommand

#Region "CClockwiseRotCommand"

   Public ReadOnly Property CClockwiseRotCommand As ICommand
      Get
         If m_cmdCClockwiseRot Is Nothing Then
            m_cmdCClockwiseRot = New Command(AddressOf CClockwiseRot)
         End If
         Return m_cmdCClockwiseRot
      End Get
   End Property

   Public Sub CClockwiseRot(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      RotateCluster(m_dRotationAngle)
      EstCalc.ResetOrderMachiningFlag()
      EgtDraw()
      ' Eventuale notifica al VeinMatching
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         VeinMatching.OnMovePartInRaw(nId)
         nId = EgtGetNextSelectedObj()
      End While
   End Sub

#End Region ' CClockwiseRotCommand

#Region "ClockwiseRotCommand"

   Public ReadOnly Property ClockwiseRotCommand As ICommand
      Get
         If m_cmdClockwiseRot Is Nothing Then
            m_cmdClockwiseRot = New Command(AddressOf ClockwiseRot)
         End If
         Return m_cmdClockwiseRot
      End Get
   End Property

   Public Sub ClockwiseRot(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      RotateCluster(-m_dRotationAngle)
      EstCalc.ResetOrderMachiningFlag()
      EgtDraw()
      ' Eventuale notifica al VeinMatching
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         VeinMatching.OnMovePartInRaw(nId)
         nId = EgtGetNextSelectedObj()
      End While
   End Sub

#End Region ' ClockwiseRotCommand

#Region "InsertPartCommand"

   Public ReadOnly Property InsertPartCommand As ICommand
      Get
         If m_cmdInsertPart Is Nothing Then
            m_cmdInsertPart = New Command(AddressOf InsertPart)
         End If
         Return m_cmdInsertPart
      End Get
   End Property

   Public Sub InsertPart(ByVal param As Object)
      ' Se inserimento automatico
      If CurrentMachine.bAutomatic And
         OmagOFFICEMap.refMainWindowVM.MainWindowM.AutoNestOption() Then
         AutomaticInsert()
         ' altrimenti inserimento standard
      Else
         StandardInsert()
      End If
   End Sub

#End Region ' InsertPartCommand

#Region "StorePartCommand"

   Public ReadOnly Property StorePartCommand As ICommand
      Get
         If m_cmdStorePart Is Nothing Then
            m_cmdStorePart = New Command(AddressOf StorePart)
         End If
         Return m_cmdStorePart
      End Get
   End Property

   Public Sub StorePart(ByVal param As Object)
      ' creo la lista delle famiglie di pezzi presenti in parcheggio
      GetFamilyGroupInPark()
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Ciclo di parcheggio dei pezzi selezionati
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         ' Recupero indice del successivo
         Dim nNextId As Integer = EgtGetNextSelectedObj()
         ' Metto in parcheggio, se in grezzo
         EstCalc.StoreOnePart(nId)
         ' Eventuale notifica al VeinMatching
         VeinMatching.OnRemovePartFromRaw(nId)
         ' Passo al successivo selezionato
         nId = nNextId
      End While
      ' Imposto flag posizione pezzi su parcheggio
      m_nPartPos = PART_POS.OUT_TABLE
      ' Aggiorno vista
      EgtZoom(ZM.ALL)
   End Sub

#End Region ' StorePartCommand

#Region "RemovePartCommand"

   Public ReadOnly Property RemovePartCommand As ICommand
      Get
         If m_cmdRemovePart Is Nothing Then
            m_cmdRemovePart = New Command(AddressOf RemovePart)
         End If
         Return m_cmdRemovePart
      End Get
   End Property

   Public Sub RemovePart()
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Se non ci sono pezzi selezionati, esco subito
      If EgtGetFirstSelectedObj() = GDB_ID.NULL Then Return
      ' Chiedo conferma prima di procedere
      If MessageBox.Show(EgtMsg(MSG_EGTMSGBOX + 21), "", MessageBoxButton.OKCancel, MessageBoxImage.Question) = MessageBoxResult.Cancel Then Return
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Verifico se ci sono pezzi provenienti da liste Csv
      Dim bCsvParts As Boolean = False
      Dim nId As Integer = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         If EgtExistsInfo(nId, INFO_CSV_PATH) Then
            bCsvParts = True
            Exit While
         End If
         nId = EgtGetNextSelectedObj()
      End While
      ' Chiedo se si vogliono cancellare anche questi pezzi
      Dim bEraseCsvParts As Boolean = False
      If bCsvParts Then
         ' Vuoi cancellare anche i pezzi da lista Csv ? 
         Select Case MessageBox.Show(EgtMsg(MSG_EGTMSGBOX + 12), "", MessageBoxButton.YesNoCancel, MessageBoxImage.Question)
            Case MessageBoxResult.Cancel
               Return
            Case MessageBoxResult.Yes
               bEraseCsvParts = True
            Case MessageBoxResult.No
               bEraseCsvParts = False
         End Select
         EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      End If
      ' Ciclo di cancellazione dei pezzi selezionati
      nId = EgtGetFirstSelectedObj()
      While nId <> GDB_ID.NULL
         '' elimino eventuali ponticelli associati al pezzo: non è gestito il movimento del pezzo
         'DeleteBridgeAssociated(nId)
         ' se è stato eseguito il Drag allora cancello tutti i ponticelli
         ResetAllBridges()
         ' Recupero indice del successivo
         Dim nNextId = EgtGetNextSelectedObj()
         ' Se abilitata cancellazione in ogni caso o pezzo non da Csv
         If bEraseCsvParts OrElse Not EgtExistsInfo(nId, INFO_CSV_PATH) Then
            ' Se pezzo in parcheggio cancello direttamente
            If EgtIsPart(nId) Then
               '---------------------- COUNTER PART ----------------------
               Dim sRefGroup As String = String.Empty
               ' recupero l'GUID del gruppo 
               EgtGetInfo(nId, INFO_REFGROUP, sRefGroup)
               '---------------------- COUNTER PART ----------------------
               ' Eventuale notifica al VeinMatching
               VeinMatching.OnRemovePart(nId, False)
               ' Rimuovo le lavorazioni
               EraseMachinings(nId)
               ' Cancello
               EgtErase(nId)
               ' aggiorno il layer che indica il numero di pezzi in parcheggio (se sRefGroup<>"")
               CountPartInFamily(sRefGroup)
               ' Altrimenti pezzo nel grezzo
            ElseIf EgtGetParent(nId) = EstCalc.GetRawId() Then
               If EgtRemovePartFromRawPart(nId) Then
                  ' Eventuale notifica al VeinMatching
                  VeinMatching.OnRemovePart(nId, False)
                  ' Rimuovo le lavorazioni
                  EraseMachinings(nId)
                  'Cancello
                  EgtErase(nId)
               End If
            End If
         End If
         ' Passo al successivo selezionato
         nId = nNextId
      End While
      ' Imposto flag posizione pezzi
      m_nPartPos = PART_POS.NONE_TABLE
      ' Aggiorno viste
      EgtZoom(ZM.ALL)
      VeinMatching.Draw()
   End Sub

   Private Sub DeleteBridgeAssociated(nMyId As Integer)
      ' verifico se esistono dei ponticelli associati al pezzo indicato
      ' recuoero il gruppo di lavorazione corrente
      Dim nIdCurrMachGroup As Integer = EgtGetCurrMachGroup()
      ' creo il gruppo per i ponticelli
      Dim sNameGroup As String = NAME_BRIDGES
      Dim nIdBridgesGroup As Integer = EgtGetFirstNameInGroup(nIdCurrMachGroup, sNameGroup)
      If nIdBridgesGroup <> GDB_ID.NULL Then
         ' carico la prima entità del gruppo BRIDGES
         Dim nIdBridgeLine As Integer = GDB_ID.NULL
         nIdBridgeLine = EgtGetFirstNameInGroup(nIdBridgesGroup, NAME_BRIDGESLINE)
         ' ciclo su tutte le entità
         While nIdBridgeLine <> GDB_ID.NULL
            Dim nNextBridgeLine As Integer = GDB_ID.NULL
            Dim nIdPart As Integer = GDB_ID.NULL
            If EgtGetInfo(nIdBridgeLine, "PartStart", nIdPart) Then
               If nIdPart = nMyId Then
                  nNextBridgeLine = EgtGetNext(nIdBridgeLine)
                  ' il ponticello deve essere eliminato
                  EgtErase(nIdBridgeLine)
                  nIdBridgeLine = nNextBridgeLine
                  ' riparto dall'inizio del ciclo
                  Continue While
               End If
            End If
            If EgtGetInfo(nIdBridgeLine, "PartEnd", nIdPart) Then
               If nIdPart = nMyId Then
                  nNextBridgeLine = EgtGetNext(nIdBridgeLine)
                  ' il ponticello deve essere eliminato
                  EgtErase(nIdBridgeLine)
                  nIdBridgeLine = nNextBridgeLine
                  ' riparto dall'inizio del ciclo
                  Continue While
               End If
            End If
            ' il BridgeLine corrente non contiene riferimeti al pezzo da eliminare
            nIdBridgeLine = EgtGetNext(nIdBridgeLine)
         End While
      End If
   End Sub

#End Region ' RemovePartCommand

#Region "SelectAllCommand"

   Public ReadOnly Property SelectAllCommand As ICommand
      Get
         If m_cmdSelectAll Is Nothing Then
            m_cmdSelectAll = New Command(AddressOf SelectAll)
         End If
         Return m_cmdSelectAll
      End Get
   End Property

   Public Sub SelectAll(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Numero dei pezzi in tavola
      Dim nPartTab As Integer = EgtGetPartInRawPartCount(GetRawId())
      ' Se già selezionati in tavola o non ci sono selezionati e pezzi in tavola
      If m_nPartPos = PART_POS.IN_TABLE Or
         (m_nPartPos = PART_POS.NONE_TABLE And nPartTab > 0) Then
         ' Seleziono tutti i pezzi in tavola
         Dim nPartId As Integer = EgtGetFirstGroupInGroup(GetRawId())
         While nPartId <> GDB_ID.NULL
            EgtSelectObj(nPartId)
            VeinMatching.OnSelectPart(nPartId, False)
            nPartId = EgtGetNextGroup(nPartId)
         End While
         ' Aggiorno flag
         m_nPartPos = If(EgtGetSelectedObjCount() > 0, PART_POS.IN_TABLE, PART_POS.NONE_TABLE)
         ' Altrimenti
      Else
         ' Seleziono tutti i pezzi in parcheggio
         Dim nPartId As Integer = EgtGetFirstPart()
         While nPartId <> GDB_ID.NULL
            If PartIsFree(nPartId) Then
               EgtSelectObj(nPartId)
               VeinMatching.OnSelectPart(nPartId, False)
            End If
            nPartId = EgtGetNextPart(nPartId)
         End While
      End If
      ' Aggiorno viste
      EgtDraw()
      VeinMatching.Draw()
   End Sub

#End Region ' SelectAllCommand

#Region "DeselectAllCommand"

   Public ReadOnly Property DeselectAllCommand As ICommand
      Get
         If m_cmdDeselectAll Is Nothing Then
            m_cmdDeselectAll = New Command(AddressOf DeselectAll)
         End If
         Return m_cmdDeselectAll
      End Get
   End Property

   Public Sub DeselectAll(ByVal param As Object)
      DeselectAllParts(True)
      ' Aggiorno vista
      EgtDraw()
   End Sub

#End Region ' DeselectAllCommand

#Region "ResetCommand"

   Public ReadOnly Property ResetCommand As ICommand
      Get
         If m_cmdReset Is Nothing Then
            m_cmdReset = New Command(AddressOf Reset)
         End If
         Return m_cmdReset
      End Get
   End Property

   Public Sub Reset(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Cancello eventuali messaggi
      OmagOFFICEMap.refStatusBarVM.ClearOutputMessage()
      ' cancello tutti i tagli di separazione 
      ResetAllSplitCurv()
      ' cancello tutti i punti di inizio (Waterjet)
      ResetAllStartCurv()
      ' cancello tutti i ponticelli disegnati
      ResetAllBridges()
      ' cancello tutti i tagli di separazione disegnati
      ResetAllSplitCut()
      ' Cancello tutte le lavorazioni
      CamAuto.EraseMachinings(GDB_ID.NULL)
      ' Reinserisco tutte le lavorazioni piane
      CamAuto.AddMachinings(GDB_ID.NULL)
      ' Aggiorno visualizzazione
      EgtDraw()
   End Sub

#End Region ' ResetCommand

#Region "CsvDataCommand"

   Public ReadOnly Property CsvDataCommand As ICommand
      Get
         If m_cmdCsvData Is Nothing Then
            m_cmdCsvData = New Command(AddressOf CsvData)
         End If
         Return m_cmdCsvData
      End Get
   End Property

   Public Sub CsvData(ByVal param As Object)
      EgtSetCurrentContext(OmagOFFICEMap.refSceneHostVM.MainScene.GetCtx())
      ' Cancello eventuali messaggi
      OmagOFFICEMap.refStatusBarVM.ClearOutputMessage()
      ' Cerco il primo pezzo selezionato
      Dim nPartId As Integer = EgtGetFirstSelectedObj()
      If nPartId = GDB_ID.NULL Then Return
      ' Deseleziono eventuali altri
      If EgtGetNextSelectedObj() <> GDB_ID.NULL Then
         EgtDeselectAll()
         EgtSelectObj(nPartId)
         EgtDraw()
      End If
      ' Recupero dati del pezzo
      Dim sCsvOrder As String = "" : EgtGetInfo(nPartId, INFO_CSV_ORD, sCsvOrder)
      Dim sCsvList As String = "" : EgtGetInfo(nPartId, INFO_CSV_DIST, sCsvList)
      Dim sCsvName As String = "" : EgtGetInfo(nPartId, INFO_CSV_PART, sCsvName)
      ' Avvio dialogo modifica
      Dim DlgCsvDataVM As New CompoCsvDataWindowVM()
      Dim DlgCsvDataV As New CompoCsvDataWindowV(Application.Current.MainWindow, DlgCsvDataVM)
      DlgCsvDataVM.SetData(sCsvOrder, sCsvList, sCsvName)
      If DlgCsvDataV.ShowDialog() Then
         ' Recupero i nuovi dati
         Dim sNewOrder As String = ""
         Dim sNewList As String = ""
         Dim sNewName As String = ""
         DlgCsvDataVM.GetData(sNewOrder, sNewList, sNewName)
         ' Assegno i nuovi dati
         EgtSetInfo(nPartId, INFO_CSV_ORD, sNewOrder)
         EgtSetInfo(nPartId, INFO_CSV_DIST, sNewList)
         EgtSetInfo(nPartId, INFO_CSV_PART, sNewName)
         ' Se necessario, modifico la scritta
         If sNewName <> sCsvName Then
            Dim nRegLayId As Integer = EgtGetFirstNameInGroup(nPartId, NAME_REGION)
            Dim nTextId = EgtGetFirstInGroup(nRegLayId)
            While nTextId <> GDB_ID.NULL
               If EgtGetType(nTextId) = GDB_TY.EXT_TEXT Then
                  Dim sText As String = String.Empty
                  EgtTextGetContent(nTextId, sText)
                  Dim nPos As Integer = sText.IndexOf(sCsvName)
                  Dim sNewText As String
                  If nPos < 0 Then
                     sNewText = sNewName & "<br/>" & sText
                  Else
                     sNewText = sText.Remove(nPos, sCsvName.Length()).Insert(nPos, sNewName)
                  End If
                  EgtModifyText(nTextId, sNewText)
                  VeinMatching.ModifyPartText(nPartId, sNewText)
                  Exit While
               End If
               nTextId = EgtGetNext(nTextId)
            End While
         End If
      End If
      ' Aggiorno visualizzazione
      EgtDraw()
   End Sub

#End Region ' CsvDataCommand

#End Region    ' COMMANDS

#Region "EVENTS"

   Friend Sub OnMouseDownScene(sender As Object, e As Windows.Forms.MouseEventArgs)
      ' se in modalità DragRectangle (deformazione delle componenti rettangolari)
      If m_bDragRectangle Then
         OnMyMouseDownSceneSelSideRectangle(sender, e)
         ' Dati per drag (abilito il Drag)
         m_locPrev = e.Location
         m_bDrag = EgtUnProjectPoint(e.Location, m_ptPrev) And m_nIdSelectedCurvRectangle <> GDB_ID.NULL
         m_bDragToStart = m_bDrag
         m_bVerify = m_bDrag AndAlso (Keyboard.Modifiers And ModifierKeys.Shift) > 0
         m_vtTotMove = Vector3d.NULL()
         Return
      End If
      ' se in modalità separazione curve WaterJet
      If m_bSplitCurvWJ Then
         OnMyMouseDownSceneSplitCurv(sender, e)
         Return
      End If
      ' se in modalità punto inizio curve WaterJet
      If m_bStartCurvWJ Then
         OnMyMouseDownSceneStartCurv(sender, e)
         Return
      End If

      ' Per default no drag
      m_bDrag = False
      ' Verifico se selezionato indicativo di pezzo
      EgtSetObjFilterForSelWin(True, True, True, True, True)
      Dim nSel As Integer
      EgtSelect(e.Location, Scene.DIM_SEL, Scene.DIM_SEL, nSel)
      Dim nId As Integer = EgtGetFirstObjInSelWin()
      While nId <> GDB_ID.NULL
         ' Recupero l'identificativo del pezzo cui appartiene
         Dim nPartId As Integer = EgtGetParent(EgtGetParent(nId))
         Dim sNamePartId As String = String.Empty
         EgtGetName(nPartId, sNamePartId)
         Dim bPartInTable As Boolean = (EgtGetParent(nPartId) = GetRawId())
         If EgtIsPart(nPartId) Or bPartInTable Then
            Dim nStat As Integer = GDB_ST.ON_
            EgtGetStatus(nPartId, nStat)

            ' verifico se l'lemento selezionato è il numero di pezzi
            If EgtGetType(nId) = GDB_TY.EXT_TEXT Then
               Dim NameLayer As String = String.Empty
               EgtGetName(EgtGetParent(nId), NameLayer)
               If NameLayer = INFO_COUNTERLY Then
                  Dim sText As String = String.Empty
                  If EgtTextGetContent(nId, sText) Then
                     Dim sItems() As String = sText.Split("#"c)
                     If sItems.Count > 1 Then
                        m_nCurrNubrOfParts = 0
                        If StringToInt(sItems(1), m_nCurrNubrOfParts) Then
                           m_bIsCounterLy = True
                           m_nIdToSel = nPartId
                        End If
                     End If
                  End If
               End If
            End If

            If Not m_bIsCounterLy Then
               ' Se già selezionato o posizione oggetto incompatibile con flag posizione selezionati
               If nStat = GDB_ST.SEL Then
                  ' Memorizzo Id da deselezionare
                  m_nIdToDesel = nPartId
               Else
                  ' Memorizzo Id da selezionare
                  m_nIdToSel = nPartId
               End If
            End If
            ' Drag possibile
            m_bDrag = True
            Exit While

         Else
            ' verifico se l'elemento selezionato è il nome della tavola
            If EgtGetType(nId) = GDB_TY.EXT_TEXT AndAlso (sNamePartId = MAIN_TAB Or
                                                          sNamePartId = SECOND_TAB Or
                                                          sNamePartId = THIRD_TAB Or
                                                          sNamePartId = FORTH_TAB) Then

               ' Apro la finestra per la selezione della tavola da usare
               Dim ChgTbV As New ChangeTableV
               Dim ChgTbVM As New ChangeTableVM(ChgTbV)
               ChgTbV.DataContext = ChgTbVM
               ChgTbV.ShowDialog()

               ' se non è stata eseguita nessuna scelta esco dal ciclo 
               If ChgTbVM.MyDialogResult = EnumDialogResult.CANCEL Or ChgTbVM.nSelectedTable = 0 Then Exit While

               ' recupero il nome della tavola corrente
               Dim sOtherTab As String = GetTableName(ChgTbVM.nSelectedTable)

               EgtChangeTable(sOtherTab, True)
               EstCalc.AdjustAdditionalTable(True)
               EgtSetMachineLook(MCH_LOOK.TAB)
               ' aggiorno le lavorazioni
               UpdateAllMachiningsToolpaths()
               ' aggiorno i movimenti pezzi tra disposizioni
               For nI As Integer = 1 To EgtGetPhaseCount()
                  EgtSetCurrPhase(nI)
                  Dim nDispId As Integer = EgtGetPhaseDisposition(nI)
                  SpecialApplyDisposition(nDispId, True)
               Next
               ' aggiorno posizionamento ventose per lavorazioni da sotto
               UpdateVacuumsForDrip()
               ' dichiaro tutto aggiornato
               EstCalc.SetOrderMachiningFlag()
               EgtSetCurrPhase(1)
               ' aggiorno posizione pezzi in parcheggio
               Dim nPPId As Integer = EgtGetFirstPart()
               While nPPId <> GDB_ID.NULL
                  PackPartInStore(nPPId)
                  nPPId = EgtGetNextPart(nPPId)
               End While
               ' se prevista rotazione
               If GetPrivateProfileInt(S_TABLE, K_CHANGETABWD, 0, CurrentMachine.sMachIniFile) = 2 Then
                  ' Dati tavola
                  Dim b3Tab As New BBox3d
                  EgtGetTableArea(1, b3Tab)
                  ' Box lastra
                  Dim b3OrigRaw As New BBox3d
                  GetRawBox(b3OrigRaw)
                  ' Allargo i limiti della tavola in tutte le fasi
                  Const TAB_OFFS As Double = 3000
                  For nI As Integer = 1 To EgtGetPhaseCount()
                     EgtSetCurrPhase(nI)
                     EgtSetTableAreaOffset(TAB_OFFS, TAB_OFFS, TAB_OFFS, TAB_OFFS)
                  Next
                  ' aggiorno posizionamento ventose per lavorazioni da sotto
                  UpdateVacuumsForDrip()
                  ' dichiaro tutto aggiornato
                  EstCalc.SetOrderMachiningFlag()
                  EgtSetCurrPhase(1)
                  ' Rotazione
                  Dim dAngRot As Double = If(sOtherTab = SECOND_TAB, 180, -180)
                  If Not RotateAllRawParts(dAngRot, False) Then
                     'm_CurrProjPage.SetWarningMessage(EgtMsg(90339))        'Rotazione impossibile
                  End If
                  ' Traslazione per riportare la lastra nella stessa posizione rispetto all'angolo BL che diveta TR e viceversa
                  Dim b3Raw As New BBox3d
                  GetRawBox(b3Raw)
                  Dim vtMove As Vector3d
                  If sOtherTab = SECOND_TAB Then
                     Dim vtDiffIni As Vector3d = b3OrigRaw.Min() - b3Tab.Min()
                     Dim vtDiffFin As Vector3d = b3Tab.Max() - b3Raw.Max()
                     vtMove = vtDiffFin - vtDiffIni
                  Else
                     Dim vtDiffIni As Vector3d = b3Tab.Max() - b3OrigRaw.Max()
                     Dim vtDiffFin As Vector3d = b3Raw.Min() - b3Tab.Min()
                     vtMove = -(vtDiffFin - vtDiffIni)
                  End If
                  vtMove.z = 0
                  MoveAllRawParts(vtMove)
                  ' Ripristino i limiti della tavola in tutte le fasi
                  For nI As Integer = 1 To EgtGetPhaseCount()
                     EgtSetCurrPhase(nI)
                     EgtSetTableAreaOffset(0, 0, 0, 0)
                  Next
                  EgtSetCurrPhase(1)
                  HideAllMachinings()
               End If

               ' visualizzazione
               EgtZoom(ZM.ALL)
               ' Elimino il datacontext della finsetra per la selezione della tavola
               ChgTbVM = Nothing
               Exit While
            End If
         End If
         nId = EgtGetNextObjInSelWin()
      End While
      ' Dati per drag
      m_locPrev = e.Location
      m_bDrag = m_bDrag AndAlso EgtUnProjectPoint(e.Location, m_ptPrev)
      m_bDragToStart = m_bDrag
      m_bVerify = m_bDrag AndAlso (Keyboard.Modifiers And ModifierKeys.Shift) > 0
      m_bKeyLeftShiftPressed = m_bVerify
      m_vtTotMove = Vector3d.NULL()
   End Sub

   Friend Sub OnMouseMoveScene(sender As Object, e As System.Windows.Forms.MouseEventArgs)
      ' Se drag non abilitato o già in esecuzione, esco
      If Not m_bDrag Or m_bDragging Then Return
      ' Se primo movimento di drag, verifico di aver superato la soglia di movimento in pixel
      If m_bDragToStart Then
         If Math.Abs(e.Location.X - m_locPrev.X) < m_nRestRadius And
            Math.Abs(e.Location.Y - m_locPrev.Y) < m_nRestRadius Then
            Return
         End If
         m_bDragToStart = False
      End If

      ' se devo muovere un lato del rettangolo
      If m_bDragRectangle Then
         OnMyMouseMoveSawRectangle(sender, e)
         Return
      End If

      ' Determino cosa muovere
      Dim nMoveId = If(m_nIdToSel <> GDB_ID.NULL, m_nIdToSel, GDB_ID.SEL)
      ' Verifico se in tavola o in parcheggio
      Dim nTestId = If(nMoveId <> GDB_ID.SEL, nMoveId, EgtGetFirstSelectedObj())
      If EgtGetParent(nTestId) <> GetRawId() Then
         ' Dal parcheggio ammesso drag di un singolo pezzo
         If nMoveId = GDB_ID.SEL Then Return
         ' Se pezzo Trf, verifico compatibilità
         If Not VerifyTrfData(nTestId) Then
            ' Pezzi con spessore, materiale o finitura non compatibili
            OmagOFFICEMap.refStatusBarVM.SetOutputMessage(EgtMsg(MSG_NESTPAGEUC + 7), MSG_TYPE.WARNING)
         End If
         ' Applico le lavorazioni al pezzo
         Dim b3Curr As New BBox3d
         EgtGetBBoxGlob(EgtGetFirstNameInGroup(nTestId, NAME_REGION), BBFLAG, b3Curr)
         If Not EstCalc.PreInsertOnePart(nTestId) Then Return
         Dim b3Ins As New BBox3d
         EgtGetBBoxGlob(EgtGetFirstNameInGroup(nTestId, NAME_REGION), BBFLAG, b3Ins)
         Dim vtDiff As New Vector3d(b3Curr.Min().x - b3Ins.Min().x, b3Curr.Min().y - b3Ins.Min().y, 0)
         EgtMove(nMoveId, vtDiff)

         '---------------------- COUNTER PART ----------------------
         ' aggiorno contatore pezzi
         Dim sRefGroup As String = String.Empty
         If EgtGetInfo(nMoveId, INFO_REFGROUP, sRefGroup) Then
            ' spengo il layer che contiene il contatore
            Dim nCounterLayer As Integer = EgtGetFirstNameInGroup(nMoveId, INFO_COUNTERLY)
            EgtSetStatus(nCounterLayer, GDB_ST.OFF)
            ' aggiorno il layer che indica il numero di pezzi in parcheggio
            CountPartInFamily(sRefGroup)
         End If
         '---------------------- COUNTER PART ----------------------

         ' Gestione VeinMatching
         VeinMatching.OnInsertPartInRaw(nMoveId)
         ' Imposto stato
         m_bVerify = True
         m_bFromParking = True
      End If
      ' Inizio esecuzione di drag
      m_bDragging = True
      ' Ricavo il punto corrente in coordinate mondo
      Dim ptCurr As Point3d
      EgtUnProjectPoint(e.Location, ptCurr)

      ' la rotazione è attivabile solo se premuto il tasto Ctrl (e non sono in parheggio)
      m_bKeyCtrlPressed = m_bDrag AndAlso (Keyboard.Modifiers And ModifierKeys.Control) > 0

      '-------------Inizio ROTAZIONE ----------------
      If m_bKeyCtrlPressed AndAlso (Not m_bFromParking OrElse m_bKeyLeftShiftPressed) Then
         ' Calcolo il centro di rotazione come centro del cluster
         Dim ptCen As Point3d
         If Not EgtGetPartPartClusterCenterGlob(nMoveId, ptCen) Then Return
         ' definisco il vettore dal centro del pezzo alla posizione del cursore
         Dim vtCurr As Vector3d = ptCurr - ptCen
         Dim dLen, dHAng, dVAng As Double
         ' recupero l'angolo orizzontale del vettore
         vtCurr.ToSpherical(dLen, dHAng, dVAng)
         If Not m_bStartRot Then
            m_dAngTotal = 0
            ' notifico una rotazione
            m_bStartRot = True
            m_dStartAng = dVAng
         End If
         Dim dDeltaAng As Double = dVAng - m_dStartAng
         ' gestione del passaggio da 0° → 360° evitando mantenendo la visualizzazione fluida
         If Math.Abs(dDeltaAng) > 90 Then
            If m_dStartAng < 180 And dVAng > 180 Then
               dDeltaAng = dVAng - 360 - m_dStartAng
            ElseIf m_dStartAng > 180 And dVAng < 180 Then
               dDeltaAng = dVAng - m_dStartAng + 360
            End If
         End If
         ' Rotazione del pezzo attorno al suo centro
         If Math.Abs(dDeltaAng) > EPS_ANG_SMALL Then
            ' se il tasto Shift è premuto (disabilitato il controllo collisioni durante il Drag) 
            If m_bKeyLeftShiftPressed Then
               EgtRotate(nMoveId, ptCen, Vector3d.Z_AX(), dDeltaAng, GDB_RT.GLOB)
               m_dAngTotal += dDeltaAng
            Else
               ' esegue la rotazione fino ad incontrare un altro pezzo
               RotatePartInsideBond(dDeltaAng, nMoveId)
               EstCalc.ResetOrderMachiningFlag()
               ' Eventuale notifica al VeinMatching
               Dim nId As Integer = EgtGetFirstSelectedObj()
               While nId <> GDB_ID.NULL
                  VeinMatching.OnMovePartInRaw(nId)
                  nId = EgtGetNextSelectedObj()
               End While
            End If
            m_dStartAng = dVAng
         End If
         '-------------Fine ROTAZIONE ----------------

      Else
         ' -------------Inizio TRASLAZIONE ---------------
         ' Ricavo il vettore di movimento
         Dim vtMove As Vector3d = ptCurr - m_ptPrev
         ' Muovo i pezzi selezionati di quanto possibile
         If vtMove.SqLen() > EPS_SMALL * EPS_SMALL Then
            ' notifico una traslazione
            If Not m_bStartMove Then
               m_bStartMove = True
            End If

            ' Se movimento con sola verifica finale (disabilitato il controllo collisioni durante il Drag)
            If m_bVerify Then
               EgtMove(nMoveId, vtMove)
               m_vtTotMove += vtMove
               ' altrimenti caso con verifica durante il movimento
            Else
               ' Aggiorno regioni per nesting
               UpdateNestRegions()
               EnableReferenceRegion(False)
               ' muovo il pezzo
               EgtMovePart(nMoveId, CurrentMachine.bReducedCut, vtMove)
               EgtSaveCollInfo()
               ' se movimento risultante nullo, provo con movimento tangente
               Dim bTgMoved As Boolean = False
               If vtMove.IsSmall() Then
                  ' riprovo con movimento tangente
                  Dim vtTgMove As Vector3d = ptCurr - m_ptPrev
                  EgtTgMovePartOnCollision(nMoveId, CurrentMachine.bReducedCut, vtTgMove)
                  bTgMoved = (Not vtTgMove.IsSmall())
               End If
               ' se abilitato magnetico (allineamento + snap), lo provo
               Dim bAlignMoved As Boolean = False
               Dim bSnapMoved As Boolean = False
               If m_bMagnetic Then
                  If Not GetLockOnRotation(nMoveId) Then
                     EgtAlignPartOnCollision(nMoveId, CurrentMachine.bReducedCut, bAlignMoved)
                  End If
                  If m_dSnapDist > EPS_SMALL Then
                     EgtRestoreCollInfo()
                     EgtMovePartToSnapPointOnCollision(nMoveId, CurrentMachine.bReducedCut, m_dSnapDist, bSnapMoved)
                  End If
               End If
               EstCalc.ResetOrderMachiningFlag()
            End If
            ' -------------Fine TRASLAZIONE ---------------
         End If
      End If

      EgtDraw()
      ' Eventuale notifica al VeinMatching
      If m_bStartMove OrElse m_bStartRot Then
         If nMoveId = GDB_ID.SEL Then
            Dim nId As Integer = EgtGetFirstSelectedObj()
            While nId <> GDB_ID.NULL
               VeinMatching.OnMovePartInRaw(nId)
               nId = EgtGetNextSelectedObj()
            End While
         Else
            VeinMatching.OnMovePartInRaw(nMoveId)
         End If
      End If
      ' Aggiorno il punto precedente
      m_ptPrev = ptCurr
      ' Terminata esecuzione di drag
      m_bDragging = False
      ' se è stato eseguito il Drag allora cancello tutti i ponticelli
      ResetAllBridges()
      ' non è gestito il movimento della lavorazione!
      'DeleteBridgeAssociated(nMoveId)
   End Sub

   Friend Sub OnMouseUpScene(sender As Object, e As System.Windows.Forms.MouseEventArgs)
      If m_bDragRectangle Then
         ' deseleziono gli oggeti, resetto le variabili usate, aggiorno il disegno
         ResetDragRectangleParam()
         Return
      End If
      ' verifico che sia attivo il comando di modifica tagli waterjet
      If m_bSplitCurvWJ Then
         ' deseleziono gli oggeti, resetto le variabili usate, aggiorno il disegno
         ' ResetSplitCurvWJParam(False)
         Return
      End If
      If m_bStartCurvWJ Then
         ' ResetStartCurvWJParam(False)
         Return
      End If

      ' Se eseguito drag
      If Not m_bDragToStart Then
         ' Se movimento con sola verifica finale ----- TRASLAZIONE
         If Not m_bStartRot And m_bStartMove Then
            VerifyMove()
            ' Se movimento con sola verifica finale ----- TRASLAZIONE + ROTAZIONE
         ElseIf m_bStartRot And m_bStartMove Then
            If Not m_bFromParking Then
               VerifyRot()
            Else
               ' forzo il reset delle info di rotazione
               m_dStartAng = 0
               m_dAngTotal = 0
               m_bStartRot = False
            End If
            VerifyMove()
            ' verifico se la posizione finale della rotazione è corretta ----- ROTAZIONE
         ElseIf m_bStartRot And Not m_bStartMove Then
            If m_bFromParking Then
               VerifyMove()
               ' forzo il reset delle info di rotazione
               m_dStartAng = 0
               m_dAngTotal = 0
               m_bStartRot = False
            Else
               VerifyRot()
            End If
         Else
            ' Basta reset alla fine
         End If

         ' se è stato selezionato il layer del contatore mostro la finsetra
      ElseIf m_bIsCounterLy Then
         ' devo csotruire la finestra per la selezione del numero di pezzi da muovere
         ' apro una finestra di dialogo per chiedere se inserire tutti i pezzi della famiglia
         Dim sRefGroup As String = String.Empty
         EgtGetInfo(m_nIdToSel, INFO_REFGROUP, sRefGroup)
         Dim DataContextSlectWD As New MultiSelectionVM(m_nCurrNubrOfParts, sRefGroup)
         Dim SelectWD As MultiSelectionV = New MultiSelectionV(Application.Current.MainWindow, DataContextSlectWD)
         DataContextSlectWD.SetMultiSelectionV(SelectWD)
         m_bIsCounterLy = False

         ' Se selezione da eseguire
      ElseIf m_nIdToSel <> GDB_ID.NULL Then
         ' Determino se pezzo in tavola o in parcheggio
         Dim bPartInTable As Boolean = (EgtGetParent(m_nIdToSel) = GetRawId())
         ' Se ci sono pezzi già selezionati nella posizione opposta, li deseleziono
         If (bPartInTable And m_nPartPos = PART_POS.OUT_TABLE) Or
            (Not bPartInTable And m_nPartPos = PART_POS.IN_TABLE) Then
            EgtDeselectAll()
            ' Aggiornamento eventuale VeinMatching
            VeinMatching.OnDeselectAll()
         End If
         ' Eseguo la selezione
         EgtSelectObj(m_nIdToSel)
         ' Eventuale aggiornamento VeinMatching
         VeinMatching.OnSelectPart(m_nIdToSel)
         ' Set flag posizione selezionati
         m_nPartPos = If(bPartInTable, PART_POS.IN_TABLE, PART_POS.OUT_TABLE)
         ' Se deselezione da eseguire
      ElseIf m_nIdToDesel <> GDB_ID.NULL Then
         EgtDeselectObj(m_nIdToDesel)
         ' Eventuale aggiornamento VeinMatching
         VeinMatching.OnDeselectPart(m_nIdToDesel)
      End If
      ' Reset
      GetFamilyGroupInPark()
      m_bDrag = False
      m_nIdToSel = GDB_ID.NULL
      m_nIdToDesel = GDB_ID.NULL
      ' Se nessun pezzo selezionato, reset flag posizione selezionati
      If EgtGetSelectedObjCount() = 0 Then
         m_nPartPos = PART_POS.NONE_TABLE
      End If
      EgtDraw()
   End Sub

   Friend Sub OnKeyDownScene(sender As Object, e As System.Windows.Forms.KeyEventArgs)
      ' Con CANC cancello i pezzi selezionati
      If e.KeyData = System.Windows.Forms.Keys.Delete Then
         RemovePart()
         ' Con INS eseguo inserimento dei pezzi selezionati in VeinMatching
      ElseIf e.KeyData = System.Windows.Forms.Keys.Insert Then
         ' Vettore dei pezzi selezionati (l'inserimento di un pezzo in VM cancella la selezione)
         Dim vSel As New List(Of Integer)
         Dim nTmp As Integer = EgtGetFirstSelectedObj()
         While nTmp <> GDB_ID.NULL
            vSel.Add(nTmp)
            nTmp = EgtGetNextSelectedObj()
         End While
         ' Ciclo di inserimento in VM dei pezzi selezionati
         For Each nId As Integer In vSel
            ' Se non è già inserito
            If Not VeinMatching.IsPartIn(nId) Then
               ' Lo copio in VM
               VeinMatching.SetRefOnPart(nId)
               VeinMatching.AddPart(nId, True)
               ' Se pezzo in lastra (ovvero non è un pezzo standard in parcheggio)
               If Not EgtIsPart(nId) Then
                  VeinMatching.OnInsertPartInRaw(nId, False)
               End If
               ' Dichiaro progetto modificato
               EgtSetModified()
            End If
         Next
         ' Ripristino lo stato di selezione
         For Each nId As Integer In vSel
            EgtSelectObj(nId)
            VeinMatching.OnSelectPart(nId)
         Next
      End If
   End Sub

#End Region    ' EVENTS

End Class

Class FamilyPart

   Private PtMinStoraged As Point3d
   Private PtMaxStoraged As Point3d

   Private m_nHText As Integer = 40
   Public ReadOnly Property nHText As Double
      Get
         Return m_nHText
      End Get
   End Property

   Private m_sRefGuid As String = String.Empty
   Public ReadOnly Property sRefGuid As String
      Get
         Return m_sRefGuid
      End Get
   End Property

   Private m_nIdPart As Integer = -1
   Public ReadOnly Property nIdPart As Integer
      Get
         Return m_nIdPart
      End Get
   End Property

   Private m_IdCounterText As Integer
   Public ReadOnly Property IdCounterText As Integer
      Get
         Return m_IdCounterText
      End Get
   End Property

   Public Function PtStorage() As Point3d
      EgtGetBBoxGlob(m_nIdPart, GDB_BB.STANDARD, PtMinStoraged, PtMaxStoraged)
      Return PtMinStoraged
   End Function

   Sub New(Guid As String, IdPart As Integer)
      m_sRefGuid = Guid
      m_nIdPart = IdPart
   End Sub

End Class