SaraP
65e0b550c6
- cambio profilo su split - sistemata identificazione dei cambi profilo dopo gli spostamenti degli outlines degli split per misura luce - preview con pezzi dello stesso colore.
749 lines
31 KiB
Lua
749 lines
31 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 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( 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, bDayLight, 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, bDayLight, nil, 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)
|
|
|
|
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)
|
|
|
|
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)
|
|
EgtAddCurveCompoCurve( nCrv1, nSplitId1)
|
|
local _, dParE1 = EgtCurveDomain( nCrv1)
|
|
EgtCurveCompoSetTempProp( nCrv1, dParE1 - 1, nSplitId)
|
|
|
|
local nSplitId2 = EgtCopyGlob( nSplitId, nAreaId)
|
|
EgtInvertCurve( nSplitId2)
|
|
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)
|
|
|
|
-- 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
|
|
if vOrigCrvs[j+1] < 0 then
|
|
AddInfo( abs( vOrigCrvs[j+1]), WIN_CHILD, -( nFirst + j))
|
|
else
|
|
AddInfo( vOrigCrvs[j+1], WIN_CHILD, nFirst + j)
|
|
end
|
|
-- assengo il nome : se deriva da outline lo copio, se deriva da split lo scelgo in base all'orientamento
|
|
if EgtGetName( abs( vOrigCrvs[j+1])) == WIN_SPLIT then
|
|
SetSplitName( nFirst + j)
|
|
else
|
|
EgtSetName( nFirst + j, EgtGetName( abs( 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, dDimMax)
|
|
|
|
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
|
|
|
|
-- se dimensione massima diversa da quella di calcolo ( e.g. sottoaree di griglia) scalo le dimensioni delle aree sulla dimensione massima per fare in modo che gli split non scompaiano
|
|
if dDimMax < dDim - GEO.EPS_SMALL then
|
|
for i = 1, #vDimensions do
|
|
vDimensions[i] = vDimensions[i] * dDimMax / dDim
|
|
end
|
|
end
|
|
|
|
return vDimensions
|
|
end
|
|
|
|
----------------------------------------------------------------------------------
|
|
local function CalcSplitCurves( nLayerId, b3OutlineLayer, dDimMax, nSplitType, vMeasureTypes, vValues)
|
|
|
|
-- calcolo le dimensioni assolute di tutti gli split
|
|
local dDim = EgtIf( nSplitType == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY())
|
|
if not dDimMax then
|
|
dDimMax = dDim
|
|
end
|
|
local vDimensions = CalcSplitDimensions( vMeasureTypes, vValues, dDim, dDimMax)
|
|
|
|
local vSplitCurves = {}
|
|
local dPosition = 0
|
|
for i = 1, #vDimensions - 1 do
|
|
-- calcolo la posizione cumulata
|
|
dPosition = dPosition + vDimensions[i]
|
|
-- creo la curva se rientra nelle dimensione limite
|
|
if dPosition < dDimMax - GEO.EPS_SMALL then
|
|
local nSplitCrv
|
|
if nSplitType == WIN_SPLITORIENTATION.VERTICAL then
|
|
-- aree ordinate da sx a dx
|
|
nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + X_AX() * dPosition, Y_AX(), b3OutlineLayer:getDimY())
|
|
elseif nSplitType == WIN_SPLITORIENTATION.HORIZONTAL then
|
|
-- aree ordinate dal basso all'alto
|
|
nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + Y_AX() * dPosition, X_AX(), b3OutlineLayer:getDimX())
|
|
EgtInvertCurve( nSplitCrv)
|
|
end
|
|
|
|
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, bDaylight, nMuntinFillSide, 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_PART_DIM, vPartsDim)
|
|
EgtSetInfo( nAreaId, WIN_MUNTINFILL_SIDE, nMuntinFillSide)
|
|
if bFrench then
|
|
EgtSetInfo( nAreaId, WIN_SPLITTYPE, WIN_SPLITTYPES.FRENCH)
|
|
EgtSetInfo( nAreaId, WIN_DAYLIGHT_MEASURE, bDaylight)
|
|
end
|
|
|
|
-- copio il contorno dall'area parent
|
|
CopyParentOutline( nAreaId, nParentAreaId)
|
|
|
|
-- creo layer per split
|
|
local nSplitLayerId = EgtGroup( nAreaId)
|
|
EgtSetName( nSplitLayerId, WIN_BASESPLIT)
|
|
|
|
-- creo le curve di split
|
|
local vSplitCurves = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, nil, 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, vVertDim, vHorizDim, nMuntinFillSide, 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_MUNTINFILL_SIDE, nMuntinFillSide)
|
|
EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr)
|
|
EgtSetInfo( nAreaId, WIN_GRID_SPLIT, true)
|
|
|
|
-- 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 dati per direzione principale e secondaria
|
|
local vMainTypes, vOtherTypes, vMainValues, vOtherValues, nMainSplitOrientation, nOtherSplitOrientation, vMainDim, vOtherDim
|
|
if bStartVertical then
|
|
vMainTypes = vVertMeasureTypes
|
|
vMainValues = vVertValues
|
|
nMainSplitOrientation = WIN_SPLITORIENTATION.VERTICAL
|
|
vMainDim = vVertDim
|
|
vOtherTypes = vHorizMeasureTypes
|
|
vOtherValues = vHorizValues
|
|
nOtherSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL
|
|
vOtherDim = vHorizDim
|
|
else
|
|
vMainTypes = vHorizMeasureTypes
|
|
vMainValues = vHorizValues
|
|
nMainSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL
|
|
vMainDim = vHorizDim
|
|
vOtherTypes = vVertMeasureTypes
|
|
vOtherValues = vVertValues
|
|
nOtherSplitOrientation = WIN_SPLITORIENTATION.VERTICAL
|
|
vOtherDim = vVertDim
|
|
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_PART_DIM, vMainDim)
|
|
|
|
-- calcolo la suddivisione nella direzione principale
|
|
local vMainSplit = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, nil, nMainSplitOrientation, vMainTypes, vMainValues)
|
|
for i = 1, #vMainSplit do
|
|
EgtSetInfo( vMainSplit[i], WIN_GRIDSPLIT_ORDER, 0)
|
|
end
|
|
local vMainAreas = CreateAreasFromSplits( nAreaId, vMainSplit)
|
|
|
|
-- calcolo gli split nella direzione secondaria. Per non far sparire split nelle sottoregioni più piccole tengo come misura di riferimento per scalare tutte le dimensioni quella
|
|
-- della sottoregione più piccola
|
|
local dMinDim = GEO.INFINITO
|
|
for i = 1, #vMainAreas do
|
|
local nAreaOutlineLayerId = EgtGetFirstNameInGroup( vMainAreas[i], WIN_AREAOUTLINE)
|
|
local b3Curr = EgtGetBBox( nAreaOutlineLayerId, GDB_BB.STANDARD)
|
|
local dDim = EgtIf( nOtherSplitOrientation == WIN_SPLITORIENTATION.VERTICAL, b3Curr:getDimX(), b3Curr:getDimY())
|
|
if dDim < dMinDim - GEO.EPS_SMALL then
|
|
dMinDim = dDim
|
|
end
|
|
end
|
|
local vOtherSplitOrig = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, dMinDim, nOtherSplitOrientation, vOtherTypes, vOtherValues)
|
|
|
|
for i = 1, #vMainAreas do
|
|
|
|
-- copio gli split della direzione secondaria
|
|
local vOtherSplit = {}
|
|
for j = 1, #vOtherSplitOrig do
|
|
vOtherSplit[j] = EgtCopyGlob( vOtherSplitOrig[j], nSplitLayerId)
|
|
EgtSetInfo( vOtherSplit[j], WIN_GRIDSPLIT_ORDER, i)
|
|
end
|
|
|
|
-- calcolo le aree generate dagli split secondari
|
|
local vNewAreas = CreateAreasFromSplits( vMainAreas[i], vOtherSplit)
|
|
for j = 1, #vNewAreas do
|
|
EgtSetInfo( vNewAreas[j], WIN_GRIDSPLIT_ORDER, i)
|
|
end
|
|
AreaResult = EgtJoinTables( AreaResult, vNewAreas)
|
|
end
|
|
|
|
EgtErase( vOtherSplitOrig)
|
|
|
|
-- 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_PART_DIM, vOtherDim)
|
|
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
|