--
-- EEEEEEEEEE      GGGGGG      TTTTTTTTTTTTTT
-- EEEEEEEEEE    GGGGGGGGGG    TTTTTTTTTTTTTT
-- EEEE         GGGG    GGGG        TTTT
-- EEEE        GGGG                 TTTT
-- EEEEEEE     GGGG   GGGGGGG       TTTT 
-- EEEEEEE     GGGG   GGGGGGG       TTTT
-- EEEE        GGGG      GGGG       TTTT
-- EEEE         GGGG    GGGG        TTTT
-- EEEEEEEEEE    GGGGGGGGGG         TTTT
-- EEEEEEEEEE      GGGGGG           TTTT
--
-- by Egalware s.r.l.
-- Window project software by Egalware s.r.l.   2023/05/02

-- Tabella per definizione modulo
local WinCreate = {}

-- Include
require( 'EgtBase')
require( 'WinConst')

-- funzioni
----------------------------------------------------------------------------------
local function AddInfo( nId, sInfo, nVal)
   local vInfo = EgtGetInfo( nId, sInfo, 'vi') or {}
   table.insert( vInfo, nVal)
   EgtSetInfo( nId, sInfo, vInfo)
end

----------------------------------------------------------------------------------
-- funzione che importa il profilo
function WinCreate.ImportProfile( sProfilePath)
   -- verifico esistenza file
   if not EgtExistsFile( sProfilePath) then
      EgtOutLog( 'File del profilo non trovato! ' .. sProfilePath)
      EgtOutText( 'File del profilo non trovato! ' .. sProfilePath)
      EgtPause(5000)
      return false
   end
   -- creo gruppo per il profilo
   local nProfileId = EgtGroup( GDB_ID.ROOT)
   EgtSetName( nProfileId, WIN_PROFILE)
   EgtSetLevel( nProfileId, GDB_LV.SYSTEM)
   -- importo profilo prescelto
   local bOk = EgtInsertFile( sProfilePath)
   -- recupero gruppi importati e li sposto nel gruppo profilo
   local nGroupId = EgtGetFirstInGroup( GDB_ID.ROOT)
   while nGroupId do
      if nGroupId ~= nProfileId then
         local nCurrId = nGroupId
         nGroupId = EgtGetNext( nGroupId)
         EgtRelocateGlob( nCurrId, nProfileId)
         EgtSetStatus( nCurrId, GDB_ST.OFF)
      else
         nGroupId = EgtGetNext( nGroupId)
      end
   end
   -- riporto path nel Part del profilo
   EgtSetInfo( nProfileId, WIN_PROFILEPATH, sProfilePath)
   return true
end

----------------------------------------------------------------------------------
------------------------------------- TELAIO -------------------------------------
----------------------------------------------------------------------------------
-- funzione che crea le curve che definiscono il telaio in base alla geometria richiesta
local function CreateFrameCurves( nLayerId, nType, dWidth, dHeight, dVal)

   -- rettangolo
   if nType == WIN_FRAME_TYPES.RECT then
      -- telaio rettangolare
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight, 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTopId = EgtLine( nLayerId, Point3d( dWidth, dHeight, 0), Point3d( 0, dHeight, 0))
      EgtSetName( nTopId, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

      -- lato top inclinato
   elseif nType == WIN_FRAME_TYPES.CHAMFER_SIDE then
      -- dHeight è l'altezza del lato sx, dVal è l'altezza del lato dx
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dVal, 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTopId = EgtLine( nLayerId, Point3d( dWidth, dVal, 0), Point3d( 0, dHeight, 0))
      EgtSetName( nTopId, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

      -- triangular arch
   elseif nType == WIN_FRAME_TYPES.CHAMFER then
      -- dHeight è l'altezza dei lati verticali, dVal è l'altezza complessiva della finestra
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight, 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTop1Id = EgtLine( nLayerId, Point3d( dWidth, dHeight, 0), Point3d( dWidth / 2, dVal, 0))
      local nTop2Id = EgtLine( nLayerId, Point3d( dWidth / 2, dVal, 0), Point3d( 0, dHeight, 0))
      EgtSetName( nTop1Id, WIN_TOP)
      EgtSetName( nTop2Id, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

      -- arco a tutto sesto
   elseif nType == WIN_FRAME_TYPES.ROUND_ARC then
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight - 0.5 * dWidth, 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTopId = EgtArcCPA( nLayerId, Point3d( 0.5 * dWidth, dHeight - 0.5 * dWidth, 0), Point3d( dWidth, dHeight - 0.5 * dWidth, 0), 180, 0) 
      EgtSetName( nTopId, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight - 0.5 * dWidth, 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

      -- arco ribassato
   elseif nType == WIN_FRAME_TYPES.SEGMENTAL_ARC then
      -- dHeight è l'altezza dei lati verticali, dVal è l'altezza complessiva della finestra
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight, 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTopId = EgtArc3P( nLayerId, Point3d( dWidth, dHeight, 0), Point3d( 0.5 * dWidth, dVal, 0), Point3d( 0, dHeight, 0))
      EgtSetName( nTopId, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

      -- arco a tutto sesto
   elseif nType == WIN_FRAME_TYPES.POINTED_ARC then
      -- dHeight è l'altezza dei lati verticali, dVal è l'altezza complessiva della finestra
      -- verifico che le due altezze abbiano valori sensati per realizzare i due archi
      if dVal - dHeight < 0.5 * dWidth then
         return
      end
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dWidth, dHeight, 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTop1Id = EgtArc2PV( nLayerId, Point3d( dWidth, dHeight, 0), Point3d( 0.5 * dWidth, dVal, 0), Y_AX())
      EgtSetName( nTop1Id, WIN_TOP)
      local nTop2Id = EgtArc2PV( nLayerId, Point3d( 0, dHeight, 0), Point3d( 0.5 * dWidth, dVal, 0), Y_AX())
      EgtInvertCurve( nTop2Id)
      EgtSetName( nTop2Id, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, dHeight, 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

      -- triangolo
   elseif nType == WIN_FRAME_TYPES.TRG then
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( dWidth, 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nEdge1Id = EgtLine( nLayerId, Point3d( dWidth, 0, 0), Point3d( dVal, dHeight, 0))
      local nEdge2Id = EgtLine( nLayerId, Point3d( dVal, dHeight, 0), ORIG())
      -- un lato verticale è right/left, un lato inclinato è top
      if dVal < GEO.EPS_SMALL then
         EgtSetName( nEdge1Id, WIN_TOP)
         EgtSetName( nEdge2Id, WIN_LEFT)
      elseif abs( dVal - dWidth) < GEO.EPS_SMALL then
         EgtSetName( nEdge1Id, WIN_RIGHT)
         EgtSetName( nEdge2Id, WIN_TOP)
      else
         EgtSetName( nEdge1Id, WIN_TOP)
         EgtSetName( nEdge2Id, WIN_TOP)
      end
   end
end

----------------------------------------------------------------------------------
-- funzione che crea il telaio a partire da una specifica geometria ( rettangolo,  chamfer...)
function WinCreate.CreateFrame( nType, vJoints, dWidth, dHeight, dHeight2)

   -- creo gruppo per telaio
   local nAreaId = EgtGroup( GDB_ID.ROOT)
   EgtSetName( nAreaId, WIN_AREA .. '(' .. WIN_FRAME .. ')')
   EgtSetLevel( nAreaId, GDB_LV.SYSTEM)
   -- imposto il tipo
   EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.FRAME)

   -- costruisco le curve di outline
   local nOutlineLayerId = EgtGroup( nAreaId)
   EgtSetName( nOutlineLayerId, WIN_AREAOUTLINE)
   CreateFrameCurves( nOutlineLayerId, nType, dWidth, dHeight, dHeight2)
   EgtSetInfo( nAreaId, WIN_FRAME_TYPE, nType)
   -- imposto tipo giunzioni
   EgtSetInfo( nOutlineLayerId, WIN_JOINTS, vJoints)

   return nAreaId
end

----------------------------------------------------------------------------------
-------------------------------------- ANTA --------------------------------------
----------------------------------------------------------------------------------
-- funzione che aggiunge una anta
function WinCreate.AddSash( nAreaId, vJoints, nSashType, nOpeningType)
   -- creo nuova area
   local nSashAreaId = EgtGroup( nAreaId)
   EgtSetName( nSashAreaId, WIN_AREA .. '(' .. WIN_SASH .. ')')
   -- imposto il tipo
   EgtSetInfo( nSashAreaId, WIN_AREATYPE, WIN_AREATYPES.SASH)
   -- recupero outline area precedente
   local nPrevAreaOutlineId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
   -- lo copio per outline area dell'anta
   local nAreaOutlineLayerId = EgtGroup( nSashAreaId)
   EgtSetName( nAreaOutlineLayerId, WIN_AREAOUTLINE)
   local nAreaOutlineId = EgtGetFirstInGroup( nPrevAreaOutlineId)
   while nAreaOutlineId do
      local nOutlineId = EgtCopy( nAreaOutlineId, nAreaOutlineLayerId)
      EgtSetInfo( nOutlineId, WIN_SOU, nAreaOutlineId)
      EgtRemoveInfo( nOutlineId, WIN_CHILD)
      AddInfo( nAreaOutlineId, WIN_CHILD, nOutlineId)
      nAreaOutlineId = EgtGetNext( nAreaOutlineId)
   end
   -- imposto tipo giunzioni
   EgtSetInfo( nAreaOutlineLayerId, WIN_JOINTS, vJoints)
   -- imposto tipo di anta e di apertura se presente
   if nSashType then
      EgtSetInfo( nSashAreaId, WIN_SASHTYPE, nSashType)
   end
   if nOpeningType then
      EgtSetInfo( nSashAreaId, WIN_OPENING_TYPE, nOpeningType)
   end
   return nSashAreaId
end

----------------------------------------------------------------------------------
-------------------------------------- FILL --------------------------------------
----------------------------------------------------------------------------------
-- funzione che aggiunge un riempimento
function WinCreate.AddFill( nAreaId, FillType)
   -- creo nuova area
   local nFillAreaId = EgtGroup( nAreaId)
   EgtSetName( nFillAreaId, WIN_AREA .. '(' .. WIN_FILL .. ')')
   -- imposto il tipo
   EgtSetInfo( nFillAreaId, WIN_AREATYPE, WIN_AREATYPES.FILL)
   -- recupero outline area precedente
   local nPrevAreaOutlineId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
   -- lo copio per outline area del riempimento
   local nAreaOutlineLayerId = EgtGroup( nFillAreaId)
   EgtSetName( nAreaOutlineLayerId, WIN_AREAOUTLINE)
   local nAreaOutlineId = EgtGetFirstInGroup( nPrevAreaOutlineId)
   while nAreaOutlineId do
      local nOutlineId = EgtCopy( nAreaOutlineId, nAreaOutlineLayerId)
      EgtSetInfo( nOutlineId, WIN_SOU, nAreaOutlineId)
      EgtRemoveInfo( nOutlineId, WIN_CHILD)
      AddInfo( nAreaOutlineId, WIN_CHILD, nOutlineId)
      nAreaOutlineId = EgtGetNext( nAreaOutlineId)
   end
   -- rimuovo eventuali info di giunzioni
   EgtRemoveInfo( nAreaOutlineLayerId, WIN_JOINTS)

   -- imposto tipo di fill
   EgtSetInfo( nFillAreaId, WIN_FILLTYPE, FillType)
   return nFillAreaId
end

----------------------------------------------------------------------------------
------------------------------------- SPLIT --------------------------------------
----------------------------------------------------------------------------------
-- funzione che crea un taglio split
function WinCreate.AddSplit( nAreaLayerId, SplitType, MeasureType, nPosition, nProportion, nSplitType)
   -- creo layer temporaneo per split
   local nTempSplitLayerId = EgtGroup( nAreaLayerId)
   -- recupero contorno area precedente
   local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaLayerId, WIN_AREAOUTLINE)
   local b3OutlineLayer = EgtGetBBox( nOutlineLayerId, GDB_BB.STANDARD)
   local nTotSplitId
   if SplitType == WIN_SPLITORIENTATION.VERTICAL then
      -- creo linea
      local nCalcPosition = 0
      if MeasureType == WIN_MEASURE.ABSOLUT then
         nCalcPosition = nPosition
      elseif MeasureType == WIN_MEASURE.PROPORTIONAL then
         nCalcPosition = b3OutlineLayer:getDimX() / nProportion * nPosition
      elseif MeasureType == WIN_MEASURE.PERCENTAGE then
         nCalcPosition = b3OutlineLayer:getDimX() * nPosition
      end
      if nCalcPosition > b3OutlineLayer:getDimX() - GEO.EPS_SMALL then
         EgtErase( nTempSplitLayerId)
         return
      end
      nTotSplitId = EgtLine( nTempSplitLayerId, b3OutlineLayer:getMin() + X_AX() * nCalcPosition, b3OutlineLayer:getMin() + X_AX() * nCalcPosition + Y_AX() * b3OutlineLayer:getDimY())
   elseif SplitType == WIN_SPLITORIENTATION.HORIZONTAL then
      -- creo linea
      local nCalcPosition = 0
      if MeasureType == WIN_MEASURE.ABSOLUT then
         nCalcPosition = nPosition
      elseif MeasureType == WIN_MEASURE.PROPORTIONAL then
         nCalcPosition = b3OutlineLayer:getDimY() / nProportion * nPosition
      elseif MeasureType == WIN_MEASURE.PERCENTAGE then
         nCalcPosition = b3OutlineLayer:getDimY() * nPosition
      end
      if nCalcPosition > b3OutlineLayer:getDimY() - GEO.EPS_SMALL then
         EgtErase( nTempSplitLayerId)
         return
      end
      nTotSplitId = EgtLine( nTempSplitLayerId, b3OutlineLayer:getMin() + Y_AX() * nCalcPosition, b3OutlineLayer:getMin() + Y_AX() * nCalcPosition + X_AX() * b3OutlineLayer:getDimX())
   end
   -- calcolo split
   local nArea1Id, nArea2Id = WinCreate.AddGenSplit( nAreaLayerId, nTotSplitId, nSplitType)
   EgtErase( nTempSplitLayerId)
   return nArea1Id, nArea2Id
end

----------------------------------------------------------------------------------
-- funzione che crea tagli split multipli
function WinCreate.AddSplits( nAreaLayerId, SplitType, MeasureType, PositionList, nProportion, nSplitType)
   local AreaList = {}
   if MeasureType == WIN_MEASURE.ABSOLUT then
      local nResArea1
      local nResArea2 = nAreaLayerId
      for nIndex = 1, #PositionList do
         if nIndex > 1 then
            EgtSetInfo( nResArea2, WIN_PRJ_ORIGSPLIT, nAreaLayerId)
         end
         local nCurrentResArea2 = nResArea2
         nResArea1, nResArea2 = WinCreate.AddSplit( nResArea2, SplitType, MeasureType, PositionList[nIndex], nProportion, nSplitType)
         if not nResArea2 then
            table.insert( AreaList, nCurrentResArea2)
            break
         end
         table.insert( AreaList, nResArea1)
         if nIndex == #PositionList then
            table.insert( AreaList, nResArea2)
         end
      end
   elseif MeasureType == WIN_MEASURE.PROPORTIONAL then
      local nResArea1
      local nResArea2 = nAreaLayerId
      local dAddPosition = 0
      for nIndex = 1, #PositionList - 1 do
         if nIndex > 1 then
            EgtSetInfo( nResArea2, WIN_PRJ_ORIGSPLIT, nAreaLayerId)
         end
         local nCurrentResArea2 = nResArea2
         nResArea1, nResArea2 = WinCreate.AddSplit( nResArea2, SplitType, MeasureType, PositionList[nIndex], nProportion - dAddPosition, nSplitType)
         if not nResArea2 then
            table.insert( AreaList, nCurrentResArea2)
            break
         end
         table.insert( AreaList, nResArea1)
         if nIndex == #PositionList -1  then
            table.insert( AreaList, nResArea2)
         end
         dAddPosition = dAddPosition + PositionList[nIndex]
      end
   elseif MeasureType == WIN_MEASURE.PERCENTAGE then
      local nResArea1
      local nResArea2 = nAreaLayerId
      local dAddPosition = 0
      local sChildAreas = ''
      for nIndex = 1, #PositionList do
         if nIndex > 1 then
            EgtSetInfo( nResArea2, WIN_PRJ_ORIGSPLIT, nAreaLayerId)
            sChildAreas = sChildAreas .. nResArea2 .. EgtIf( nIndex < #PositionList, ',', '')
         end
         local nCurrentResArea2 = nResArea2
         nResArea1, nResArea2 = WinCreate.AddSplit( nResArea2, SplitType, MeasureType, EgtIf( nIndex == 1, PositionList[nIndex], PositionList[nIndex] / ( 1 - dAddPosition)), nProportion, nSplitType)
         if not nResArea2 then
            table.insert( AreaList, nCurrentResArea2)
            break
         end
         table.insert( AreaList, nResArea1)
         if nIndex == #PositionList then
            table.insert( AreaList, nResArea2)
         end
         dAddPosition = dAddPosition + PositionList[nIndex]
      end
      EgtSetInfo( nAreaLayerId, 'ChildSplit', sChildAreas)
   end
   return AreaList
end

----------------------------------------------------------------------------------
-- funzione che crea tagli split grid
function WinCreate.AddGridSplits( nAreaLayerId, MeasureType, PositionListVert, PositionListHoriz, bStartVertical, nSplitType)
   local AreaResult = {}
   -- recupero contorno area precedente
   local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaLayerId, WIN_AREAOUTLINE)
   local b3OutlineLayer = EgtGetBBox( nOutlineLayerId, GDB_BB.STANDARD)
   -- calcolo numero parti totali nel caso di misura proporzionale
   local nProportionVert = 0
   local nProportionHoriz = 0
   if MeasureType == WIN_MEASURE.PROPORTIONAL then
      for i = 1, #PositionListVert do
         nProportionVert = nProportionVert + PositionListVert[i]
      end
      for i = 1, #PositionListHoriz do
         nProportionHoriz = nProportionHoriz + PositionListHoriz[i]
      end
   end
   -- calcolo gli split nella direzione secondaria
   local PositionAbs = {}
   local PositionList = EgtIf( bStartVertical, PositionListHoriz, PositionListVert)
   local nProportion = EgtIf( bStartVertical, nProportionHoriz, nProportionVert)
   local dDim = EgtIf( bStartVertical, b3OutlineLayer:getDimY(), b3OutlineLayer:getDimX())
   for i = 1, #PositionList do
      if MeasureType == WIN_MEASURE.ABSOLUT then
         PositionAbs[i] = PositionList[i]
      elseif MeasureType == WIN_MEASURE.PROPORTIONAL then
         PositionAbs[i] = dDim / nProportion * PositionList[i]
      elseif MeasureType == WIN_MEASURE.PERCENTAGE then
         PositionAbs[i] = dDim * PositionList[i]
      end
   end
   if bStartVertical then
      local AreaList = WinCreate.AddSplits( nAreaLayerId, WIN_SPLITORIENTATION.VERTICAL, MeasureType, PositionListVert, nProportionVert, nSplitType)
      for i = 1, #AreaList do
         local AreaTemp = WinCreate.AddSplits( AreaList[i], WIN_SPLITORIENTATION.HORIZONTAL, WIN_MEASURE.ABSOLUT, PositionAbs, nProportionHoriz, nSplitType) or {}
         for j = 1, #AreaTemp do
            table.insert( AreaResult, AreaTemp[j])
         end
      end
   else
      local AreaList = WinCreate.AddSplits( nAreaLayerId, WIN_SPLITORIENTATION.HORIZONTAL, MeasureType, PositionListHoriz, nProportionHoriz, nSplitType)
      for i = 1, #AreaList do
         -- recupero contorno area corrente
         local nCurrentOutlineLayerId = EgtGetFirstNameInGroup( AreaList[i], WIN_AREAOUTLINE)
         local b3CurrentOutlineLayer = EgtGetBBox( nCurrentOutlineLayerId, GDB_BB.STANDARD)
         local dDiff = b3OutlineLayer:getMin():getX() -  b3CurrentOutlineLayer:getMin():getX()
         if dDiff < - GEO.EPS_SMALL then
            local nFirstIndex = #PositionAbs + 1
            for k = 1, #PositionAbs do
               if PositionAbs[k] + dDiff > GEO.EPS_SMALL then
                  PositionAbs[k] = PositionAbs[k] + dDiff
                  nFirstIndex = k
                  break
               elseif k ~= #PositionAbs then
                  PositionAbs[k + 1] = PositionAbs[k] + PositionAbs[k + 1]
               end
            end
            for k = 1, nFirstIndex - 1 do
               table.remove( PositionAbs, 1)
            end
         end
         local AreaTemp = WinCreate.AddSplits( AreaList[i], WIN_SPLITORIENTATION.VERTICAL, WIN_MEASURE.ABSOLUT, PositionAbs, nProportionVert, nSplitType) or {}
         for j = 1, #AreaTemp do
            table.insert( AreaResult, AreaTemp[j])
         end
      end
   end
   return AreaResult
end

----------------------------------------------------------------------------------
-- funzione che assegna il nome alla curva di split nella sottoarea in base alla sua direzione
local function SetSplitName( nSplitId)

   local vtMedia = ( ( EgtEV( nSplitId) - EgtSV( nSplitId)) / 2)
   if not vtMedia:normalize() then
      vtMedia = EgtSV( nSplitId)
   end
   if abs( vtMedia:getX()) > abs( vtMedia:getY()) then
      if vtMedia:getX() > 0 then
         EgtSetName( nSplitId, WIN_BOTTOM)
      else
         EgtSetName( nSplitId, WIN_TOP)
      end
   else
      if vtMedia:getY() > 0 then
         EgtSetName( nSplitId, WIN_RIGHT)
      else
         EgtSetName( nSplitId, WIN_LEFT)
      end
   end
end

----------------------------------------------------------------------------------
-- funzione che crea le aree da un taglio split
local function CreateAreaFromSplit( nAreaLayerId, nCompo, nSplitId, dPar1, dPar2, vOutlineCrvs)

   -- creo layer per le due sottoaree
   local nArea1Id = EgtGroup( nAreaLayerId)
   EgtSetName( nArea1Id , WIN_AREA .. '1')
   EgtSetInfo( nArea1Id, WIN_AREATYPE, WIN_AREATYPES.NULL)
   local nArea1OutlineLayerId = EgtGroup( nArea1Id)
   EgtSetName( nArea1OutlineLayerId , WIN_AREAOUTLINE)
   local nArea2Id = EgtGroup( nAreaLayerId)
   EgtSetName( nArea2Id , WIN_AREA .. '2')
   EgtSetInfo( nArea2Id, WIN_AREATYPE, WIN_AREATYPES.NULL)
   local nArea2OutlineLayerId = EgtGroup( nArea2Id)
   EgtSetName( nArea2OutlineLayerId , WIN_AREAOUTLINE)

   -- ad ogni sottoarea associo la porzione di curva composita corrispondente
   local nCrv1 = EgtCopyGlob( nCompo, nArea1OutlineLayerId)
   local nCrv2 = EgtCopyGlob( nCompo, nArea2OutlineLayerId)
   EgtTrimCurveStartEndAtParam( nCrv1, dPar2, dPar1)
   EgtTrimCurveStartEndAtParam( nCrv2, dPar1, dPar2)

   -- copio curva di split
   local nSplitId1 = EgtCopyGlob( nSplitId, nArea1OutlineLayerId)
   local nSplitId2 = EgtCopyGlob( nSplitId, nArea2OutlineLayerId)
   -- verifico se necessaria inversione
   if AreSamePointApprox( EgtSP( nSplitId1), EgtSP( nCrv1)) then
      EgtInvertCurve( nSplitId1)
   end
   if AreSamePointApprox( EgtSP( nSplitId2), EgtSP( nCrv2)) then
      EgtInvertCurve( nSplitId2)
   end
   -- assegno il nome in base alla direzione
   SetSplitName( nSplitId1)
   SetSplitName( nSplitId2)
   -- assengo le info di source e child
   EgtSetInfo( nSplitId, WIN_CHILD, { nSplitId1, nSplitId2})
   EgtSetInfo( nSplitId1, WIN_SOU, nSplitId)
   EgtSetInfo( nSplitId2, WIN_SOU, nSplitId)

   -- spezzo le curve composite per riottenere le curve originarie di partenza
   local nFirst1, nCnt1 = EgtExplodeCurveCompo( nCrv1)
   local nFirst2, nCnt2 = EgtExplodeCurveCompo( nCrv2)
   -- assegno nome e info
   local vCrvs = EgtTableFill( nFirst1, nCnt1)
   EgtTableAdd( vCrvs, nFirst2, nCnt2)
   for i = 1,  #vCrvs do
      -- ricavo la curva di outline originale da cui deriva
      local ptM = EgtMP( vCrvs[i])
      for j = 1, #vOutlineCrvs do
         if EgtCurveParamAtPoint( vOutlineCrvs[j], ptM, 100 * GEO.EPS_SMALL) then
            -- ne prendo il nome
            EgtSetName( vCrvs[i], EgtGetName( vOutlineCrvs[j]))
            -- assegno le info di child e source
            EgtSetInfo( vCrvs[i], WIN_SOU, vOutlineCrvs[j])
            AddInfo( vOutlineCrvs[j], WIN_CHILD, vCrvs[i])
            break
         end
      end
   end

   -- scorro pezzi del primo e secondo outline per avere bottom come primo
   local nFirstInAreaId = EgtGetFirstInGroup( nArea1OutlineLayerId)
   local sFirstInAreaName = EgtGetName( nFirstInAreaId)
   while sFirstInAreaName ~= WIN_BOTTOM do
      EgtRelocate( nFirstInAreaId, nArea1OutlineLayerId)
      nFirstInAreaId = EgtGetFirstInGroup( nArea1OutlineLayerId)
      sFirstInAreaName = EgtGetName( nFirstInAreaId)
   end
   nFirstInAreaId = EgtGetFirstInGroup( nArea2OutlineLayerId)
   sFirstInAreaName = EgtGetName( nFirstInAreaId)
   while sFirstInAreaName ~= WIN_BOTTOM do
      EgtRelocate( nFirstInAreaId, nArea2OutlineLayerId)
      nFirstInAreaId = EgtGetFirstInGroup( nArea2OutlineLayerId)
      sFirstInAreaName = EgtGetName( nFirstInAreaId)
   end

   return nArea1Id, nArea2Id
end

----------------------------------------------------------------------------------
-- funzione che crea un taglio split da una curva generica
function WinCreate.AddGenSplit( nAreaLayerId, nSplitId, nSplitType)
   -- se area nulla diventa di tipo split
   local nAreaType = EgtGetInfo( nAreaLayerId, WIN_AREATYPE, 'i')
   if nAreaType == WIN_AREATYPES.NULL then
      EgtSetInfo( nAreaLayerId, WIN_AREATYPE, WIN_AREATYPES.SPLIT)
   end
   -- creo layer per split
   local nSplitLayerId = EgtGroup( nAreaLayerId)
   EgtSetName( nSplitLayerId, WIN_BASESPLIT)
   -- sposto curva split nel layer
   EgtRelocateGlob( nSplitId, nSplitLayerId)
   -- assegno nome profilo
   EgtSetName( nSplitId, WIN_SPLIT)

   -- verifico se devo impostare tipo di split ( solo se deriva da tipo frame)
   if nSplitType then
      local nParentAreaId = nAreaLayerId
      local nParentAreaType = nAreaType
      -- recupero parent fino a trovare frame o sash
      while nParentAreaType ~= WIN_AREATYPES.FRAME and nParentAreaType ~= WIN_AREATYPES.SASH do
         nParentAreaId = EgtGetParent( nParentAreaId)
         nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i')
      end
      if nParentAreaType == WIN_AREATYPES.FRAME then
         -- imposto tipo di split
         EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, nSplitType)
      end
   end

   -- Ricerca delle intersezioni :
   -- creo una curva composita a partire da tutte le curve di outline
   local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaLayerId, WIN_AREAOUTLINE)
   local vOutlineCrvs = EgtGetAllInGroup( nOutlineLayerId)
   local nCompo = EgtCurveCompo( nSplitLayerId, vOutlineCrvs, false)
   -- allungo curva split per cercare intersezioni
   EgtExtendCurveStartByLen( nSplitId, 10)
   EgtExtendCurveEndByLen( nSplitId, 10)
   -- trovo intersezioni tra composita e lo split
   local nFirst, nPntCnt, nCrvCnt = EgtCurveCurveInters( nCompo, nSplitId, nSplitLayerId)
   if nCrvCnt ~= 0 or nPntCnt ~= 2 then
      -- errore
      return
   end
   -- recupero i due punti di intersezione
   local pt1 = EgtSP( nFirst)
   local pt2 = EgtSP( nFirst + 1)
   EgtErase( { nFirst, nFirst + 1})

   -- recupero i parametri di intersezione sulla curva di split
   local dSplitParS = EgtCurveParamAtPoint( nSplitId, pt1, 100 * GEO.EPS_SMALL)
   local dSplitParE = EgtCurveParamAtPoint( nSplitId, pt2, 100 * GEO.EPS_SMALL)
   -- recupero i parametri di intersezione sulla curva composita
   local dPar1 = EgtCurveParamAtPoint( nCompo, pt1, 100 * GEO.EPS_SMALL)
   local dPar2 = EgtCurveParamAtPoint( nCompo, pt2, 100 * GEO.EPS_SMALL)

   -- ricavo i parametri di intersezione legati a start ed end dello split
   local dParCrvS = dPar1
   local dParCrvE = dPar2
   if dSplitParS > dSplitParE then
      dSplitParS, dSplitParE = dSplitParE, dSplitParS
      dParCrvS, dParCrvE = dParCrvE, dParCrvS
   end

   -- taglio la curva di split nei punti di intersezione
   EgtTrimCurveStartEndAtParam( nSplitId, dSplitParS, dSplitParE)

   -- setto info per intersezione start
   -- se il parametro è intero allora l'intersezione coinvolge due curve successive
   if abs( dParCrvS - ceil( dParCrvS)) < GEO.EPS_SMALL then
      local nCrv = vOutlineCrvs[ ceil( dParCrvS) + 1]
      local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId)
      EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, { nOther, nCrv})
   elseif abs( dParCrvS - floor( dParCrvS)) < GEO.EPS_SMALL then
      local nCrv = vOutlineCrvs[ floor( dParCrvS) + 1]
      local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId)
      EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, { nOther, nCrv})
   else
      -- se il parametro non è intero allora l'intersezione coinvolge una sola curva
      local nCrv = vOutlineCrvs[ floor( dParCrvS) + 1]
      EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, { nCrv})
   end

   -- setto info per intersezione end
   if abs( dParCrvE - ceil( dParCrvE)) < GEO.EPS_SMALL then
      local nCrv = vOutlineCrvs[ ceil( dParCrvE) + 1]
      local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId)
      EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, { nOther, nCrv})
   elseif abs( dParCrvE - floor( dParCrvE)) < GEO.EPS_SMALL then
      local nCrv = vOutlineCrvs[ floor( dParCrvE) + 1]
      local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId)
      EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, { nOther, nCrv})
   else
      local nCrv = vOutlineCrvs[ floor( dParCrvE) + 1]
      EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, { nCrv})
   end

   -- creo sottoaree
   local nArea1, nArea2 = CreateAreaFromSplit( nAreaLayerId, nCompo, nSplitId, dPar1, dPar2, vOutlineCrvs)

   EgtErase( nCompo)

   return nArea1, nArea2

end

----------------------------------------------------------------------------------
-- funzione che crea tagli split da curve generiche
function WinCreate.AddGenSplits( nAreaLayerId, SplitList)
   for nIndex = 1, #SplitList do
      WinCreate.AddSplit( nAreaLayerId, SplitList[nIndex])
   end
end

----------------------------------------------------------------------------------
---------------------------------- BOTTOMRAIL ------------------------------------
----------------------------------------------------------------------------------
-- funzione che aggiunge uno zoccolo
function WinCreate.AddBottomRail( nAreaId, nNbr)
   local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
   if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then
      EgtSetInfo( nAreaId, WIN_BOTTOMRAIL, nNbr)
   end
end

----------------------------------------------------------------------------------
---------------------------------- SOGLIA ------------------------------------
----------------------------------------------------------------------------------
-- funzione che aggiunge la soglia
function WinCreate.AddThreshold( nAreaId, sThresholdProfile)
   local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
   if nAreaType == WIN_AREATYPES.FRAME then
      EgtSetInfo( nAreaId, WIN_THRESHOLD_PROFILE, sThresholdProfile)
   end
end

----------------------------------------------------------------------------------
---------------------------------- FERRAMENTA ------------------------------------
----------------------------------------------------------------------------------
function WinCreate.AddHardware( nFrameId, sFavourite, sHandle)
   EgtSetInfo( nFrameId, WIN_HDW_FAVOURITE, sFavourite)
   EgtSetInfo( nFrameId, WIN_HDW_HANDLE, sHandle)
end

---------------------------------------------------------------------
return WinCreate