--
-- 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

require( 'EgtBase')
_ENV = EgtProtectGlobal()
EgtEnableDebug( false)

-- Imposto direttorio per librerie
local sBaseDir = EgtGetSourceDir()
EgtOutLog("BaseDir=" .. sBaseDir)
EgtAddToPackagePath( sBaseDir .. '?.lua')
EgtAddToPackagePath( sBaseDir .. 'WinLib\\' .. '?.lua')

_G.package.loaded.WinConst = nil
_G.package.loaded.WinJWDConst = nil
_G.package.loaded.WinCreate = nil
_G.package.loaded.WinCalculate = nil
_G.package.loaded.WinManageProject = nil
_G.package.loaded.JSON = nil
_G.package.loaded.xml2lua = nil
_G.package.loaded.xml2lua_tree = nil

require( 'WinConst')
local WinCreate = require( 'WinCreate')
local WinManageProject = require( 'WinManageProject')
local WinCalculate = require( 'WinCalculate')


-- WDG

-- funzioni
----------------------------------------------------------------------------------
local function GetVariableList( sName)
   local List = {}
   local nIndex = 1
   while WDG[sName .. nIndex] do
      table.insert(List, WDG[sName .. nIndex])
      nIndex = nIndex + 1
   end
   return List
end

----------------------------------------------------------------------------------
local function CleanVariableList( sName)
   local nIndex = 1
   while WDG[sName .. nIndex] do
      WDG[sName .. nIndex] = nil
      nIndex = nIndex + 1
   end
end

----------------------------------------------------------------------------------
local function FillVariableList( sName, List)
   CleanVariableList( sName)
   for i = 1, #List do
      WDG[sName .. i] = List[i]
   end
end

----------------------------------------------------------------------------------
local function GetAreaIdsFromNumbers( vAreaNbrs)
   -- inizializzo la lista
   local vAreaIds = {}
   for i = 1, #vAreaNbrs do
      vAreaIds[i] = GDB_ID.NULL
   end
   -- recupero le aree richieste
   local vStack = { EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*')}
   local i = 1
   while vStack[i] do
      local nAreaNbr = EgtGetInfo( vStack[i], WIN_AREA_NBR, 'i') or -1
      for j = 1, #vAreaNbrs do
         if nAreaNbr == vAreaNbrs[j] then
            vAreaIds[j] = vStack[i]
            break
         end
      end
      -- ricerco nelle sue sottoaree
      local vChildren = EgtGetNameInGroup( vStack[i], WIN_AREA .. '*')
      vStack = EgtJoinTables( vStack, vChildren)
      i = i + 1
   end
   
   return vAreaIds
end

----------------------------------------------------------------------------------
local function SetProfilePath()
   _G.sProfilePath = WDG.PROFILEPATH
end
_G.SetProfilePath = SetProfilePath

----------------------------------------------------------------------------------
local function WinCreate_ImportProfile()
   _G.sProfile = WDG.PROFILE
   if _G.sProfilePath then
      WinCreate.ImportProfile( _G.sProfilePath .. '\\' .. WDG.PROFILE .. '.nge')
   end
end
_G.WinCreate_ImportProfile = WinCreate_ImportProfile

----------------------------------------------------------------------------------
local function FindThresholds( nGrpId)
   local tThresholds = {}  -- array delle soglie
   -- ogni soglia è una tabella con due chiavi : nType = intero che indica la tipologia ( cfr. WIN_THRESHOLD_TYPES), sName = nome della soglia nel file dei profili
   local tHash = {}
   -- scorro tutti i profili del telaio
   local nCurrId = EgtGetFirstInGroup( nGrpId)
   while nCurrId do
      -- verifico se di tipo bottom
      local nBottomType = EgtGetInfo( nCurrId, WIN_BOTTOM, 'i') or WIN_THRESHOLD_TYPES.NULL
      if nBottomType ~= WIN_THRESHOLD_TYPES.NULL then
         -- recupero il nome
         local vNames = EgtSplitString( EgtGetName( nCurrId), '_')
         local sName = vNames[#vNames]
         if not tHash[sName] then
            table.insert( tThresholds, { nType = nBottomType, sName = sName})
            tHash[sName] = 1
         end
      end
      nCurrId = EgtGetNext( nCurrId)
   end
   return tThresholds
end

----------------------------------------------------------------------------------
local function GetProfileThresholdsList()
   local tThresholds = {}
   if _G.sProfile == WDG.PROFILE then
      -- se profilo corrente
      local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
      local nFrameGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_FRAME)
      tThresholds = FindThresholds( nFrameGrp)
   else
      -- importo temporaneamente il profilo
      local nLastId = EgtGetLastInGroup( GDB_ID.ROOT)
      local bOk = EgtInsertFile( _G.sProfilePath .. '\\' .. WDG.PROFILE .. '.nge')
      local nCurrId = EgtGetNext( nLastId or GDB_ID.NULL) or EgtGetFirstInGroup( GDB_ID.ROOT)
      while nCurrId do
         if EgtGetName( nCurrId) == WIN_FRAME then
            tThresholds = FindThresholds( nCurrId)
         end
         -- passo al successivo e cancello il corrente
         local nOldId = nCurrId
         nCurrId = EgtGetNext( nCurrId)
         EgtErase( nOldId)
      end
   end
   WDG.THRESHOLDSLIST = tThresholds
end
_G.GetProfileThresholdsList = GetProfileThresholdsList

----------------------------------------------------------------------------------
local function GetProfileData( nFrameGrp, nSashGrp)
   local tData = {}
   
   -- a) dimensioni
   for i = 1, 2 do
      -- scorro tutti i profili e salvo le dimensioni
      local sName = EgtIf( i == 1, WIN_FRAME, WIN_SASH)
      local vProfiles = EgtGetAllInGroup( EgtIf( i ==1, nFrameGrp, nSashGrp))
      for j = 1, #vProfiles do
         local sCurrName = sName .. '_' .. EgtGetName( vProfiles[j])
         tData[sCurrName .. '_' .. WIN_DIM_STD] = EgtGetInfo( vProfiles[j], WIN_DIM_STD, 'd')
         tData[sCurrName .. '_' .. WIN_DIM_MIN] = EgtGetInfo( vProfiles[j], WIN_DIM_MIN, 'd')
         tData[sCurrName .. '_' .. WIN_DIM_MAX] = EgtGetInfo( vProfiles[j], WIN_DIM_MAX, 'd')
      end
   end
   
   -- b) overlap
   -- tra ante e telaio
   local vProfiles = EgtGetAllInGroup( nFrameGrp)
   for i = 1, #vProfiles do
      local dTopOverlap = EgtGetInfo( vProfiles[i], WIN_SASH_TOP_OVERLAP, 'd')
      local dBottomOverlap = EgtGetInfo( vProfiles[i], WIN_SASH_BOTTOM_OVERLAP, 'd')
      if dTopOverlap and dBottomOverlap then
         tData[EgtGetName( vProfiles[i]) .. '_' .. WIN_TOP .. '_' .. WIN_OVERLAP] = dTopOverlap
         tData[EgtGetName( vProfiles[i]) .. '_' .. WIN_BOTTOM .. '_' .. WIN_OVERLAP] = dBottomOverlap
      else
         tData[EgtGetName( vProfiles[i]) .. '_' .. WIN_OVERLAP] = dTopOverlap or dBottomOverlap
      end
   end
   
   -- tra ante battenti/riceventi
   local nSashActive = EgtGetFirstNameInGroup( nSashGrp, WIN_SASH_ACTIVE)
   if nSashActive then
      tData[WIN_SASH_ACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashActive, WIN_OVERLAP, 'd')
   end
   local nSashFrench = EgtGetFirstNameInGroup( nSashGrp, WIN_FRENCH_IN)
   if nSashFrench then
      tData[WIN_FRENCH_IN .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashFrench, WIN_OVERLAP, 'd')
   end
   local nSlideActive = EgtGetFirstNameInGroup( nSashGrp, WIN_SLIDE_ACTIVE)
   if nSlideActive then
      tData[WIN_SLIDE_ACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSlideActive, WIN_OVERLAP, 'd')
   end
   
   -- tra bottomrail
   local nFrameBottomRail = EgtGetFirstNameInGroup( nFrameGrp, WIN_RAIL_BOTTOM)
   if nFrameBottomRail then
      tData[WIN_FRAME .. '_'.. WIN_BOTTOMRAIL .. '_' .. WIN_OVERLAP] = EgtGetInfo( nFrameBottomRail, WIN_OVERLAP, 'd')
   end
   local nSashBottomRail = EgtGetFirstNameInGroup( nSashGrp, WIN_RAIL_BOTTOM)
   if nSashBottomRail then
      tData[WIN_SASH .. '_'.. WIN_BOTTOMRAIL .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashBottomRail, WIN_OVERLAP, 'd')
   end
   
   return tData
end

----------------------------------------------------------------------------------
local function WinGetProfileData()
   
   local tData
   if _G.sProfile == WDG.PROFILE then
      -- se profilo corrente
      local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
      local nFrameGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_FRAME)
      local nSashGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_SASH)
      tData = GetProfileData( nFrameGrp, nSashGrp)
   else
      -- importo temporaneamente il profilo
      local nLastId = EgtGetLastInGroup( GDB_ID.ROOT)
      local bOk = EgtInsertFile( _G.sProfilePath .. '\\' .. WDG.PROFILE .. '.nge')
      local nCurrId = EgtGetNext( nLastId or GDB_ID.NULL) or EgtGetFirstInGroup( GDB_ID.ROOT)
      local vGrps = {}
      while nCurrId do
         table.insert( vGrps, nCurrId)
         nCurrId = EgtGetNext( nCurrId)
      end
      tData = GetProfileData( vGrps[1], vGrps[2])
      EgtErase( vGrps)
   end
   WDG.PROFILEDATA = tData
end
_G.WinGetProfileData = WinGetProfileData

----------------------------------------------------------------------------------
local function WinCreate_CreateFrame()
   local JointList = GetVariableList( 'JOINT')
   local DimensionList = GetVariableList( 'DIMENSION')
   WDG.AREAID = WinCreate.CreateFrame( WDG.FRAMETYPE, JointList, DimensionList, WDG.AREANBR)
   CleanVariableList('JOINT')
   CleanVariableList('DIMENSION')
end
_G.WinCreate_CreateFrame = WinCreate_CreateFrame

----------------------------------------------------------------------------------
local function WinCreate_AddSash()
   local JointList = GetVariableList( 'JOINT')
   WDG.AREAID = WinCreate.AddSash( WDG.AREAID, JointList, WDG.OPENINGTYPE, WDG.AREANBR)
   CleanVariableList( 'JOINT')
end
_G.WinCreate_AddSash = WinCreate_AddSash

----------------------------------------------------------------------------------
local function WinCreate_AddSashGroup()
   local DimensionList = GetVariableList( 'DIMENSION')
   local JointList = GetVariableList( 'JOINT')
   local SashTypeList = GetVariableList( 'SASHTYPE')
   local OpeningTypeList = GetVariableList( 'OPENINGTYPE')
   local SashNbrList = GetVariableList( 'SASHNBR')
   
   local AreaList = WinCreate.AddSashGroup( WDG.AREAID, WDG.MEASURETYPE, DimensionList, JointList, SashTypeList, OpeningTypeList, WDG.AREANBR, SashNbrList)
   FillVariableList( 'AREAID', AreaList)
   
   CleanVariableList( 'DIMENSION')
   CleanVariableList( 'JOINT')
   CleanVariableList( 'SASHTYPE')
   CleanVariableList( 'OPENINGTYPE')
   CleanVariableList( 'SASHNBR')
end
_G.WinCreate_AddSashGroup = WinCreate_AddSashGroup

----------------------------------------------------------------------------------
local function WinCreate_AddHardware()
   WinCreate.AddHardware( WDG.AREAID, WDG.FAVOURITE, WDG.HANDLE)
end
_G.WinCreate_AddHardware = WinCreate_AddHardware

----------------------------------------------------------------------------------
local function WinCreate_AddFill()
   WDG.AREAID = WinCreate.AddFill( WDG.AREAID, WDG.FILLTYPE, WDG.AREANBR)
end
_G.WinCreate_AddFill = WinCreate_AddFill

----------------------------------------------------------------------------------
local function WinCreate_AddBottomRail()
   WinCreate.AddBottomRail( WDG.AREAID, WDG.NBR)
end
_G.WinCreate_AddBottomRail = WinCreate_AddBottomRail

----------------------------------------------------------------------------------
local function WinCreate_AddThreshold()
   WinCreate.AddThreshold( WDG.AREAID, WDG.THRESHOLDPROFILE)
end
_G.WinCreate_AddThreshold = WinCreate_AddThreshold

----------------------------------------------------------------------------------
local function WinCreate_AddSplits()
   local PositionList = GetVariableList( 'POSITION')
   local AreaList = WinCreate.AddSplits( WDG.AREAID, WDG.SPLITORIENTATION, WDG.MEASURETYPE, PositionList, false, WDG.AREANBR)
   FillVariableList( 'AREAID', AreaList)
   CleanVariableList( 'POSITION')
end
_G.WinCreate_AddSplits = WinCreate_AddSplits

----------------------------------------------------------------------------------
local function WinCreate_AddGridSplits()
   local PositionListVert = GetVariableList( 'POSITION_VERT')
   local PositionListHoriz = GetVariableList( 'POSITION_HORIZ')
   
   local AreaList = WinCreate.AddGridSplits( WDG.AREAID, WDG.MEASURETYPE, PositionListVert, PositionListHoriz, WDG.STARTVERTICAL, WDG.AREANBR)
   FillVariableList( 'AREAID', AreaList)
   
   CleanVariableList( 'POSITION_VERT')
   CleanVariableList( 'POSITION_HORIZ')
end
_G.WinCreate_AddGridSplits = WinCreate_AddGridSplits

----------------------------------------------------------------------------------
local function WinCalculate_SetCalcSolid()
   WinCalculate.SetCalcSolid( WDG.VALUE)
end
_G.WinCalculate_SetCalcSolid = WinCalculate_SetCalcSolid

----------------------------------------------------------------------------------
local function WinCalculate_SetSimplifiedSolid()
   WinCalculate.SetSimplifiedSolid( WDG.VALUE)
end
_G.WinCalculate_SetSimplifiedSolid = WinCalculate_SetSimplifiedSolid

----------------------------------------------------------------------------------
local function WinCalculate_SetCalcPreview()
   WinCalculate.SetCalcPreview( WDG.VALUE)
end
_G.WinCalculate_SetCalcPreview = WinCalculate_SetCalcPreview

----------------------------------------------------------------------------------
local function WinCalculate_CreatePartFromArea()
   WinCalculate.CreatePartFromArea( WDG.FRAMEID)
end
_G.WinCalculate_CreatePartFromArea = WinCalculate_CreatePartFromArea

----------------------------------------------------------------------------------
local function WinCalculate_RecalcSolids()
   WinCalculate.RecalcSolids( WDG.FRAMEID)
end
_G.WinCalculate_RecalcSolids = WinCalculate_RecalcSolids

----------------------------------------------------------------------------------
local function WinCalculate_AddHardware()
   WDG.HARDWAREKIT_LIST, WDG.HARDWAREPOSITION_LIST, WDG.HARDWAREOPTION_LIST = WinCalculate.AddHardware( WDG.FRAMEID, WDG.CALC_MACHINING, WDG.CALC_HARDWARELIST, WDG.CALC_POSITIONLIST, WDG.CALC_OPTIONLIST)
end
_G.WinCalculate_AddHardware = WinCalculate_AddHardware

----------------------------------------------------------------------------------
local function WinCalculate_AddHardwareByGroupId()
   -- recupero gli id geometrici delle aree richieste
   local vAreaNbrs = GetVariableList( 'AREANBR')
   local vAreaIds = GetAreaIdsFromNumbers( vAreaNbrs)
   
   for i = 1, #vAreaIds do
      if vAreaIds[i] ~= GDB_ID.NULL then
         WDG['HARDWAREKIT_LIST' .. tostring(i)], WDG['HARDWAREPOSITION_LIST' .. tostring(i)], WDG['HARDWAREOPTION_LIST' .. tostring(i)] = 
                        WinCalculate.AddHardware( vAreaIds[i], WDG.CALC_MACHINING, WDG.CALC_HARDWARELIST, WDG.CALC_POSITIONLIST, WDG.CALC_OPTIONLIST)
      end
   end
end
_G.WinCalculate_AddHardwareByGroupId = WinCalculate_AddHardwareByGroupId

----------------------------------------------------------------------------------
local function WinCalculate_AddAccessories()
   WinCalculate.AddAccessories( WDG.FRAMEID, WDG.DRAW)
end
_G.WinCalculate_AddAccessories = WinCalculate_AddAccessories

----------------------------------------------------------------------------------
local function WinManage_LoadJwd()
   WDG.AREAID = WinManageProject.ReadFromJwd( WDG.JWD)
end
_G.WinManage_LoadJwd = WinManage_LoadJwd

----------------------------------------------------------------------------------
local function WinGetImage()
   -- sistemo la vista
   EgtSetView( SCE_VD.TOP, false)
   EgtZoom( SCE_ZM.ALL, false)
   -- salvo immagine
   EgtGetImage( SCE_SM.SH, EgtStdColor('WHITE'), EgtStdColor('WHITE'), 1920, 1080, WDG.FILE)
end
_G.WinGetImage = WinGetImage

----------------------------------------------------------------------------------
local function WinGetSvg()
   -- sistemo la vista
   EgtSetView( SCE_VD.TOP, false)
   EgtZoom( SCE_ZM.ALL, false)
   -- salvo immagine
   EgtExportSvg( WDG.GROUPID, WDG.FILE, EEX_FLT.LEV_SYSTEM + EEX_FLT.MODE_STD + EEX_FLT.STAT_OFF)
end
_G.WinGetSvg = WinGetSvg

----------------------------------------------------------------------------------
local function WinSetAuxGrpStatus()
   -- recupero il gruppo aux della ferramenta e accessori e assegno stato
   local nAuxGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AUX) or GDB_ID.NULL
   EgtSetStatus( nAuxGrp, EgtIf( WDG.AUXSTATUS, GDB_ST.ON, GDB_ST.OFF))
end
_G.WinSetAuxGrpStatus = WinSetAuxGrpStatus

----------------------------------------------------------------------------------
local function WinGetSectionsTotalLenghts()
   WDG.SECTIONS_LENGTHS = {}   -- array con le sezioni
   -- ogni sezione è una tabella con le seguenti chiavi : w = spessore, h = altezza, l = array con le lunghezze dei pezzi di tale sezione
   -- scorro tutti i pezzi
   local nPartId = EgtGetFirstPart()
   while nPartId do
      local nPartType = EgtGetInfo( nPartId, WIN_PART_TYPE, 'i') or WIN_PART_TYPES.NULL
      if nPartType ~= WIN_PART_TYPES.FILL then
         -- recupero il gruppo logs ( per archi) o geo dove sono salvate le dimensioni del pezzo
         local nLayerId = EgtGetFirstNameInGroup( nPartId, WIN_LOGS) or EgtGetFirstNameInGroup( nPartId, WIN_GEO) or GDB_ID.NULL
         if nLayerId ~= GDB_ID.NULL then
            local dWidth = EgtGetInfo( nLayerId, WIN_GEOWIDTH, 'd')
            local dHeight = EgtGetInfo( nLayerId, WIN_GEOHEIGHT, 'd')
            local dLen = EgtGetInfo( nLayerId, WIN_GEOLEN, 'd')
            if dLen then
               -- verfico se devo aggiornare sezione già presente o se devo aggiungerla
               local bFound = false
               for i = 1, #WDG.SECTIONS_LENGTHS do
                  if ( abs( WDG.SECTIONS_LENGTHS[i].W - dWidth) < GEO.EPS_SMALL and abs( WDG.SECTIONS_LENGTHS[i].H - dHeight) < GEO.EPS_SMALL) then
                     bFound = true
                     table.insert( WDG.SECTIONS_LENGTHS[i].L, dLen)
                     WDG.SECTIONS_LENGTHS[i].TotL =  WDG.SECTIONS_LENGTHS[i].TotL + dLen
                  end
               end
               if not bFound then
                  table.insert( WDG.SECTIONS_LENGTHS, { W = dWidth, H = dHeight, L = {dLen}, TotL = dLen})
               end
            end
         end
      end
      nPartId = EgtGetNextPart( nPartId)
   end
end
_G.WinGetSectionsTotalLenghts = WinGetSectionsTotalLenghts

----------------------------------------------------------------------------------
local function WinGetGlassesList()
   WDG.GLASSES_LIST = {}  -- array dei vetri
   -- ogni vetro è una tabella con le seguenti chiavi : bRect = true se rettangolo/false altrimenti, w/l/t sono le tre dimensioni
   local nPartId = EgtGetFirstPart()
   while nPartId do
      local nFillType = EgtGetInfo( nPartId, WIN_FILLTYPE)
      if nFillType == WIN_GLASS then
         local nLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
         local bShapeRect = EgtGetInfo( nLayerId, WIN_GLASS_RECT, 'b') or false
         local dW = EgtGetInfo( nLayerId, WIN_GEOWIDTH, 'd') or 0
         local dL = EgtGetInfo( nLayerId, WIN_GEOHEIGHT, 'd') or 0
         local dT = EgtGetInfo( nLayerId, WIN_GLASSTHICKNESS, 'd') or 0
         table.insert( WDG.GLASSES_LIST, { Rect = bShapeRect, W = dW, L = dL, T = dT})
      end
      nPartId = EgtGetNextPart( nPartId)
   end
end
_G.WinGetGlassesList = WinGetGlassesList

----------------------------------------------------------------------------------
local function WinGetSashShape()
   -- recupero gli id geometrici delle aree richieste
   local vAreaNbrs = GetVariableList( 'AREANBR')
   local vAreaIds = GetAreaIdsFromNumbers( vAreaNbrs)
   -- ricavo le forme
   for i = 1, #vAreaIds do
      if vAreaIds[i] ~= GDB_ID.NULL then
         WDG['SASHSHAPE' .. tostring( i)] = EgtGetInfo( vAreaIds[i], WIN_SASH_SHAPE)
      end
   end
end
_G.WinGetSashShape = WinGetSashShape

----------------------------------------------------------------------------------
local function WinGetAreaProfiles()
   -- restituisce una lista dove ogni elemento è una tabella con le seguenti chiavi : GroupId = AREANBR corrispondente, EntId = sottoentità ( e.g. anta, area di split a griglia),
   -- Profiles = lista dei profili dei pezzi di quell'area
   
   -- recupero gli id geometrici delle aree richieste
   local vAreaNbrs = GetVariableList( 'AREANBR')
   local vAreaIds = GetAreaIdsFromNumbers( vAreaNbrs)
  
   -- ricavo i profili
   local tabProfiles = {}
   for i = 1, #vAreaIds do
      if vAreaIds[i] ~= GDB_ID.NULL then
         local nAreaType = EgtGetInfo( vAreaIds[i], WIN_AREATYPE, 'i')
         if nAreaType == WIN_AREATYPES.FRAME then
            table.insert( tabProfiles, { GroupId = vAreaNbrs[i], EntId = -1, Profiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES, 'vs')})
            
         elseif nAreaType == WIN_AREATYPES.SASH then
            table.insert( tabProfiles, { GroupId = vAreaNbrs[i], EntId = 1, Profiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES, 'vs')})
            
         elseif nAreaType == WIN_AREATYPES.SPLIT then
            local nSplitLayId = EgtGetFirstNameInGroup( vAreaIds[i], WIN_SPLIT)
            local nSplitType = EgtGetInfo( nSplitLayId, WIN_SPLITTYPE, 'i')
            -- se french split devo recuperare le ante che definisce
            if nSplitType == WIN_SPLITTYPES.FRENCH then
               local vSashes = EgtGetNameInGroup( vAreaIds[i], WIN_AREA .. '*')
               for j = 1, #vSashes do
                  local nSashId = EgtGetInfo( vSashes[j], WIN_SASH_NBR, 'i')
                  table.insert( tabProfiles, { GroupId = vAreaNbrs[i], EntId = nSashId, Profiles = EgtGetInfo( vSashes[j], WIN_AREA_PROFILES, 'vs')})
               end
               
            -- se split standard recupero i profili
            else
               local bGridSplit = EgtGetInfo( vAreaIds[i], WIN_GRID_SPLIT, 'b') or false
               if bGridSplit then
                  -- distinguo per ordine di split
                  local nOrder = 0
                  local vProfiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES .. tostring( nOrder), 'vs')
                  while vProfiles do
                     table.insert( tabProfiles, { GroupId = vAreaNbrs[i], EntId = nOrder, Profiles = vProfiles})
                     nOrder = nOrder + 1
                     vProfiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES .. tostring( nOrder), 'vs')
                  end
               else
                  table.insert( tabProfiles, { GroupId = vAreaNbrs[i], EntId = -1, Profiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES, 'vs')})
               end
            end
         end
      end
   end
   WDG['AREAPROFILES'] = tabProfiles
end
_G.WinGetAreaProfiles = WinGetAreaProfiles