Annamaria Sassi
418 lines
16 KiB
Lua
418 lines
16 KiB
Lua
--
|
|
-- 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 WinManageProject = {}
|
|
|
|
-- Include
|
|
require( 'WinJWDConst')
|
|
local WinCreate = require( 'WinCreate')
|
|
local JSON = require( 'JSON')
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetJoints( tJoints)
|
|
local vJoints = {}
|
|
for i = 1, #tJoints do
|
|
local nIndex = tJoints[i][JWD_INDEX]
|
|
if tJoints[i][JWD_JOINT_TYPE] == 'FULL_H' then
|
|
vJoints[nIndex] = WIN_JNT.FULL_H
|
|
elseif tJoints[i][JWD_JOINT_TYPE] == 'FULL_V' then
|
|
vJoints[nIndex] = WIN_JNT.FULL_V
|
|
elseif tJoints[i][JWD_JOINT_TYPE] == 'ANGLED' then
|
|
vJoints[nIndex] = WIN_JNT.ANGLED
|
|
end
|
|
end
|
|
return vJoints
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetDimensions( tDimensions)
|
|
local vDims = {}
|
|
for i = 1, #tDimensions do
|
|
local nIndex = tDimensions[i][JWD_INDEX]
|
|
vDims[nIndex] = tDimensions[i][JWD_VALUE]
|
|
end
|
|
return vDims
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetSplitDimensions( tDimensions)
|
|
local vDims = {}
|
|
for i = 1, #tDimensions do
|
|
local nIndex = tDimensions[i][JWD_INDEX]
|
|
local nArea = tDimensions[i][JWD_SPLIT_AREA]
|
|
if not vDims[nArea] then
|
|
vDims[nArea] = {}
|
|
end
|
|
vDims[nArea][nIndex] = tDimensions[i][JWD_VALUE]
|
|
end
|
|
return vDims
|
|
end
|
|
---------------------------------------------------------------------
|
|
local function GetFrameShape( sShape)
|
|
|
|
if sShape == 'RECTANGLE' then
|
|
return WIN_FRAME_TYPES.RECT
|
|
elseif sShape == 'RIGHTCHAMFER' or sShape == 'LEFTCHAMFER' then
|
|
return WIN_FRAME_TYPES.CHAMFER_SIDE
|
|
elseif sShape == 'DOUBLECHAMFER' then
|
|
return WIN_FRAME_TYPES.CHAMFER
|
|
elseif sShape == 'ARC_FULL' then
|
|
return WIN_FRAME_TYPES.ROUND_ARC
|
|
elseif sShape == 'ARC' then
|
|
return WIN_FRAME_TYPES.SEGMENTAL_ARC
|
|
elseif sShape == 'DOUBLEARC' then
|
|
return WIN_FRAME_TYPES.POINTED_ARC
|
|
elseif sShape == 'THREECENTERARC' then
|
|
return WIN_FRAME_TYPES.THREE_CENTER_ARC
|
|
elseif sShape == 'TRIANGLE' then
|
|
return WIN_FRAME_TYPES.TRG
|
|
end
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetOpeningType( sOpeningType)
|
|
|
|
if sOpeningType == 'NULL' then
|
|
return WIN_OPENING_TYPES.NULL
|
|
elseif sOpeningType == 'TURNONLY_LEFT' then
|
|
return WIN_OPENING_TYPES.TURNONLY_LEFT
|
|
elseif sOpeningType == 'TURNONLY_RIGHT' then
|
|
return WIN_OPENING_TYPES.TURNONLY_RIGHT
|
|
elseif sOpeningType == 'TILTTURN_LEFT' then
|
|
return WIN_OPENING_TYPES.TILTTURN_LEFT
|
|
elseif sOpeningType == 'TILTTURN_RIGHT' then
|
|
return WIN_OPENING_TYPES.TILTTURN_RIGHT
|
|
elseif sOpeningType == 'TILTONLY_TOP' then
|
|
return WIN_OPENING_TYPES.TILTONLY_TOP
|
|
elseif sOpeningType == 'TILTONLY_BOTTOM' then
|
|
return WIN_OPENING_TYPES.TILTONLY_BOTTOM
|
|
elseif sOpeningType == 'PIVOT' then
|
|
return WIN_OPENING_TYPES.PIVOT
|
|
elseif sOpeningType == 'FIXED' then
|
|
return WIN_OPENING_TYPES.FIXED
|
|
elseif sOpeningType == 'COPLANARSLIDE_LEFT' then
|
|
return WIN_OPENING_TYPES.COPLANARSLIDE_LEFT
|
|
elseif sOpeningType == 'COPLANARSLIDE_RIGHT' then
|
|
return WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT
|
|
elseif sOpeningType == 'LIFTSLIDE_LEFT' then
|
|
return WIN_OPENING_TYPES.LIFTSLIDE_LEFT
|
|
elseif sOpeningType == 'LIFTSLIDE_RIGHT' then
|
|
return WIN_OPENING_TYPES.LIFTSLIDE_RIGHT
|
|
end
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
local function GetMeasureType( sMeasureType)
|
|
|
|
if sMeasureType == 'ABSOLUTE' then
|
|
return WIN_MEASURE.ABSOLUTE
|
|
elseif sMeasureType == 'PROPORTIONAL' then
|
|
return WIN_MEASURE.PROPORTIONAL
|
|
elseif sMeasureType == 'PERCENTAGE' then
|
|
return WIN_MEASURE.PERCENTAGE
|
|
end
|
|
|
|
return WIN_MEASURE.PERCENTAGE
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che ricava la tipologia dell'anta in base al tipo di apertura e alla struttura
|
|
local function GetSashTypes( tSashes, vOpeningTypes)
|
|
|
|
-- alzante scorrevole
|
|
local bSlideWindow = ( vOpeningTypes[1] == WIN_OPENING_TYPES.FIXED or vOpeningTypes[1] == WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT or vOpeningTypes[1] == WIN_OPENING_TYPES.LIFTSLIDE_RIGHT)
|
|
if bSlideWindow then
|
|
if #tSashes == 2 then
|
|
if vOpeningTypes[1] == WIN_OPENING_TYPES.FIXED then
|
|
return { WIN_SASHTYPES.SLIDE_FIXED, WIN_SASHTYPES.SLIDE_MOVABLE}, 'Dx'
|
|
elseif vOpeningTypes[2] == WIN_OPENING_TYPES.FIXED then
|
|
return { WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_FIXED}, 'Sx'
|
|
else
|
|
-- TODO individuare parametro per disinguerle
|
|
return { WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE_BACK}, 'Sx'
|
|
end
|
|
else
|
|
if vOpeningTypes[1] == WIN_OPENING_TYPES.FIXED then
|
|
return { WIN_SASHTYPES.SLIDE_FIXED, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_FIXED}, 'Sx'
|
|
elseif vOpeningTypes[2] == WIN_OPENING_TYPES.FIXED then
|
|
return { WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_FIXED, WIN_SASHTYPES.SLIDE_MOVABLE}, 'Sx'
|
|
else
|
|
return { WIN_SASHTYPES.SLIDE_MOVABLE_BACK, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE_BACK}, 'Sx'
|
|
end
|
|
end
|
|
end
|
|
|
|
-- casi standard
|
|
if #tSashes == 2 then
|
|
if tSashes[1][JWD_HAS_HANDLE] then
|
|
return { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE}, 'Sx'
|
|
else
|
|
return { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE}, 'Dx'
|
|
end
|
|
|
|
elseif #tSashes == 3 then
|
|
if tSashes[1][JWD_HAS_HANDLE] then
|
|
return { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.INACTIVE_OUT}, 'Sx'
|
|
elseif tSashes[2][JWD_HAS_HANDLE] then
|
|
if vOpeningTypes[2] == WIN_OPENING_TYPES.TURNONLY_LEFT or vOpeningTypes[2] == WIN_OPENING_TYPES.TILTTURN_LEFT then
|
|
return { WIN_SASHTYPES.ACTIVE_OUT, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.INACTIVE}, 'Sx'
|
|
else
|
|
return { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.ACTIVE_OUT}, 'Dx'
|
|
end
|
|
else
|
|
return { WIN_SASHTYPES.INACTIVE_OUT, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.ACTIVE}, 'Dx'
|
|
end
|
|
|
|
else
|
|
if tSashes[2][JWD_HAS_HANDLE] then
|
|
return { WIN_SASHTYPES.ACTIVE_OUT, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.INACTIVE_OUT}, 'Sx'
|
|
else
|
|
return { WIN_SASHTYPES.INACTIVE_OUT, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.ACTIVE_OUT}, 'Dx'
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione ricorsiva che legge le aree in tabella e crea le geometrie
|
|
local function ConvertTableToGeometry( AreaTable, nParentId)
|
|
|
|
if not AreaTable then
|
|
return
|
|
end
|
|
|
|
-- recupero numerazione
|
|
local nAreaNbr = AreaTable[JWD_ID_GROUP]
|
|
|
|
-- TELAIO
|
|
if AreaTable[JWD_AREA_TYPE] == 'FRAME' then
|
|
|
|
-- recupero i dati del telaio ( forma, giunzioni, dimensioni)
|
|
local nType = GetFrameShape( AreaTable[JWD_FRAME_SHAPE])
|
|
local vJoints = GetJoints( AreaTable[JWD_JOINTS])
|
|
local vDim = GetDimensions( AreaTable[JWD_DIMENSION_LIST])
|
|
local vElementDim = GetDimensions( AreaTable[JWD_ELEMENT_DIMENSION])
|
|
|
|
-- creo il telaio
|
|
local nAreaId = WinCreate.CreateFrame( nType, vDim, vJoints, vElementDim, nAreaNbr)
|
|
if not nAreaId then
|
|
return
|
|
end
|
|
|
|
-- verifico presenza threshold
|
|
if AreaTable[JWD_THRESHOLD] then
|
|
WinCreate.AddThreshold( nAreaId, AreaTable[JWD_THRESHOLD])
|
|
end
|
|
|
|
-- verifico presenza bottomrail
|
|
if AreaTable[JWD_BOTTOMRAIL] then
|
|
local vElementDim = GetDimensions( AreaTable[JWD_BR_ELEMENT_DIMENSION])
|
|
WinCreate.AddBottomRail( nAreaId, AreaTable[JWD_BOTTOMRAIL_QTY], vElementDim)
|
|
end
|
|
|
|
-- analizzo sottoaree
|
|
if AreaTable[JWD_AREA_LIST] then
|
|
ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][1], nAreaId)
|
|
end
|
|
|
|
return nAreaId
|
|
|
|
-- ANTA
|
|
elseif AreaTable[JWD_AREA_TYPE] == 'SASH' then
|
|
|
|
-- recupero dati
|
|
local tSashes = AreaTable[JWD_SASH_LIST]
|
|
local nBottomRailNbr = 0
|
|
local vElementDim = GetDimensions( AreaTable[JWD_BR_ELEMENT_DIMENSION])
|
|
if AreaTable[JWD_BOTTOMRAIL] then
|
|
nBottomRailNbr = AreaTable[JWD_BOTTOMRAIL_QTY]
|
|
end
|
|
|
|
-- lettura opzioni ferramenta
|
|
local HdwOptions = AreaTable[JWD_HARDWARE_OPTIONS] or {}
|
|
local vsOptions = {}
|
|
for i = 1, #HdwOptions do
|
|
local sName = HdwOptions[i][JWD_NAME]
|
|
local sValue = HdwOptions[i][JWD_VALUE]
|
|
table.insert( vsOptions, sName .. '=' .. sValue)
|
|
end
|
|
|
|
-- anta singola
|
|
if #tSashes == 1 then
|
|
local vJoints = GetJoints( tSashes[1][JWD_JOINTS])
|
|
local nOpeningType = GetOpeningType( tSashes[1][JWD_OPENING_TYPE])
|
|
local vElementDim = GetDimensions( tSashes[1][JWD_ELEMENT_DIMENSION])
|
|
local nAreaId = WinCreate.AddSash( nParentId, vJoints, vElementDim, nOpeningType, nAreaNbr)
|
|
-- aggiungo ferramenta sull'anta
|
|
local sHandleSide
|
|
if nOpeningType == WIN_OPENING_TYPES.TURNONLY_LEFT or
|
|
nOpeningType == WIN_OPENING_TYPES.TILTTURN_LEFT or
|
|
nOpeningType == WIN_OPENING_TYPES.TILTONLY_TOP or
|
|
nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_LEFT or
|
|
nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_LEFT then
|
|
sHandleSide = 'Sx'
|
|
elseif nOpeningType == WIN_OPENING_TYPES.TURNONLY_RIGHT or
|
|
nOpeningType == WIN_OPENING_TYPES.TILTTURN_RIGHT or
|
|
nOpeningType == WIN_OPENING_TYPES.TILTONLY_BOTTOM or
|
|
nOpeningType == WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT or
|
|
nOpeningType == WIN_OPENING_TYPES.LIFTSLIDE_RIGHT then
|
|
sHandleSide = 'Dx'
|
|
end
|
|
WinCreate.AddHardware( nAreaId, AreaTable[JWD_HARDWARE], sHandleSide)
|
|
EgtSetInfo( nAreaId, WIN_HDW_OPTIONS, vsOptions)
|
|
-- bottomrail
|
|
WinCreate.AddBottomRail( nAreaId, nBottomRailNbr, vElementDim)
|
|
-- analizzo sottaree
|
|
ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][1], nAreaId)
|
|
|
|
-- ante multiple
|
|
else
|
|
-- recupero dati delle ante
|
|
local vDimensions = {}
|
|
local vOpeningTypes = {}
|
|
local vMeasureType = {}
|
|
local vSashNbrs = {}
|
|
local vJoints = {}
|
|
local vPartsDim = {}
|
|
for i = 1, #tSashes do
|
|
vMeasureType[i] = GetMeasureType( tSashes[i][JWD_MEASURE_TYPE])
|
|
vDimensions[i] = tSashes[i][JWD_DIMENSION]
|
|
vOpeningTypes[i] = GetOpeningType( tSashes[i][JWD_OPENING_TYPE])
|
|
vSashNbrs[i] = tSashes[i][JWD_ID_SASH]
|
|
vJoints[i] = GetJoints( tSashes[i][JWD_JOINTS])
|
|
vPartsDim[i] = GetDimensions( tSashes[i][JWD_ELEMENT_DIMENSION])
|
|
end
|
|
local vSashTypes, sHandleSide = GetSashTypes( tSashes, vOpeningTypes)
|
|
|
|
-- aggiungo il gruppo di ante
|
|
local vAreas = WinCreate.AddSashGroup( nParentId, vMeasureType, vDimensions, vJoints, vPartsDim, vSashTypes, vOpeningTypes, nAreaNbr, vSashNbrs)
|
|
-- aggiungo le ante
|
|
for i = 1, #vAreas do
|
|
-- bottomrail
|
|
WinCreate.AddBottomRail( vAreas[i], nBottomRailNbr, vElementDim)
|
|
-- analizzo sottaree
|
|
ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][i], vAreas[i])
|
|
end
|
|
|
|
-- aggiungo la ferramenta sull'area split
|
|
local nSplitAreaId = EgtGetParent( vAreas[1])
|
|
WinCreate.AddHardware( nSplitAreaId, AreaTable[JWD_HARDWARE], sHandleSide)
|
|
EgtSetInfo( nSplitAreaId, WIN_HDW_OPTIONS, vsOptions)
|
|
end
|
|
|
|
|
|
-- FILL
|
|
elseif AreaTable[JWD_AREA_TYPE] == 'FILL' then
|
|
local nFillType = EgtIf( AreaTable[JWD_FILL_TYPE] == 'GLASS', WIN_FILLTYPES.GLASS, WIN_FILLTYPES.WOOD)
|
|
WinCreate.AddFill( nParentId, nFillType, nAreaNbr)
|
|
|
|
|
|
-- SPLIT
|
|
elseif AreaTable[JWD_AREA_TYPE] == 'SPLIT' then
|
|
local vVertDimensions = {}
|
|
local vVertMeasureType = {}
|
|
local vVertElementDimension = GetSplitDimensions(AreaTable[JWD_ELEMENT_VERT_DIMENSION])
|
|
local vSplitVertDimensions = AreaTable[JWD_SPLIT_VERT_POS]
|
|
for i = 1, #vSplitVertDimensions do
|
|
vVertMeasureType[i] = GetMeasureType( vSplitVertDimensions[i][JWD_MEASURE_TYPE])
|
|
vVertDimensions[i] = vSplitVertDimensions[i][JWD_DIMENSION]
|
|
end
|
|
local vHorizDimensions = {}
|
|
local vHorizMeasureType = {}
|
|
local vHorizElementDimension = GetSplitDimensions(AreaTable[JWD_ELEMENT_HORIZ_DIMENSION])
|
|
local vSplitHorizDimensions = AreaTable[JWD_SPLIT_HORIZ_POS]
|
|
for i = 1, #vSplitHorizDimensions do
|
|
vHorizMeasureType[i] = GetMeasureType( vSplitHorizDimensions[i][JWD_MEASURE_TYPE])
|
|
vHorizDimensions[i] = vSplitHorizDimensions[i][JWD_DIMENSION]
|
|
end
|
|
local vSplitAreas
|
|
if AreaTable[JWD_SPLIT_TYPE] == 'GRID' then
|
|
local vElementDimension = {}
|
|
if AreaTable[JWD_SPLIT_START_VERT] then
|
|
vElementDimension = vVertElementDimension[0]
|
|
for i = 1, #vHorizElementDimension do
|
|
EgtJoinTables( vElementDimension, vHorizElementDimension[i])
|
|
end
|
|
else
|
|
vElementDimension = vHorizElementDimension[0]
|
|
for i = 1, #vVertElementDimension do
|
|
EgtJoinTables( vElementDimension, vVertElementDimension[i])
|
|
end
|
|
end
|
|
vSplitAreas = WinCreate.AddGridSplits( nParentId, vVertMeasureType, vVertDimensions, vHorizMeasureType, vHorizDimensions, AreaTable[JWD_SPLIT_START_VERT], vElementDimension, nAreaNbr)
|
|
elseif AreaTable[JWD_SPLIT_TYPE] == 'VERTICAL' then
|
|
vSplitAreas = WinCreate.AddSplits( nParentId, WIN_SPLITORIENTATION.VERTICAL, vVertMeasureType, vVertDimensions, vVertElementDimension[0], false, nAreaNbr)
|
|
else
|
|
vSplitAreas = WinCreate.AddSplits( nParentId, WIN_SPLITORIENTATION.HORIZONTAL, vHorizMeasureType, vHorizDimensions, vHorizElementDimension[0], false, nAreaNbr)
|
|
end
|
|
for i = 1, #vSplitAreas do
|
|
ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][i], vSplitAreas[i])
|
|
end
|
|
|
|
|
|
-- NULL
|
|
elseif AreaTable[JWD_AREA_TYPE] == 'SPLITTED' then
|
|
EgtSetInfo( nParentId, WIN_AREA_NBR, nAreaNbr)
|
|
if AreaTable[JWD_AREA_LIST] then
|
|
ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][1], nParentId)
|
|
end
|
|
end
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che dato un file in json ne crea il progetto gerarchico
|
|
function WinManageProject.ReadFromFile( sFilePath, sProfileDir)
|
|
-- leggo il file
|
|
local SouFh = io.open( sFilePath, "rb")
|
|
if not SouFh then
|
|
EgtOutBox( 'Error opening ' .. sFilePath, 'ReadFromFile', 'ERROR')
|
|
return false
|
|
end
|
|
local content = SouFh:read( "*all")
|
|
SouFh:close()
|
|
local tData = JSON:decode( content)
|
|
|
|
-- importo il profilo
|
|
local sProfilePath = sProfileDir .. '\\' .. tData[JWD_PROFILE_PATH] .. '.nge'
|
|
if not WinCreate.ImportProfile( sProfilePath) then
|
|
return false
|
|
end
|
|
|
|
-- creo le aree
|
|
return ConvertTableToGeometry( tData[JWD_AREA_LIST][1], GDB_ID.ROOT)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
-- funzione che apre un file jwd
|
|
function WinManageProject.ReadFromJwd( sJwd)
|
|
local tData = JSON:decode( sJwd)
|
|
|
|
-- importo il profilo
|
|
local sProfilePath = _G.sProfilePath .. '\\' .. tData[JWD_PROFILE_PATH] .. '.nge'
|
|
if not WinCreate.ImportProfile( sProfilePath) then
|
|
return false
|
|
end
|
|
|
|
-- creo le aree
|
|
return ConvertTableToGeometry( tData[JWD_AREA_LIST][1], GDB_ID.ROOT)
|
|
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
return WinManageProject
|