--
-- 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 = {}

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

----------------------------------------------------------------------------------
local function CopyParentOutline( nAreaId, nParentAreaId)
   -- recupero outline del parent
   local nParentOutlineLayerId = EgtGetFirstNameInGroup( nParentAreaId, WIN_AREAOUTLINE)
   local vParentCrvs = EgtGetAllInGroup( nParentOutlineLayerId)
   -- creo outline per area corrente
   local nOutlineLayerId = EgtGroup( nAreaId)
   EgtSetName( nOutlineLayerId, WIN_AREAOUTLINE)
   -- copio le curve di outline del parent e setto le corrispondenze sou/child
   for i = 1, #vParentCrvs do
      local nOutlineId = EgtCopy( vParentCrvs[i], nOutlineLayerId)
      EgtSetInfo( nOutlineId, WIN_SOU, vParentCrvs[i])
      EgtSetInfo( vParentCrvs[i], WIN_CHILD, nOutlineId)
   end
   return nOutlineLayerId
end



----------------------------------------------------------------------------------
------------------------------------ PROFILO -------------------------------------
----------------------------------------------------------------------------------
-- 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, vDim)
  
   -- rettangolo
   if nType == WIN_FRAME_TYPES.RECT then
      -- vDim[1] larghezza, vDim[2] altezza dei lati verticali
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTopId = EgtLine( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( 0, vDim[2], 0))
      EgtSetName( nTopId, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

   -- lato top inclinato
   elseif nType == WIN_FRAME_TYPES.CHAMFER_SIDE then
      -- vDim[1] larghezza, vDim[2] altezza del lato sx, vDim[3] altezza del lato dx
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[3], 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTopId = EgtLine( nLayerId, Point3d( vDim[1], vDim[3], 0), Point3d( 0, vDim[2], 0))
      EgtSetName( nTopId, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

   -- triangular arch
   elseif nType == WIN_FRAME_TYPES.CHAMFER then
      -- vDim[1] larghezza, vDim[2] altezza dei lati verticali, vDim[3] altezza complessiva
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTop1Id = EgtLine( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( vDim[1] / 2, vDim[3], 0))
      local nTop2Id = EgtLine( nLayerId, Point3d( vDim[1] / 2, vDim[3], 0), Point3d( 0, vDim[2], 0))
      EgtSetName( nTop1Id, WIN_TOP)
      EgtSetName( nTop2Id, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

   -- arco a tutto sesto
   elseif nType == WIN_FRAME_TYPES.ROUND_ARC then
      -- vDim[1] larghezza, vDim[2] altezza complessiva
      -- verifico che altezza sia sensata
      if vDim[2] < 0.5 * vDim[1] + GEO.EPS_SMALL then
         return false
      end
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2] - 0.5 * vDim[1], 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTopId = EgtArcCPA( nLayerId, Point3d( 0.5 * vDim[1], vDim[2] - 0.5 * vDim[1], 0), Point3d( vDim[1], vDim[2] - 0.5 * vDim[1], 0), 180, 0)
      EgtSetName( nTopId, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2] - 0.5 * vDim[1], 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

   -- arco ribassato
   elseif nType == WIN_FRAME_TYPES.SEGMENTAL_ARC then
      -- vDim[1] larghezza, vDim[2] altezza dei lati verticali, vDim[3] altezza complessiva
      -- controllo che non degeneri in arco a tutto sesto
      if vDim[3] - vDim[2] > 0.5 * vDim[1] - GEO.EPS_SMALL then
         return false
      end
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTopId = EgtArc3P( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( 0.5 * vDim[1], vDim[3], 0), Point3d( 0, vDim[2], 0))
      EgtSetName( nTopId, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)
   
   -- arco a 3 centri
   elseif nType == WIN_FRAME_TYPES.THREE_CENTER_ARC then
      -- vDim[1] larghezza, vDim[2] altezza dei lati verticali, vDim[3] altezza complessiva, vDim[4] raggio di raccordo
      -- controllo sulle dimensioni
      if vDim[3] - vDim[2] > 0.5 * vDim[1] - GEO.EPS_SMALL or vDim[4] > 0.5 * vDim[1] - GEO.EPS_SMALL then
         return false
      end
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTopId = EgtArc3P( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( 0.5 * vDim[1], vDim[3], 0), Point3d( 0, vDim[2], 0))
      EgtSetName( nTopId, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)
      
      local nFillet1 = EgtCurveFillet( nLayerId, nRightId, EgtUP( nRightId, 0.9), nTopId, EgtUP( nTopId, 0.1), vDim[4], true)
      EgtRelocateGlob( nFillet1, nTopId, GDB_IN.BEFORE)
      EgtSetName( nFillet1, WIN_TOP)
      local nFillet2 = EgtCurveFillet( nLayerId, nTopId, EgtUP( nTopId, 0.9), nLeftId, EgtUP( nLeftId, 0.1), vDim[4], true)
      EgtRelocateGlob( nFillet2, nTopId, GDB_IN.AFTER)
      EgtSetName( nFillet2, WIN_TOP)
      
   -- arco a sesto acuto
   elseif nType == WIN_FRAME_TYPES.POINTED_ARC then
      -- vDim[1] larghezza, vDim[2] altezza dei lati verticali, vDim[3] altezza complessiva
      -- verifico che le due altezze abbiano valori sensati per realizzare i due archi
      if vDim[3] - vDim[2] < 0.5 * vDim[1] then
         return false
      end
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nRightId = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[1], vDim[2], 0))
      EgtSetName( nRightId, WIN_RIGHT)
      local nTop1Id = EgtArc2PV( nLayerId, Point3d( vDim[1], vDim[2], 0), Point3d( 0.5 * vDim[1], vDim[3], 0), Y_AX())
      EgtSetName( nTop1Id, WIN_TOP)
      local nTop2Id = EgtArc2PV( nLayerId, Point3d( 0, vDim[2], 0), Point3d( 0.5 * vDim[1], vDim[3], 0), Y_AX())
      EgtInvertCurve( nTop2Id)
      EgtSetName( nTop2Id, WIN_TOP)
      local nLeftId = EgtLine( nLayerId, Point3d( 0, vDim[2], 0), ORIG())
      EgtSetName( nLeftId, WIN_LEFT)

   -- triangolo
   elseif nType == WIN_FRAME_TYPES.TRG then
      -- vDim[1] larghezza, vDim[2] altezza complessiva, vDim[3] proiezione del lato left sul bottom
      local nBottomId = EgtLine( nLayerId, ORIG(), Point3d( vDim[1], 0, 0))
      EgtSetName( nBottomId, WIN_BOTTOM)
      local nEdge1Id = EgtLine( nLayerId, Point3d( vDim[1], 0, 0), Point3d( vDim[3], vDim[2], 0))
      local nEdge2Id = EgtLine( nLayerId, Point3d( vDim[3], vDim[2], 0), ORIG())
      -- un lato verticale è right/left, un lato inclinato è top
      if vDim[3] < GEO.EPS_SMALL then
         EgtSetName( nEdge1Id, WIN_TOP)
         EgtSetName( nEdge2Id, WIN_LEFT)
      elseif abs( vDim[3] - vDim[1]) < GEO.EPS_SMALL then
         EgtSetName( nEdge1Id, WIN_RIGHT)
         EgtSetName( nEdge2Id, WIN_TOP)
      else
         EgtSetName( nEdge1Id, WIN_TOP)
         EgtSetName( nEdge2Id, WIN_TOP)
      end
   end
   return true
end

----------------------------------------------------------------------------------
-- funzione che crea il telaio a partire da una specifica geometria ( rettangolo, chamfer...)
function WinCreate.CreateFrame( nType, vDimensions, vJoints, vPartsDim, nAreaNbr)

   -- creo gruppo per telaio
   local nAreaId = EgtGroup( GDB_ID.ROOT)
   EgtSetName( nAreaId, WIN_AREA .. '(' .. WIN_FRAME .. ')')
   EgtSetLevel( nAreaId, GDB_LV.SYSTEM)
   
   -- imposto le info
   EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.FRAME)
   EgtSetInfo( nAreaId, WIN_FRAME_TYPE, nType)
   EgtSetInfo( nAreaId, WIN_JOINTS, vJoints)
   EgtSetInfo( nAreaId, WIN_PART_DIM, vPartsDim)
   EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr)

   -- costruisco le curve di outline
   local nOutlineLayerId = EgtGroup( nAreaId)
   EgtSetName( nOutlineLayerId, WIN_AREAOUTLINE)
   if not CreateFrameCurves( nOutlineLayerId, nType, vDimensions) then
      return
   end 
   
   return nAreaId
end



----------------------------------------------------------------------------------
-------------------------------------- ANTA --------------------------------------
----------------------------------------------------------------------------------
-- funzione che aggiunge una singola anta
function WinCreate.AddSash( nParentAreaId, vJoints, vPartsDim, nOpeningType, nAreaNbr)
   
   -- se già presente area errore
   if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then
      return
   end
   
   -- creo nuova area
   local nAreaId = EgtGroup( nParentAreaId)
   EgtSetName( nAreaId, WIN_AREA .. '(' .. WIN_SASH .. ')')
   -- imposto le info
   EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.SASH)
   EgtSetInfo( nAreaId, WIN_JOINTS, vJoints)
   EgtSetInfo( nAreaId, WIN_PART_DIM, vPartsDim)
   EgtSetInfo( nAreaId, WIN_OPENING_TYPE, nOpeningType)
   EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr)
   EgtSetInfo( nAreaId, WIN_SASH_NBR, 1)
   -- copio outline dall'area parent
   CopyParentOutline( nAreaId, nParentAreaId)
   
   return nAreaId
end

----------------------------------------------------------------------------------
-- funzione che aggiunge un gruppo di ante
function WinCreate.AddSashGroup( nParentAreaId, vMeasureTypes, vDimensions, vJoints, vPartsDim, vSashTypes, vOpeningTypes, nAreaNbr, vSashNbrs)
   
   -- se già presente sottoarea errore
   if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then
      return
   end
   
   -- creo gli split di tipo french
   local vAreas = WinCreate.AddSplits( nParentAreaId, WIN_SPLITORIENTATION.VERTICAL, vMeasureTypes, vDimensions, {}, true, nAreaNbr)
   -- trasformo le aree risultanti ( che sono null) nelle aree dell'anta settando le info opportune
   for i = 1, #vAreas do
      EgtSetName( vAreas[i], EgtGetName( vAreas[i]) .. '(' .. WIN_SASH .. ')')
      EgtSetInfo( vAreas[i], WIN_AREATYPE, WIN_AREATYPES.SASH)
      EgtSetInfo( vAreas[i], WIN_JOINTS, vJoints[i])
      EgtSetInfo( vAreas[i], WIN_PART_DIM, vPartsDim[i])
      EgtSetInfo( vAreas[i], WIN_SASHTYPE, vSashTypes[i])
      EgtSetInfo( vAreas[i], WIN_OPENING_TYPE, vOpeningTypes[i])
      if vSashNbrs then
         EgtSetInfo( vAreas[i], WIN_SASH_NBR, vSashNbrs[i])
      end
   end
   
   return vAreas
end



----------------------------------------------------------------------------------
-------------------------------------- FILL --------------------------------------
----------------------------------------------------------------------------------
-- funzione che aggiunge un riempimento
function WinCreate.AddFill( nParentAreaId, nFillType, nAreaNbr)
   
   -- se area ha già sottoarea errore
   if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then
      return
   end
   
   local nAreaId = EgtGroup( nParentAreaId)
   EgtSetName( nAreaId, WIN_AREA .. '(' .. WIN_FILL .. ')')
   -- setto le info
   EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.FILL)   
   EgtSetInfo( nAreaId, WIN_FILLTYPE, nFillType)
   EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr)
   -- copio outline dall'area parent
   CopyParentOutline( nAreaId, nParentAreaId)
   
   return nAreaId
end



----------------------------------------------------------------------------------
------------------------------------- SPLIT --------------------------------------
----------------------------------------------------------------------------------
-- 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 taglia lo split con il bordo della regione
local function AdjustSplitCurve( nSplitId, nCompo, vOutlineCrvs, nOutlineLayerId)
   
   -- trimmo lo split a filo con l'outline
   EgtExtendCurveStartByLen( nSplitId, 10)
   EgtExtendCurveEndByLen( nSplitId, 10)
   local ptS = EgtIP( nSplitId, nCompo, EgtSP( nSplitId))
   local ptE = EgtIP( nSplitId, nCompo, EgtEP( nSplitId))
   local dParS = EgtCurveParamAtPoint( nSplitId, ptS)
   local dParE = EgtCurveParamAtPoint( nSplitId, ptE)
   EgtTrimCurveStartEndAtParam( nSplitId, dParS, dParE)
   
   -- recupero le curve con cui avviene l'intersezione e le salvo come info
   -- start
   local dParCrvS = EgtCurveParamAtPoint( nCompo, ptS)
   if abs( dParCrvS - ceil( dParCrvS)) < GEO.EPS_ZERO 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_ZERO 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
   
   -- end
   local dParCrvE = EgtCurveParamAtPoint( nCompo, ptE)
   if abs( dParCrvE - ceil( dParCrvE)) < GEO.EPS_ZERO 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_ZERO 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
end

----------------------------------------------------------------------------------
-- funzione che restituisce il bordo delle due regioni definite da uno split
local function GetBorderRegions( nSplitId, nCompo, nAreaId)

   -- taglio il bordo in due in corrispondenza dello split
   local nCrv1 = EgtCopyGlob( nCompo, nAreaId)
   local nCrv2 = EgtCopyGlob( nCompo, nAreaId)
   local dPar1 = EgtCurveParamAtPoint( nCompo, EgtSP( nSplitId), 100 * GEO.EPS_SMALL)
   local dPar2 = EgtCurveParamAtPoint( nCompo, EgtEP( nSplitId), 100 * GEO.EPS_SMALL)
   EgtTrimCurveStartEndAtParam( nCrv1, dPar2, dPar1)
   EgtTrimCurveStartEndAtParam( nCrv2, dPar1, dPar2)

   -- aggiungo la curva di split al bordo per chiuderlo orientandola opportunamente
   local nSplitId1 = EgtCopyGlob( nSplitId, nAreaId)
   if AreSamePointApprox( EgtSP( nSplitId1), EgtSP( nCrv1)) then
      EgtInvertCurve( nSplitId1)
   end
   EgtAddCurveCompoCurve( nCrv1, nSplitId1)
   local _, dParE1 = EgtCurveDomain( nCrv1)
   EgtCurveCompoSetTempProp( nCrv1, dParE1 - 1, nSplitId)
   
   local nSplitId2 = EgtCopyGlob( nSplitId, nAreaId)
   if AreSamePointApprox( EgtSP( nSplitId2), EgtSP( nCrv2)) then
      EgtInvertCurve( nSplitId2)
   end
   EgtAddCurveCompoCurve( nCrv2, nSplitId2)
   local _, dParE2 = EgtCurveDomain( nCrv2)
   EgtCurveCompoSetTempProp( nCrv2, dParE2 - 1, nSplitId)
   
   return nCrv1, nCrv2
end

----------------------------------------------------------------------------------
-- funzione che crea le aree generate da una sequenza di curve di split
local function CreateAreasFromSplits( nAreaId, vSplitCrvs)
   
   local nGrpTmp = EgtGroup( nAreaId)
   
   -- creo la curva composita dell'outline
   local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
   local vOutlineCrvs = EgtGetAllInGroup( nOutlineLayerId)
   local nCompo = EgtCurveCompo( nGrpTmp, vOutlineCrvs, false)
   for i = 1, #vOutlineCrvs do
      EgtCurveCompoSetTempProp( nCompo, i - 1, vOutlineCrvs[i])
   end

   -- creo le curve associate ad ogni regione degli split
   local vBorders = {}
   local nCompoRef = nCompo
   for i = 1, #vSplitCrvs do
      
      -- aggiusto lo split per averlo a filo con l'outline
      AdjustSplitCurve( vSplitCrvs[i], nCompo, vOutlineCrvs, nOutlineLayerId)
      
      -- calcolo i bordi delle due regioni definite dallo split
      local nCrv1, nCrv2 = GetBorderRegions( vSplitCrvs[i], nCompoRef, nGrpTmp)
      table.insert( vBorders, nCrv1)
      -- il secondo bordo è quello da suddividere con lo split successivo ( se esiste)
      nCompoRef = nCrv2
      if i == #vSplitCrvs then
         table.insert( vBorders, nCrv2)
      end
   end
   
   -- creo le sottoaree a partire dai contorni
   local vAreas = {}
   for i = 1, #vBorders do
      -- creo area
      local nSplitAreaId = EgtGroup( nAreaId)
      EgtSetName( nSplitAreaId , WIN_AREA .. tostring( i))
      EgtSetInfo( nSplitAreaId, WIN_AREATYPE, WIN_AREATYPES.NULL)
      vAreas[i] = nSplitAreaId
      
      -- creo outline con la curva di bordo
      local nOutlineLayerId = EgtGroup( nSplitAreaId)
      EgtSetName( nOutlineLayerId, WIN_AREAOUTLINE)
      EgtRelocateGlob( vBorders[i], nOutlineLayerId)
      local vOrigCrvs = EgtCurveCompoGetTempProp( vBorders[i])
      local nFirst, nCnt = EgtExplodeCurveCompo( vBorders[i])
      
      -- assegno nome e info a tutte le curve di bordo a partire dalla curva da cui derviano ( salvata nella temp prop della curva)
      for j = 0, nCnt - 1 do
         -- assegno le info di child e source
         EgtSetInfo( nFirst + j, WIN_SOU, vOrigCrvs[j+1])
         AddInfo( vOrigCrvs[j+1], WIN_CHILD, nFirst + j)
         -- assengo il nome : se deriva da outline lo copio, se deriva da split lo scelgo in base all'orientamento
         if EgtGetName( vOrigCrvs[j+1]) == WIN_SPLIT then
            SetSplitName( nFirst + j)
         else
            EgtSetName( nFirst + j, EgtGetName( vOrigCrvs[j+1]))
         end
      end
      
      -- riordino le curve dell'outline per avere bottom come primo
      local nCrvId = EgtGetFirstInGroup( nOutlineLayerId)
      while EgtGetName( nCrvId) ~= WIN_BOTTOM do
         EgtRelocate( nCrvId, nOutlineLayerId)
         nCrvId = EgtGetFirstInGroup( nOutlineLayerId)
      end
   end

   EgtErase( nGrpTmp)
   return vAreas
end

----------------------------------------------------------------------------------
-- funzione che calcola le dimensioni assolute delle divisioni
local function CalcSplitDimensions( vMeasureTypes, vValues, dDim)

   local vDimensions = {}
   -- calcolo le dimensioni di tutti gli split assoluti e percentuali e calcolo i valori di riferimento per eventuali split proporzionali
   local nPropTot = 0
   local dPropDim = dDim
   local bProportional = false
   for i = 1, #vMeasureTypes do
      if vMeasureTypes[i] == WIN_MEASURE.ABSOLUTE then
         vDimensions[i] = vValues[i]
         dPropDim = dPropDim - vDimensions[i]
      elseif vMeasureTypes[i] == WIN_MEASURE.PERCENTAGE then
         vDimensions[i] = dDim * vValues[i] / 100
         dPropDim = dPropDim - vDimensions[i]
      elseif vMeasureTypes[i] == WIN_MEASURE.PROPORTIONAL then
         nPropTot = nPropTot + vValues[i]
         bProportional = true
      end
   end

   -- calcolo le dimensioni degli split proporzionali
   if bProportional then
      if dPropDim < GEO.EPS_SMALL then
         return {}
      end
      for i = 1, #vValues do
         if vMeasureTypes[i] == WIN_MEASURE.PROPORTIONAL then
            vDimensions[i] = dPropDim * vValues[i] / nPropTot
         end
      end
   end
   
   return vDimensions
end

----------------------------------------------------------------------------------
local function CalcSplitCurves( nLayerId, b3OutlineLayer, b3Limit, nSplitType, vMeasureTypes, vValues)
   
   -- calcolo le dimensioni assolute di tutti gli split
   local vDimensions = CalcSplitDimensions( vMeasureTypes, vValues, EgtIf( nSplitType == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY()))
   
   local vSplitCurves = {}
   local dPosition = 0
   for i = 1, #vDimensions do
      -- calcolo la posizione cumulata
      dPosition = dPosition + vDimensions[i]
      
      local nSplitCrv
      if nSplitType == WIN_SPLITORIENTATION.VERTICAL then
         -- aree ordinate da sx a dx
         local dCurrPosition = dPosition
         -- creo la linea se rientra nella regione limite
         local dX = b3OutlineLayer:getMin():getX() + dCurrPosition
         if dX > b3Limit:getMin():getX() + GEO.EPS_SMALL and dX < b3Limit:getMax():getX() - GEO.EPS_SMALL then
            nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + X_AX() * dCurrPosition, Y_AX(), b3OutlineLayer:getDimY())
         end
      
      elseif nSplitType == WIN_SPLITORIENTATION.HORIZONTAL then
         -- aree ordinate dall'alto al basso
         local dCurrPosition = b3OutlineLayer:getDimY() - dPosition
         -- creo la linea se rientra nella regione limite
         local dY = b3OutlineLayer:getMin():getY() + dCurrPosition
         if dY > b3Limit:getMin():getY() + GEO.EPS_SMALL and dY < b3Limit:getMax():getY() - GEO.EPS_SMALL then
            nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + Y_AX() * dCurrPosition, X_AX(), b3OutlineLayer:getDimX())
         end
      end
      
      if nSplitCrv then
         EgtSetName( nSplitCrv, WIN_SPLIT)
         table.insert( vSplitCurves, nSplitCrv)
         EgtSetInfo( nSplitCrv, WIN_SPLIT_POSITION, dPosition)
      end
   end
   
   return vSplitCurves
end

----------------------------------------------------------------------------------
-- funzione che crea tagli split multipli
function WinCreate.AddSplits( nParentAreaId, nSplitType, vMeasureTypes, vValues, vPartsDim, bFrench, nAreaNbr)

   -- se area ha già sottoarea errore
   if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then
      return
   end
   
   local nParentOutlineLayerId = EgtGetFirstNameInGroup( nParentAreaId, WIN_AREAOUTLINE)
   local b3OutlineLayer = EgtGetBBox( nParentOutlineLayerId, GDB_BB.STANDARD)
   
   -- creo area di split
   local nAreaId = EgtGroup( nParentAreaId)
   EgtSetName( nAreaId, WIN_AREA .. '(' .. WIN_SPLIT .. ')')
   -- setto le info
   EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.SPLIT)
   EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr)
   EgtSetInfo( nAreaId, WIN_SPLIT_DIR, nSplitType)
   EgtSetInfo( nAreaId, WIN_MEASURE_TYPE, vMeasureTypes)
   EgtSetInfo( nAreaId, WIN_MEASURE_VALUE, vValues)
   EgtSetInfo( nAreaId, WIN_SPLIT_REF_DIM, EgtIf( nSplitType == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY()))
   EgtSetInfo( nAreaId, WIN_PART_DIM, vPartsDim)

   -- copio il contorno dall'area parent
   CopyParentOutline( nAreaId, nParentAreaId)
   
   -- creo layer per split
   local nSplitLayerId = EgtGroup( nAreaId)
   EgtSetName( nSplitLayerId, WIN_BASESPLIT)
   -- verifico se va impostato il tipo french
   if bFrench then
      EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, WIN_SPLITTYPES.FRENCH)
   end
   -- creo le curve di split
   local vSplitCurves = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, b3OutlineLayer, nSplitType, vMeasureTypes, vValues)
   if #vSplitCurves == 0 then
      -- se non ci sono curve valide cancello tutto ed esco
      EgtErase( nAreaId)
      return
   end
   
   -- creo le aree generate dagli split
   local vAreas = CreateAreasFromSplits( nAreaId, vSplitCurves)
   return vAreas
end

----------------------------------------------------------------------------------
-- funzione che crea tagli split grid
function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues, vHorizMeasureTypes, vHorizValues, bStartVertical, vPartsDim, nAreaNbr)
   
   local AreaResult = {}
   
   -- se area ha già sottoarea errore
   if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then
      return
   end
   
   -- creo area di split
   local nAreaId = EgtGroup( nParentAreaId)
   EgtSetName( nAreaId, WIN_AREA .. '(' .. WIN_SPLIT .. ')')
   -- setto info
   EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.SPLIT)
   EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr)
   EgtSetInfo( nAreaId, WIN_GRID_SPLIT, true)
   EgtSetInfo( nAreaId, WIN_PART_DIM, vPartsDim)

   -- copio il contorno dall'area parent e setto opportune corrispondenze sou/child
   local nOutlineLayerId = CopyParentOutline( nAreaId, nParentAreaId)
   local b3OutlineLayer = EgtGetBBox( nOutlineLayerId, GDB_BB.STANDARD)
   
   -- creo layer per split
   local nSplitLayerId = EgtGroup( nAreaId)
   EgtSetName( nSplitLayerId, WIN_BASESPLIT)

   -- stabilisco direzione principale e secondaria
   local vMainTypes, vOtherTypes, vMainValues, vOtherValues, nMainSplitOrientation, nOtherSplitOrientation
   if bStartVertical then
      vMainTypes = vVertMeasureTypes
      vMainValues = vVertValues
      nMainSplitOrientation = WIN_SPLITORIENTATION.VERTICAL
      vOtherTypes = vHorizMeasureTypes
      vOtherValues = vHorizValues
      nOtherSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL
   else
      vMainTypes = vHorizMeasureTypes
      vMainValues = vHorizValues
      nMainSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL
      vOtherTypes = vVertMeasureTypes
      vOtherValues = vVertValues
      nOtherSplitOrientation = WIN_SPLITORIENTATION.VERTICAL
   end
   
   -- salvo i dati dello split principale nell'area principale, i dati dello split secondario verranno salvati nelle aree virtuali
   EgtSetInfo( nAreaId, WIN_SPLIT_DIR, nMainSplitOrientation)
   EgtSetInfo( nAreaId, WIN_MEASURE_TYPE, vMainTypes)
   EgtSetInfo( nAreaId, WIN_MEASURE_VALUE, vMainValues)
   EgtSetInfo( nAreaId, WIN_SPLIT_REF_DIM, EgtIf( nMainSplitOrientation == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY()))
   
   -- calcolo la suddivisione nella direzione principale
   local vMainSplit = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, b3OutlineLayer, nMainSplitOrientation, vMainTypes, vMainValues)
   for i = 1, #vMainSplit do
      EgtSetInfo( vMainSplit[i], WIN_GRIDSPLIT_ORDER, 0)
   end
   local vMainAreas = CreateAreasFromSplits( nAreaId, vMainSplit)
   
   -- per ogni area della direzione principale calcolo la suddivisione nella direzione secondaria
   for i = 1, #vMainAreas do
       -- recupero outline per calcolare il limite delle curve di split
      local nAreaOutlineLayerId = EgtGetFirstNameInGroup( vMainAreas[i], WIN_AREAOUTLINE)
      local b3Limit = EgtGetBBox( nAreaOutlineLayerId, GDB_BB.STANDARD)
      
      -- calcolo gli split nella direzione secondaria
      local vOtherSplit = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, b3Limit, nOtherSplitOrientation, vOtherTypes, vOtherValues)
      if #vOtherSplit > 0 then
         for j = 1, #vOtherSplit do
            EgtSetInfo( vOtherSplit[j], WIN_GRIDSPLIT_ORDER, tostring( i))
         end
         -- calcolo le aree generate dagli split secondari
         local vNewAreas = CreateAreasFromSplits( vMainAreas[i], vOtherSplit)
         AreaResult = EgtJoinTables( AreaResult, vNewAreas)
      end
   end
   
   -- sposto le aree secondarie nell'area di split e le rinomino
   for i = 1, #AreaResult do 
      EgtRelocateGlob( AreaResult[i], nAreaId)
      EgtSetName( AreaResult[i], WIN_AREA .. EgtNumToString( i))
   end
   -- le aree generate dallo split principale diventano aree virtuali ausiliarie per i conti
   -- riporto come info quelle legate allo split secondario
   for i = 1, #vMainAreas do
      EgtSetName( vMainAreas[i], WIN_VIRTUAL_AREA)
      EgtSetInfo( vMainAreas[i], WIN_SPLIT_DIR, nOtherSplitOrientation)
      EgtSetInfo( vMainAreas[i], WIN_MEASURE_TYPE, vOtherTypes)
      EgtSetInfo( vMainAreas[i], WIN_MEASURE_VALUE, vOtherValues)
      EgtSetInfo( vMainAreas[i], WIN_SPLIT_REF_DIM, EgtIf( nOtherSplitOrientation == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY()))
   end

   return AreaResult
end



----------------------------------------------------------------------------------
---------------------------------- BOTTOMRAIL ------------------------------------
----------------------------------------------------------------------------------
-- funzione che aggiunge uno zoccolo
function WinCreate.AddBottomRail( nAreaId, nNbr, vDim)
   local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
   if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then
      EgtSetInfo( nAreaId, WIN_BOTTOMRAIL, nNbr)
      EgtSetInfo( nAreaId, WIN_BOTTOMRAIL .. WIN_PART_DIM, vDim)
   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