Emmanuele Sassi
a550ccc3ed
- progettazione serramenti rettangolari , ad arco e di forma generica - gestione vetrifissi, ante, divisioni, montanti, ante battenti e riceventi - costruzione solidi - scrittura e lettura file jwd - inizio creazione test - inizio gestione spine
2323 lines
114 KiB
Lua
2323 lines
114 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 WinCalculate = {}
|
|
|
|
-- Include
|
|
require( 'EgtBase')
|
|
require( 'WinConst')
|
|
|
|
local bCalcSolid = false
|
|
function WinCalculate.GetCalcSolid()
|
|
return bCalcSolid
|
|
end
|
|
function WinCalculate.SetCalcSolid( bValue)
|
|
bCalcSolid = bValue
|
|
end
|
|
|
|
-- funzioni
|
|
|
|
-- funzione che cicla ricorsivamente sulla struttura per creare tutti i pezzi della finestra
|
|
function WinCalculate.CreatePartFromArea( nAreaId)
|
|
WinCalculate.CalcProfileType(nAreaId)
|
|
WinCalculate.CalculateOutlineFromAreaOutline( nAreaId)
|
|
-- recupero tipo di area
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then
|
|
-- creo pezzi outline
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
WinCalculate.CreatePartFromOutline( nAreaId, nOutlineId)
|
|
|
|
-- se di tipo bottom
|
|
local sName = EgtGetName( nOutlineId)
|
|
if sName == WIN_BOTTOM then
|
|
-- se ha BottomRail
|
|
local nBottomRail = EgtGetInfo( nOutlineLayerId, WIN_BOTTOMRAIL, 'i')
|
|
if nBottomRail and nBottomRail == 1 then
|
|
WinCalculate.CreatePartFromOutline( nAreaId, nOutlineId, true)
|
|
end
|
|
end
|
|
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
end
|
|
if nAreaType == WIN_AREATYPES.FILL then
|
|
-- creo riempimento
|
|
WinCalculate.CreatePartFromOutline( nAreaId)
|
|
end
|
|
-- verifico se c'e' uno split
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT)
|
|
if nSplitLayerId then
|
|
local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i')
|
|
local bCalcSplit = false
|
|
-- se split di tipo montante
|
|
if nSplitType == WIN_SPLITTYPES.MULLION then
|
|
bCalcSplit = true
|
|
elseif nSplitType == WIN_SPLITTYPES.FRENCH then
|
|
bCalcSplit = false
|
|
else
|
|
-- o split dell'anta
|
|
local nParentArea = nAreaId
|
|
local nParentType = nAreaType
|
|
while nParentArea and nParentType ~= WIN_AREATYPES.FRAME and nParentType ~= WIN_AREATYPES.SASH do
|
|
nParentArea = EgtGetParent( nParentArea)
|
|
nParentType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i')
|
|
end
|
|
if nParentArea and nParentType == WIN_AREATYPES.SASH then
|
|
bCalcSplit = true
|
|
else
|
|
bCalcSplit = true
|
|
end
|
|
end
|
|
if bCalcSplit then
|
|
local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
if nSplitId then
|
|
-- creo pezzo split
|
|
WinCalculate.CreatePartFromOutline( nAreaId, nSplitId)
|
|
end
|
|
end
|
|
elseif nAreaType ~= WIN_AREATYPES.FILL then
|
|
if WinCalculate.GetCalcSolid() then
|
|
-- verifico se c'e' un'area Sash prima di questa
|
|
local nParentAreaId = nAreaId
|
|
local nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, "i")
|
|
while nParentAreaId and nParentAreaType and nParentAreaType ~= WIN_AREATYPES.SASH do
|
|
nParentAreaId = EgtGetParent( nParentAreaId)
|
|
nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, "i")
|
|
end
|
|
if nParentAreaId and nParentAreaType == WIN_AREATYPES.SASH then
|
|
-- calcolo strip dell'outline
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
WinCalculate.CreateStripFromOutline( nAreaId, nOutlineId)
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
else
|
|
--- verifico se area successiva e' un fill
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAASTERISK)
|
|
local nChildAreaType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, "i")
|
|
if nChildAreaType == WIN_AREATYPES.FILL then
|
|
-- se lo e', vuol dire che e' un vetro fisso, quindi calcolo strip dell'outline
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
WinCalculate.CreateStripFromOutline( nAreaId, nOutlineId)
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- verifico se ci sono aree
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*')
|
|
while nChildAreaId do
|
|
-- lancio costruzione pezzi di quell'area
|
|
WinCalculate.CreatePartFromArea( nChildAreaId)
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*')
|
|
end
|
|
end
|
|
|
|
|
|
-- funzione che dato un gruppo contenente curve ordinate che creano una curva chiusa,
|
|
-- ne estende/taglia i contorni per ottenere una curva chiusa continua
|
|
function WinCalculate.TrimAndOrientOrderedCurveLayer( nLayerId)
|
|
local IntersCurveList = {}
|
|
local LastCurveInters
|
|
local ptInters
|
|
local nCurveId = EgtGetFirstInGroup( nLayerId)
|
|
-- ciclo sui segmenti per ottenere lista intersezioni
|
|
while nCurveId do
|
|
local nPrevId = EgtGetPrev( nCurveId)
|
|
if not nPrevId then
|
|
nPrevId = EgtGetLastInGroup( nLayerId)
|
|
end
|
|
ptInters = EgtIP( nCurveId, nPrevId, EgtSP( nCurveId))
|
|
if not ptInters then
|
|
local dDist = abs( ( EgtEP( nPrevId) - EgtSP(nCurveId)):len())
|
|
EgtExtendCurveStartByLen( nCurveId, 2 * dDist)
|
|
EgtExtendCurveEndByLen( nCurveId, 2 * dDist)
|
|
EgtExtendCurveStartByLen( nPrevId, 2 * dDist)
|
|
EgtExtendCurveEndByLen( nPrevId, 2 * dDist)
|
|
ptInters = EgtIP( nCurveId, nPrevId, EgtSP( nCurveId))
|
|
end
|
|
if LastCurveInters then
|
|
LastCurveInters.EndInters = Point3d( ptInters)
|
|
end
|
|
local NewCurveInters = { CurveId = nCurveId, StartInters = Point3d( ptInters)}
|
|
table.insert( IntersCurveList, NewCurveInters)
|
|
LastCurveInters = NewCurveInters
|
|
nCurveId = EgtGetNext( nCurveId)
|
|
end
|
|
IntersCurveList[#IntersCurveList].EndInters = IntersCurveList[1].StartInters
|
|
-- ciclo per tagliare ed orientare
|
|
for nIntersCurveIndex = 1, #IntersCurveList do
|
|
local CurveInters = IntersCurveList[nIntersCurveIndex]
|
|
local dStartParam = EgtCurveParamAtPoint( CurveInters.CurveId, CurveInters.StartInters)
|
|
local dEndParam = EgtCurveParamAtPoint( CurveInters.CurveId, CurveInters.EndInters)
|
|
EgtTrimCurveStartEndAtParam( CurveInters.CurveId, min( dStartParam, dEndParam), max( dStartParam, dEndParam))
|
|
if dStartParam > dEndParam then
|
|
EgtInvertCurve( CurveInters.CurveId)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- funzione che dato un gruppo contenente curve ordinate che creano una curva chiusa,
|
|
-- ne estende/taglia i contorni per ottenere una curva chiusa continua
|
|
function WinCalculate.TrimInOrderedCurveLayer( nLayerId)
|
|
local nCurveId = EgtGetFirstInGroup( nLayerId)
|
|
while nCurveId do
|
|
local nNextId = EgtGetNext( nCurveId)
|
|
if not nNextId then
|
|
nNextId = EgtGetFirstInGroup( nLayerId)
|
|
end
|
|
local ptInters = EgtIP( nCurveId, nNextId, EgtEP( nCurveId))
|
|
if ptInters then
|
|
local dIntersCurveParam = EgtCurveParamAtPoint( nCurveId, ptInters)
|
|
EgtTrimCurveEndAtParam( nCurveId, dIntersCurveParam)
|
|
local dIntersNextParam = EgtCurveParamAtPoint( nNextId, ptInters)
|
|
EgtTrimCurveStartAtParam( nNextId, dIntersNextParam)
|
|
end
|
|
nCurveId = EgtGetNext( nCurveId)
|
|
end
|
|
end
|
|
|
|
function WinCalculate.TrimSplitWithOutline( nSplitId)
|
|
-- lo taglio con outline
|
|
local nStartIntersId = EgtGetInfo( nSplitId, WIN_SPLIT_STARTINTERS, 'i')
|
|
local nOutlineId = EgtGetInfo( nStartIntersId, WIN_CHILD, 'i')
|
|
local ptStartInters = EgtIP( nSplitId, nOutlineId, EgtSP( nSplitId))
|
|
local dStartInters = EgtCurveParamAtPoint( nSplitId, ptStartInters)
|
|
EgtTrimCurveStartAtParam( nSplitId, dStartInters)
|
|
local nEndIntersId = EgtGetInfo( nSplitId, WIN_SPLIT_ENDINTERS, 'i')
|
|
nOutlineId = EgtGetInfo( nEndIntersId, WIN_CHILD, 'i')
|
|
local ptEndInters = EgtIP( nSplitId, nOutlineId, EgtSP( nSplitId))
|
|
local dEndInters = EgtCurveParamAtPoint( nSplitId, ptEndInters)
|
|
EgtTrimCurveEndAtParam( nSplitId, dEndInters)
|
|
end
|
|
|
|
-- funzione che calcola l'outline dall'area outline
|
|
function WinCalculate.CalculateOutlineFromAreaOutline( nAreaId)
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
-- if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then
|
|
-- -- copio BaseOutline in outline
|
|
-- local nAreaOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
-- local nOutlineLayerId = EgtCopy( nAreaOutlineLayerId, nAreaId)
|
|
-- EgtSetName( nOutlineLayerId, WIN_OUTLINE)
|
|
-- local nAreaOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId)
|
|
-- local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
-- while nAreaOutlineId do
|
|
-- EgtSetInfo( nAreaOutlineId, WIN_COPY, nOutlineId)
|
|
-- EgtRemoveInfo( nOutlineId, WIN_SOU)
|
|
-- nAreaOutlineId = EgtGetNext( nAreaOutlineId)
|
|
-- nOutlineId = EgtGetNext( nOutlineId)
|
|
-- end
|
|
-- -- se presente, copio split
|
|
-- local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT)
|
|
-- if nBaseSplitLayerId then
|
|
-- local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId)
|
|
-- EgtSetName( nSplitLayerId, WIN_SPLIT)
|
|
-- local nBaseSplitId = EgtGetFirstInGroup( nBaseSplitLayerId)
|
|
-- local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
-- EgtSetInfo( nBaseSplitId, WIN_COPY, nSplitId)
|
|
-- EgtRemoveInfo( nSplitId, WIN_SOU)
|
|
-- end
|
|
if nAreaType == WIN_AREATYPES.FRAME then
|
|
-- copio BaseOutline in outline
|
|
local nAreaOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineLayerId = EgtCopy( nAreaOutlineLayerId, nAreaId)
|
|
EgtSetName( nOutlineLayerId, WIN_OUTLINE)
|
|
local nAreaOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nAreaOutlineId do
|
|
EgtSetInfo( nAreaOutlineId, WIN_COPY, nOutlineId)
|
|
EgtRemoveInfo( nOutlineId, WIN_SOU)
|
|
nAreaOutlineId = EgtGetNext( nAreaOutlineId)
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
-- se presente, copio split
|
|
local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT)
|
|
if nBaseSplitLayerId then
|
|
local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId)
|
|
EgtSetName( nSplitLayerId, WIN_SPLIT)
|
|
local nBaseSplitId = EgtGetFirstInGroup( nBaseSplitLayerId)
|
|
local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
EgtSetInfo( nBaseSplitId, WIN_COPY, nSplitId)
|
|
EgtRemoveInfo( nSplitId, WIN_SOU)
|
|
end
|
|
elseif nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then
|
|
-- creo gruppo per outline
|
|
local nAreaOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineLayerId = EgtCopy( nAreaOutlineLayerId, nAreaId)
|
|
EgtSetName( nOutlineLayerId, WIN_OUTLINE)
|
|
EgtEmptyGroup( nOutlineLayerId)
|
|
-- recupero outline di livello precedente e lo copio pezzo per pezzo
|
|
local nSplitId
|
|
local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId)
|
|
while nBaseOutlineId do
|
|
local sBaseName = EgtGetName( nBaseOutlineId)
|
|
local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU)
|
|
local nSouParentId = EgtGetParent( nSouId)
|
|
local sSouParentName = EgtGetName( nSouParentId)
|
|
local nCopyId = EgtGetInfo( nSouId, WIN_COPY)
|
|
local nNewOutlineId = EgtCopy( nCopyId, nOutlineLayerId)
|
|
-- se discende da split
|
|
if sSouParentName == WIN_BASESPLIT then
|
|
-- aggiorno nome
|
|
EgtSetName( nNewOutlineId, sBaseName)
|
|
nSplitId = nNewOutlineId
|
|
end
|
|
EgtSetInfo( nNewOutlineId, WIN_SOU, nBaseOutlineId)
|
|
EgtSetInfo( nBaseOutlineId, WIN_COPY, nNewOutlineId)
|
|
EgtRemoveInfo( nNewOutlineId, WIN_CHILD)
|
|
EgtRemoveInfo( nNewOutlineId, WIN_COPY)
|
|
nBaseOutlineId = EgtGetNext( nBaseOutlineId)
|
|
end
|
|
-- taglio tutti i contorni
|
|
WinCalculate.TrimAndOrientOrderedCurveLayer( nOutlineLayerId)
|
|
-- se esiste un outline che deriva da uno split
|
|
if nSplitId then
|
|
-- recupero il successivo
|
|
local nNextId = EgtGetNext( nSplitId)
|
|
if not nNextId then
|
|
nNextId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
end
|
|
end
|
|
-- se presente, copio split
|
|
local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT)
|
|
if nBaseSplitLayerId then
|
|
local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId)
|
|
EgtSetName( nSplitLayerId, WIN_SPLIT)
|
|
local nBaseSplitId = EgtGetFirstInGroup( nBaseSplitLayerId)
|
|
local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
EgtSetInfo( nBaseSplitId, WIN_COPY, nSplitId)
|
|
EgtRemoveInfo( nSplitId, WIN_SOU)
|
|
-- lo taglio con outline
|
|
WinCalculate.TrimSplitWithOutline( nSplitId)
|
|
-- se split interno ad anta
|
|
local nParentAreaId = EgtGetParent( nAreaId)
|
|
local nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i')
|
|
while nParentAreaType ~= WIN_AREATYPES.FRAME and nParentAreaType ~= WIN_AREATYPES.SASH do
|
|
nParentAreaId = EgtGetParent( nParentAreaId)
|
|
nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
if nParentAreaType == WIN_AREATYPES.SASH then
|
|
-- recupero tipo di profilo
|
|
local sSplitProfile = EgtGetInfo( nSplitId, WIN_PROFILETYPE)
|
|
-- recupero profilo usato per anta
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
|
|
local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSplitProfile)
|
|
-- calcolo offset sulla z dell'anta
|
|
local dSashZOffset = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd')
|
|
-- sposto Split in Z
|
|
EgtMove( nSplitId, Z_AX() * dSashZOffset)
|
|
end
|
|
|
|
end
|
|
elseif nAreaType == WIN_AREATYPES.SASH then
|
|
-- recupero BaseOutline dell'anta
|
|
local nSashAreaOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
-- copio BaseOutline del sash e lo svuoto
|
|
local nSashOutlineLayerId = EgtCopy( nSashAreaOutlineLayerId, nAreaId)
|
|
EgtSetName( nSashOutlineLayerId, WIN_OUTLINE)
|
|
EgtEmptyGroup( nSashOutlineLayerId)
|
|
-- recupero se anta battente ricevente
|
|
local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i')
|
|
-- ciclo su profilo disegnato anta
|
|
local nSashAreaOutlineId = EgtGetFirstInGroup( nSashAreaOutlineLayerId)
|
|
while nSashAreaOutlineId do
|
|
-- recupero pezzi del frame associati
|
|
local nPrevAreaOutlineId = EgtGetInfo( nSashAreaOutlineId, WIN_SOU , 'i')
|
|
local nPrevOutlineId = EgtGetInfo( nPrevAreaOutlineId, WIN_COPY, 'i')
|
|
-- verifico se outline e' segmento battente o ricevente che quindi deriva da split
|
|
local bFrenchSplitOutline = false
|
|
if nSashType and nSashType ~= WIN_SASHTYPES.NULL then
|
|
-- faccio sou due volte per trovare il tipo dell'outline originale da cui deriva
|
|
local nSouId = EgtGetInfo( nSashAreaOutlineId, WIN_SOU, 'i')
|
|
nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i')
|
|
local nSouLayerId = EgtGetParent( nSouId)
|
|
local sSouLayerName = EgtGetName( nSouLayerId)
|
|
if sSouLayerName == WIN_BASESPLIT then
|
|
bFrenchSplitOutline = true
|
|
end
|
|
end
|
|
-- recupero tipo di profili anta
|
|
local sSashProfile = EgtGetInfo( nSashAreaOutlineId, WIN_PROFILETYPE)
|
|
-- recupero profilo usato per anta
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
|
|
local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile)
|
|
-- calcolo offset sulla z dell'anta
|
|
local dSashZOffset = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd')
|
|
local b3FrameProfile
|
|
if not bFrenchSplitOutline then
|
|
-- cerco a ritroso il frame
|
|
local nFrameAreaOutlineId = nSashAreaOutlineId
|
|
local nFrameAreaOutlineLayerId
|
|
local sFrameAreaOutlineLayer
|
|
local nFrameAreaId
|
|
local nFrameAreaType
|
|
repeat
|
|
nFrameAreaOutlineId = EgtGetInfo( nFrameAreaOutlineId, WIN_SOU , 'i')
|
|
nFrameAreaOutlineLayerId = EgtGetParent( nFrameAreaOutlineId)
|
|
sFrameAreaOutlineLayer = EgtGetName( nFrameAreaOutlineLayerId)
|
|
nFrameAreaId = EgtGetParent( nFrameAreaOutlineLayerId)
|
|
nFrameAreaType = EgtGetInfo( nFrameAreaId, WIN_AREATYPE, 'i')
|
|
until not nFrameAreaOutlineId or ( nFrameAreaType == WIN_AREATYPES.FRAME and sFrameAreaOutlineLayer == WIN_AREAOUTLINE or sFrameAreaOutlineLayer == WIN_BASESPLIT) or ( nFrameAreaType == WIN_AREATYPES.SPLIT and sFrameAreaOutlineLayer == WIN_BASESPLIT)
|
|
local nFrameOutlineId = EgtGetInfo( nFrameAreaOutlineId, WIN_COPY, 'i')
|
|
-- recupero tipi di profili anta e telaio
|
|
local sFrameProfile = EgtGetInfo( nFrameOutlineId, WIN_PROFILETYPE)
|
|
-- recupero profili usati per anta e telaio
|
|
local nFrameProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_FRAME)
|
|
local nFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileLayerId, sFrameProfile)
|
|
-- recupero le relative origini
|
|
local nFrameFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileId, WIN_SECTIONFRAME)
|
|
local frFrameProfileId = EgtFR(nFrameFrameProfileId)
|
|
-- calcolo il box del riferimento del profilo del frame
|
|
local nRefFrameProfileId = EgtGetFirstNameInGroup( nFrameProfileId, WIN_REF)
|
|
b3FrameProfile = EgtGetBBoxRef( nRefFrameProfileId, GDB_BB.STANDARD, frFrameProfileId)
|
|
end
|
|
-- creo copia outline e lo offsetto
|
|
local nSashOutlineId
|
|
if bFrenchSplitOutline then
|
|
-- copio outline del frame
|
|
nSashOutlineId = EgtCopy( nPrevOutlineId, nSashOutlineLayerId)
|
|
EgtSetInfo( nSashAreaOutlineId, WIN_COPY, nSashOutlineId)
|
|
else
|
|
-- calcolo offset perpendicolare
|
|
local dOverlap = EgtGetInfo( nSashProfileId, WIN_OVERLAP, 'd')
|
|
local dSashPerpOffset = abs( b3FrameProfile:getMin():getX()) - dOverlap
|
|
-- copio outline del frame
|
|
nSashOutlineId = EgtCopy( nPrevOutlineId, nSashOutlineLayerId)
|
|
EgtSetInfo( nSashAreaOutlineId, WIN_COPY, nSashOutlineId)
|
|
-- faccio offset
|
|
EgtOffsetCurve( nSashOutlineId, - dSashPerpOffset)
|
|
end
|
|
-- sposto anta in Z
|
|
EgtMove( nSashOutlineId, Z_AX() * dSashZOffset)
|
|
-- riporto info tipo profilo
|
|
EgtSetInfo( nSashOutlineId, WIN_PROFILETYPE, sSashProfile)
|
|
-- riporto riferimento ad elemento di BaseArea
|
|
EgtSetInfo( nSashOutlineId, WIN_COPY, nSashAreaOutlineId)
|
|
nSashAreaOutlineId = EgtGetNext( nSashAreaOutlineId)
|
|
end
|
|
-- accorcio gli offset
|
|
WinCalculate.TrimAndOrientOrderedCurveLayer( nSashOutlineLayerId)
|
|
-- WinCalculate.TrimInOrderedCurveLayer( nSashOutlineLayerId)
|
|
-- se presente, copio split
|
|
local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT)
|
|
if nBaseSplitLayerId then
|
|
local nBaseSplitId = EgtGetFirstInGroup( nBaseSplitLayerId)
|
|
-- recupero tipo di profilo split
|
|
local sSplitProfile = EgtGetInfo( nBaseSplitId, WIN_PROFILETYPE)
|
|
-- recupero profilo usato per anta
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nSplitProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
|
|
local nSplitProfileId = EgtGetFirstNameInGroup( nSplitProfileLayerId, sSplitProfile)
|
|
-- calcolo offset sulla z dell'anta
|
|
local dSplitZOffset = EgtGetInfo( nSplitProfileId, WIN_DELTA, 'd')
|
|
-- creo copia
|
|
local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId)
|
|
EgtSetName( nSplitLayerId, WIN_SPLIT)
|
|
local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
-- la taglio con outline
|
|
WinCalculate.TrimSplitWithOutline( nSplitId)
|
|
-- sposto split in Z
|
|
EgtMove( nSplitId, Z_AX() * dSplitZOffset)
|
|
EgtSetInfo( nBaseSplitId, WIN_COPY, nSplitId)
|
|
EgtRemoveInfo( nSplitId, WIN_SOU)
|
|
end
|
|
elseif nAreaType == WIN_AREATYPES.FILL then
|
|
-- recupero BaseArea del riempimento
|
|
local nFillBaseAreaLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
-- copio area outline del fill e la svuoto
|
|
local nFillOutlineLayerId = EgtCopy( nFillBaseAreaLayerId, nAreaId)
|
|
EgtSetName( nFillOutlineLayerId, WIN_OUTLINE)
|
|
EgtEmptyGroup( nFillOutlineLayerId)
|
|
-- ciclo su BaseArea riempimento
|
|
local nFillAreaOutlineId = EgtGetFirstInGroup( nFillBaseAreaLayerId)
|
|
while nFillAreaOutlineId do
|
|
local nParentBaseOutlineId = EgtGetInfo( nFillAreaOutlineId, WIN_SOU)
|
|
local nParentOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_COPY)
|
|
-- recupero pezzi dell'anta o dello split anta (o del frame a vetro fisso) associati
|
|
local nSashAreaOutlineId = nFillAreaOutlineId
|
|
local nSashAreaLayerId
|
|
local nSashAreaId
|
|
local nSashAreaType
|
|
local sSashLayerName
|
|
repeat
|
|
nSashAreaOutlineId = EgtGetInfo( nSashAreaOutlineId, WIN_SOU , 'i')
|
|
nSashAreaLayerId = EgtGetParent( nSashAreaOutlineId)
|
|
nSashAreaId = EgtGetParent( nSashAreaLayerId)
|
|
nSashAreaType = EgtGetInfo( nSashAreaId, WIN_AREATYPE, 'i')
|
|
if nSashAreaType == WIN_AREATYPES.SPLIT then
|
|
sSashLayerName = EgtGetName( nSashAreaLayerId)
|
|
end
|
|
until not nSashAreaOutlineId or not nSashAreaId or nSashAreaType == WIN_AREATYPES.FRAME or nSashAreaType == WIN_AREATYPES.SASH or ( nSashAreaType == WIN_AREATYPES.SPLIT and sSashLayerName == WIN_BASESPLIT)
|
|
-- recupero tipo di profilo anta (o frame a vetro fisso)
|
|
local sSashProfile = EgtGetInfo( nSashAreaOutlineId, WIN_PROFILETYPE)
|
|
-- verifico se BottomRail
|
|
if nSashAreaType == WIN_AREATYPES.FRAME then
|
|
local nBottomRail = EgtGetInfo( nSashAreaLayerId, WIN_BOTTOMRAIL, 'i')
|
|
local sSashAreaOutlineName = EgtGetName( nSashAreaOutlineId)
|
|
if nBottomRail and sSashAreaOutlineName == WIN_BOTTOM and nBottomRail == 1 then
|
|
-- allora imposto profilo BottomRail
|
|
sSashProfile = WIN_RAIL_BOTTOM
|
|
end
|
|
end
|
|
-- recupero se discende da anta o frame
|
|
local sProfileType
|
|
if nSashAreaType == WIN_AREATYPES.FRAME then
|
|
sProfileType = WIN_FRAME
|
|
elseif nSashAreaType == WIN_AREATYPES.SASH then
|
|
sProfileType = WIN_SASH
|
|
else
|
|
-- verifico guardando le aree prewcedentei se e' successivo ad un'anta o al frame
|
|
local nAreaLayerId = EgtGetParent( EgtGetParent( nFillAreaOutlineId))
|
|
repeat
|
|
nAreaLayerId = EgtGetParent( nAreaLayerId)
|
|
nSashAreaType = EgtGetInfo( nAreaLayerId, WIN_AREATYPE, 'i')
|
|
until not nSashAreaOutlineId or not nAreaLayerId or nSashAreaType == WIN_AREATYPES.FRAME or nSashAreaType == WIN_AREATYPES.SASH
|
|
if nSashAreaOutlineId and nAreaLayerId and nSashAreaType == WIN_AREATYPES.FRAME then
|
|
sProfileType = WIN_FRAME
|
|
elseif nSashAreaOutlineId and nAreaLayerId and nSashAreaType == WIN_AREATYPES.SASH then
|
|
sProfileType = WIN_SASH
|
|
end
|
|
end
|
|
-- recupero profilo usato per anta (o frame a vetro fisso)
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, sProfileType)
|
|
local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile)
|
|
-- recupero le relative origini
|
|
local nFrameSashProfileId = EgtGetFirstNameInGroup( nSashProfileId, WIN_SECTIONFRAME)
|
|
local frSashProfileId = EgtFR(nFrameSashProfileId)
|
|
-- calcolo il box del riferimento del profilo del frame
|
|
local nRefSashProfileId = EgtGetFirstNameInGroup( nSashProfileId, WIN_REF)
|
|
local b3FrameProfile = EgtGetBBoxRef( nRefSashProfileId, GDB_BB.STANDARD, frSashProfileId)
|
|
-- calcolo offset perpendicolare e sulla z dell'anta
|
|
local dOverlap = EgtGetInfo( nSashProfileId, WIN_FILLOVERLAP, 'd')
|
|
local dFillPerpOffset = abs( b3FrameProfile:getMin():getX()) - dOverlap
|
|
local dFillZOffset = EgtGetInfo( nSashProfileId, WIN_FILLDELTA, 'd')
|
|
-- copio outline del sash
|
|
local nFillOutlineId = EgtCopy( nParentOutlineId, nFillOutlineLayerId)
|
|
EgtSetInfo( nFillAreaOutlineId, WIN_CHILD, nFillOutlineId)
|
|
-- faccio offset
|
|
EgtOffsetCurve( nFillOutlineId, - dFillPerpOffset)
|
|
EgtMove( nFillOutlineId, Z_AX() * dFillZOffset)
|
|
nFillAreaOutlineId = EgtGetNext( nFillAreaOutlineId)
|
|
end
|
|
-- accorcio gli offset
|
|
WinCalculate.TrimAndOrientOrderedCurveLayer( nFillOutlineLayerId)
|
|
-- WinCalculate.TrimInOrderedCurveLayer( nFillOutlineLayerId)
|
|
|
|
-- elseif ...
|
|
|
|
end
|
|
end
|
|
|
|
-- funzione che verifica se ci sono Sash dopo
|
|
function WinCalculate.VerifyChildArea( nAreaId)
|
|
local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAASTERISK)
|
|
local nChildAreaType
|
|
if nChildAreaId then
|
|
nChildAreaType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, 'i')
|
|
if nChildAreaType == WIN_AREATYPES.SASH then
|
|
return true
|
|
end
|
|
if WinCalculate.VerifyChildArea( nChildAreaId) then return true end
|
|
end
|
|
while nChildAreaId and nChildAreaType ~= WIN_AREATYPES.SASH do
|
|
nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREAASTERISK)
|
|
if nChildAreaId then
|
|
nChildAreaType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, 'i')
|
|
if nChildAreaType == WIN_AREATYPES.SASH then
|
|
return true
|
|
end
|
|
end
|
|
if WinCalculate.VerifyChildArea( nChildAreaId) then return true end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- funzione che imposta i tipi di profilo in base al tipo di pezzi
|
|
function WinCalculate.CalcProfileType( nAreaId)
|
|
local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
if nAreaType == WIN_AREATYPES.FRAME then
|
|
-- verifico se ci sono Split
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT)
|
|
local nSplitType
|
|
if nSplitLayerId then
|
|
-- verifico il tipo di split
|
|
nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i')
|
|
if not nSplitType then
|
|
-- verifico se ci sono Sash prima
|
|
local nParentAreaId = nAreaId
|
|
local nParentAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
while nParentAreaId and nParentAreaType ~= WIN_AREATYPES.SASH do
|
|
nParentAreaId = EgtGetParent( nParentAreaId)
|
|
nParentAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
-- se non ci sono
|
|
if not nParentAreaId or nParentAreaId ~= WIN_AREATYPES.SASH then
|
|
-- verifico se ci sono Sash dopo
|
|
local bSashAfter = WinCalculate.VerifyChildArea( nAreaId)
|
|
-- se ci sono
|
|
if bSashAfter then
|
|
-- assegno tipo di profilo a mullion
|
|
EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, WIN_SPLITTYPES.MULLION)
|
|
nSplitType = WIN_SPLITTYPES.MULLION
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- se montante, devo considerare separatamente le due ante
|
|
if nSplitType and nSplitType == WIN_SPLITTYPES.MULLION then
|
|
-- assegno tipo di profilo al montante
|
|
local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
-- verifico direzione per dare nome
|
|
local vtMedia = ( ( EgtEV( nSplitId) - EgtSV( nSplitId)) / 2)
|
|
if not vtMedia:normalize() then
|
|
vtMedia = EgtSV( nSplitId)
|
|
end
|
|
if abs( vtMedia:getX()) > abs( vtMedia:getY()) then
|
|
EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_HORIZONTAL )
|
|
else
|
|
EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_VERTICAL )
|
|
end
|
|
-- ciclo su outline
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
-- recupero tipo del child
|
|
local nChildId = nOutlineId
|
|
local nChildAreaId
|
|
local nChildType
|
|
-- ciclo fino a trovare un child che non sia uno split
|
|
repeat
|
|
nChildId = EgtGetInfo( nChildId, WIN_CHILD)
|
|
nChildAreaId = EgtGetParent( EgtGetParent( nChildId))
|
|
nChildType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, 'i')
|
|
until not nChildId or ( nChildType ~= WIN_AREATYPES.SPLIT and nChildType ~= WIN_AREATYPES.NULL)
|
|
local sName = EgtGetName( nOutlineId)
|
|
if nChildType == WIN_AREATYPES.SASH then
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_BOTTOM)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_TOP)
|
|
end
|
|
elseif nChildType == WIN_AREATYPES.FILL then
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_BOTTOM)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_TOP)
|
|
end
|
|
end
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
-- se battente - ricevente, guardo tipo del contenuto
|
|
elseif nSplitType and nSplitType == WIN_SPLITTYPES.FRENCH then
|
|
-- ciclo su outline
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
local sName = EgtGetName( nOutlineId)
|
|
-- assegno tipo profilo
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_BOTTOM)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_TOP)
|
|
end
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
-- se interno a vetro fisso o senza split
|
|
else
|
|
-- se vetro fisso
|
|
if nSplitLayerId then
|
|
-- assegno tipo di profilo allo Split
|
|
local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_FRAME_SPLIT)
|
|
end
|
|
-- ciclo su outline
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
-- recupero tipo del child
|
|
local nChildId = nOutlineId
|
|
local nChildAreaId
|
|
local nChildType
|
|
-- ciclo fino a trovare un child che non sia uno split
|
|
repeat
|
|
nChildId = EgtGetInfo( nChildId, WIN_CHILD)
|
|
nChildAreaId = EgtGetParent( EgtGetParent( nChildId))
|
|
nChildType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, 'i')
|
|
until not nChildId or ( nChildType ~= WIN_AREATYPES.SPLIT and nChildType ~= WIN_AREATYPES.NULL)
|
|
local sName = EgtGetName( nOutlineId)
|
|
if nChildType == WIN_AREATYPES.SASH then
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_BOTTOM)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_TOP)
|
|
end
|
|
elseif nChildType == WIN_AREATYPES.FILL then
|
|
if sName == WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_BOTTOM)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FIXED_TOP)
|
|
end
|
|
end
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
end
|
|
elseif nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then
|
|
-- verifico se ci sono Split
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT)
|
|
-- se split non definito, verifico se sia implicitamente un mulion
|
|
if nSplitLayerId then
|
|
-- verifico il tipo di split
|
|
local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i')
|
|
if not nSplitType then
|
|
-- verifico il tipo di split
|
|
nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i')
|
|
if not nSplitType then
|
|
-- verifico se ci sono Sash prima
|
|
local nParentAreaId = nAreaId
|
|
local nParentAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
while nParentAreaId and nParentAreaType ~= WIN_AREATYPES.SASH do
|
|
nParentAreaId = EgtGetParent( nParentAreaId)
|
|
nParentAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
-- se non ci sono
|
|
if not nParentAreaId or nParentAreaId ~= WIN_AREATYPES.SASH then
|
|
-- verifico se ci sono Sash dopo
|
|
local bSashAfter = WinCalculate.VerifyChildArea( nAreaId)
|
|
-- se ci sono
|
|
if bSashAfter then
|
|
-- assegno tipo di profilo a mullion
|
|
EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, WIN_SPLITTYPES.MULLION)
|
|
nSplitType = WIN_SPLITTYPES.MULLION
|
|
end
|
|
end
|
|
end
|
|
end
|
|
-- se split non definito
|
|
if not nSplitType then
|
|
-- se split interno ad anta
|
|
local nParentAreaId = EgtGetParent( nAreaId)
|
|
local nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i')
|
|
while nParentAreaType ~= WIN_AREATYPES.FRAME and nParentAreaType ~= WIN_AREATYPES.SASH do
|
|
nParentAreaId = EgtGetParent( nParentAreaId)
|
|
nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
-- assegno tipo di profilo allo Split
|
|
local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
if nParentAreaType == WIN_AREATYPES.SASH then
|
|
EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_SPLIT )
|
|
else
|
|
-- altrimenti vetro fisso
|
|
EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_FRAME_SPLIT )
|
|
end
|
|
end
|
|
-- se montante
|
|
if nSplitType == WIN_SPLITTYPES.MULLION then
|
|
-- assegno tipo di profilo al montante
|
|
local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
-- verifico direzione per dare nome
|
|
local vtMedia = ( ( EgtEV( nSplitId) - EgtSV( nSplitId)) / 2)
|
|
if not vtMedia:normalize() then
|
|
vtMedia = EgtSV( nSplitId)
|
|
end
|
|
if abs( vtMedia:getX()) > abs( vtMedia:getY()) then
|
|
EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_HORIZONTAL )
|
|
else
|
|
EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_VERTICAL )
|
|
end
|
|
end
|
|
end
|
|
elseif nAreaType == WIN_AREATYPES.SASH then
|
|
-- verifico se e' di tipo battente ricevente
|
|
local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i')
|
|
if nSashType and nSashType ~= WIN_SASHTYPES.NULL then
|
|
-- imposto profili sash
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
-- faccio sou due volte per trovare il tipo dell'outline originale da cui deriva
|
|
local nSouId = EgtGetInfo( nOutlineId, WIN_SOU, 'i')
|
|
nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i')
|
|
local nSouLayerId = EgtGetParent( nSouId)
|
|
local sSouLayerName = EgtGetName( nSouLayerId)
|
|
if sSouLayerName == WIN_BASESPLIT then
|
|
if nSashType == WIN_SASHTYPES.ACTIVE then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE)
|
|
elseif nSashType == WIN_SASHTYPES.INACTIVE then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_INACTIVE)
|
|
end
|
|
else
|
|
local sName = EgtGetName( nOutlineId)
|
|
if sName ~= WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM)
|
|
end
|
|
end
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
else
|
|
-- imposto profili sash
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE)
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
local sName = EgtGetName( nOutlineId)
|
|
if sName ~= WIN_BOTTOM then
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP)
|
|
else
|
|
EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM)
|
|
end
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
end
|
|
-- verifico se ci sono Split
|
|
local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT)
|
|
if nSplitLayerId then
|
|
-- assegno tipo di profilo
|
|
local nSplitId = EgtGetFirstInGroup( nSplitLayerId)
|
|
EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_SPLIT )
|
|
end
|
|
|
|
|
|
|
|
|
|
-- elseif ...
|
|
|
|
end
|
|
end
|
|
|
|
-- funzione che restituisce BBox del Ref del profilo
|
|
function WinCalculate.GetRefWithBBoxFromProfile( nProfileFrameLayerId, sProfileType)
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileFrameLayerId, sProfileType)
|
|
local nSectionFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frSectionFrame = EgtFR( nSectionFrameId)
|
|
local nProfileRefId = EgtGetFirstNameInGroup( nProfileId, WIN_REF)
|
|
local b3Ref = EgtGetBBoxRef( nProfileRefId, GDB_BB.STANDARD, frSectionFrame)
|
|
return nProfileId, b3Ref, nProfileRefId, frSectionFrame
|
|
end
|
|
|
|
-- funzione che restituisce ref e calcola delta controprofilo dal profilo passatogli
|
|
function WinCalculate.GetDeltaProfile( nProfileFrameLayerId, sProfileType, sCtrIn)
|
|
local nProfileId, b3Ref, nProfileRefId, frSectionFrame = WinCalculate.GetRefWithBBoxFromProfile( nProfileFrameLayerId, sProfileType)
|
|
local dCPDelta = 0
|
|
if sCtrIn then
|
|
local nCPId = EgtGetFirstNameInGroup( nProfileId, sCtrIn)
|
|
local b3CP = EgtGetBBoxRef( nCPId, GDB_BB.STANDARD, frSectionFrame)
|
|
if sCtrIn == WIN_CTRIN .. WIN_BOTTOM then
|
|
dCPDelta = abs( b3CP:getMin():getX())
|
|
else
|
|
dCPDelta = abs( b3CP:getMax():getX())
|
|
end
|
|
--local dCPDelta = abs( b3Ref:getMin():getX() - b3CP:getDimX())
|
|
end
|
|
return dCPDelta, b3Ref, nProfileId, nProfileRefId
|
|
end
|
|
|
|
-- funzione che dato l'outline adiacente ed il tipo di profilo, restituisce il tipo di profilo dell'outline adiacente
|
|
function WinCalculate.GetProfileType( nProfileType, nPrevOutlineId)
|
|
if nProfileType == WIN_PRF.SPLIT then
|
|
local nOrigPrevSouId = nPrevOutlineId
|
|
local nOrigPrevSouAreaId = EgtGetParent( EgtGetParent( nOrigPrevSouId))
|
|
local nOrigPrevSouType = EgtGetInfo( nOrigPrevSouAreaId, WIN_AREATYPE, 'i')
|
|
while nOrigPrevSouId and nOrigPrevSouType == WIN_AREATYPES.SPLIT do
|
|
nOrigPrevSouId = EgtGetInfo( nOrigPrevSouId, WIN_SOU)
|
|
nOrigPrevSouAreaId = EgtGetParent( EgtGetParent( nOrigPrevSouId))
|
|
nOrigPrevSouType = EgtGetInfo( nOrigPrevSouAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
-- se profilo bottom
|
|
local sPrevName = EgtGetName( nOrigPrevSouId)
|
|
if sPrevName == WIN_BOTTOM then
|
|
-- ed e' presente BottomRail
|
|
local nBottomRailId = EgtGetInfo( nOrigPrevSouId, WIN_BOTTOMRAIL, 'i')
|
|
if nBottomRailId and nBottomRailId > 1 then
|
|
-- allora imposto profilo BottomRail
|
|
return WIN_RAIL_BOTTOM
|
|
else
|
|
return EgtGetInfo( nOrigPrevSouId, WIN_PROFILETYPE)
|
|
end
|
|
end
|
|
return EgtGetInfo( nOrigPrevSouId, WIN_PROFILETYPE)
|
|
else
|
|
return EgtGetInfo( nPrevOutlineId, WIN_PROFILETYPE)
|
|
end
|
|
end
|
|
|
|
-- funzione che restituisce il tipo di profilo e di controprofilo dell'outline adiacente
|
|
function WinCalculate.GetProfileData( nProfileType, nPrevOutlineId, nOutlineId, nProfileFrameLayerId)
|
|
local sPrevProfileType = WinCalculate.GetProfileType( nProfileType, nPrevOutlineId)
|
|
-- recupero box dei controprofili rispetto al loro sistema di riferimento
|
|
local nProfileId = EgtGetFirstNameInGroup( nProfileFrameLayerId, sPrevProfileType)
|
|
return sPrevProfileType, WinCalculate.GetProfileCtrIn( nProfileType, nPrevOutlineId, nOutlineId, nProfileId)
|
|
end
|
|
|
|
-- funzione che restituisce il tipo di controprofilo dell'outline adiacente
|
|
function WinCalculate.GetProfileCtrIn( nProfileType, nPrevOutlineId, nOutlineId, nProfileId)
|
|
local sPrevCtrIn = WIN_CTRIN
|
|
if nProfileType == WIN_PRF.SPLIT then
|
|
-- verifico se il prev e' uno split
|
|
local nPrevSouId = nPrevOutlineId
|
|
local nPrevSouParentId
|
|
local sPrevSouParentId
|
|
repeat
|
|
nPrevSouId = EgtGetInfo( nPrevSouId, WIN_SOU)
|
|
if nPrevSouId then
|
|
nPrevSouParentId = EgtGetParent( nPrevSouId)
|
|
sPrevSouParentId = EgtGetName( nPrevSouParentId)
|
|
end
|
|
until not nPrevSouId or sPrevSouParentId == WIN_BASESPLIT
|
|
if nPrevSouId and sPrevSouParentId == WIN_BASESPLIT then
|
|
-- verifico da che lato sono dello split
|
|
local dOutlineDist, _, dSide = EgtPointCurveDistSide( EgtMP( nOutlineId), nPrevSouId, Z_AX())
|
|
-- recupero box dei controprofili rispetto al loro sistema di riferimento
|
|
local nSectionFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
local frSectionFrame = EgtFR( nSectionFrameId, GDB_ID.ROOT)
|
|
local dMinDist
|
|
-- confronto distanze dei controprofili rispetto a distanza dell'outline per trovare il controprofilo piu' vicino
|
|
local nMinCtrInId
|
|
local nCtrInId = EgtGetFirstNameInGroup( nProfileId, WIN_CTRIN .. '*')
|
|
while nCtrInId do
|
|
local b3CtrIn = EgtGetBBoxRef( nCtrInId, GDB_BB.STANDARD, frSectionFrame)
|
|
local dCtrInDist = abs( ( dSide * dOutlineDist) - b3CtrIn:getCenter():getX())
|
|
if not dMinDist or dCtrInDist < dMinDist then
|
|
dMinDist = dCtrInDist
|
|
nMinCtrInId = nCtrInId
|
|
end
|
|
nCtrInId = EgtGetNextName( nCtrInId, WIN_CTRIN .. '*')
|
|
end
|
|
if nMinCtrInId then
|
|
sPrevCtrIn = EgtGetName( nMinCtrInId)
|
|
end
|
|
end
|
|
end
|
|
return sPrevCtrIn
|
|
end
|
|
|
|
-- -- funzione che restituisce il tipo di controprofilo
|
|
-- function WinCalculate.GetProfileData( nProfileType, nPrevOutlineId, nOutlineId, nProfileFrameLayerId)
|
|
-- local sPrevProfileType
|
|
-- local sPrevCtrIn = WIN_CTRIN
|
|
-- if nProfileType == WIN_PRF.SPLIT then
|
|
-- local nOrigPrevSouId = nPrevOutlineId
|
|
-- local nOrigPrevSouAreaId = EgtGetParent( EgtGetParent( nOrigPrevSouId))
|
|
-- local nOrigPrevSouType = EgtGetInfo( nOrigPrevSouAreaId, WIN_AREATYPE, 'i')
|
|
-- while nOrigPrevSouId and nOrigPrevSouType == WIN_AREATYPES.SPLIT do
|
|
-- nOrigPrevSouId = EgtGetInfo( nOrigPrevSouId, WIN_SOU)
|
|
-- nOrigPrevSouAreaId = EgtGetParent( EgtGetParent( nOrigPrevSouId))
|
|
-- nOrigPrevSouType = EgtGetInfo( nOrigPrevSouAreaId, WIN_AREATYPE, 'i')
|
|
-- end
|
|
-- sPrevProfileType = EgtGetInfo( nOrigPrevSouId, WIN_PROFILETYPE)
|
|
-- local sPrevName = EgtGetName( nPrevOutlineId)
|
|
-- -- verifico se il prev e' uno split
|
|
-- local nPrevSouId = nPrevOutlineId
|
|
-- local nPrevSouParentId
|
|
-- local sPrevSouParentId
|
|
-- repeat
|
|
-- nPrevSouId = EgtGetInfo( nPrevSouId, WIN_SOU)
|
|
-- if nPrevSouId then
|
|
-- nPrevSouParentId = EgtGetParent( nPrevSouId)
|
|
-- sPrevSouParentId = EgtGetName( nPrevSouParentId)
|
|
-- end
|
|
-- until not nPrevSouId or sPrevSouParentId == WIN_BASESPLIT
|
|
-- if nPrevSouId and sPrevSouParentId == WIN_BASESPLIT then
|
|
-- -- verifico da che lato sono dello split
|
|
-- local dOutlineDist = EgtPointCurveDist( EgtMP( nOutlineId), nPrevOutlineId)
|
|
-- -- recupero box dei controprofili rispetto al loro sistema di riferimento
|
|
-- local nProfileId = EgtGetFirstNameInGroup( nProfileFrameLayerId, sPrevProfileType)
|
|
-- local nSectionFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME)
|
|
-- local frSectionFrame = EgtFR( nSectionFrameId)
|
|
-- local dMinDist
|
|
-- -- confronto distanze dei controprofili rispetto a distanza dell'outline per trovare il controprofilo piu' vicino
|
|
-- local nMinCtrInId
|
|
-- local nCtrInId = EgtGetFirstNameInGroup( nProfileId, WIN_CTRIN .. '*')
|
|
-- while nCtrInId do
|
|
-- local b3CtrIn = EgtGetBBoxRef( nCtrInId, GDB_BB.STANDARD, frSectionFrame)
|
|
-- local dCtrInDist = abs( dOutlineDist - b3CtrIn:getCenter():getX())
|
|
-- if not dMinDist or dCtrInDist < dMinDist then
|
|
-- dMinDist = dCtrInDist
|
|
-- nMinCtrInId = nCtrInId
|
|
-- end
|
|
-- nCtrInId = EgtGetNextName( WIN_CTRIN .. '*')
|
|
-- end
|
|
-- if nMinCtrInId then
|
|
-- sPrevCtrIn = EgtGetName( nMinCtrInId)
|
|
-- end
|
|
|
|
|
|
|
|
|
|
|
|
|
|
-- -- -- se usa profilo verticale
|
|
-- -- if sPrevProfileType == WIN_SASH_VERTICAL then
|
|
-- -- if sPrevName == WIN_LEFT or sPrevName == WIN_TOP then
|
|
-- -- sPrevCtrIn = sPrevCtrIn .. WIN_RIGHT
|
|
-- -- elseif sPrevName == WIN_RIGHT or sPrevName == WIN_BOTTOM then
|
|
-- -- sPrevCtrIn = sPrevCtrIn .. WIN_LEFT
|
|
-- -- end
|
|
-- -- elseif sPrevProfileType == WIN_SASH_HORIZONTAL then
|
|
-- -- if sPrevName == WIN_TOP or sPrevName == WIN_RIGHT then
|
|
-- -- sPrevCtrIn = sPrevCtrIn .. WIN_BOTTOM
|
|
-- -- elseif sPrevName == WIN_BOTTOM or sPrevName == WIN_LEFT then
|
|
-- -- sPrevCtrIn = sPrevCtrIn .. WIN_TOP
|
|
-- -- end
|
|
-- -- elseif sPrevProfileType == WIN_SASH_SPLIT then
|
|
-- -- if sPrevName == WIN_LEFT or sPrevName == WIN_TOP then
|
|
-- -- sPrevCtrIn = sPrevCtrIn .. WIN_LEFT
|
|
-- -- elseif sPrevName == WIN_RIGHT or sPrevName == WIN_BOTTOM then
|
|
-- -- sPrevCtrIn = sPrevCtrIn .. WIN_LEFT
|
|
-- -- end
|
|
-- -- end
|
|
-- end
|
|
-- else
|
|
-- sPrevProfileType = EgtGetInfo( nPrevOutlineId, WIN_PROFILETYPE)
|
|
-- end
|
|
-- return sPrevProfileType, sPrevCtrIn
|
|
-- end
|
|
|
|
-- funzione che crea le curve del geo
|
|
function WinCalculate.CreateFrameGeo( nOutlineId, nPrevOutlineId, nNextOutlineId, StartJointType, EndJointType, nProfileType, nGeoLayerId, nProfileFrameLayerId, bBottomRail)
|
|
local nCurrCurveId
|
|
local nCurrOffsetId
|
|
local nPrevCurveId
|
|
local nNextCurveId
|
|
local dGeoWidth
|
|
-- recupero ref e controprofilo e calcolo delta del top, prev e next
|
|
local sCurrProfileType = EgtGetInfo( nOutlineId, WIN_PROFILETYPE)
|
|
if bBottomRail then
|
|
sCurrProfileType = WIN_RAIL_BOTTOM
|
|
end
|
|
local _, b3CurrRef, nCurrProfileId, nCurrProfileRefId = WinCalculate.GetDeltaProfile( nProfileFrameLayerId, sCurrProfileType)
|
|
local sPrevProfileType, sPrevCtrIn = WinCalculate.GetProfileData( nProfileType, nPrevOutlineId, nOutlineId, nProfileFrameLayerId)
|
|
local dPrevCPDelta, _ = WinCalculate.GetDeltaProfile( nProfileFrameLayerId, sPrevProfileType, sPrevCtrIn)
|
|
local sNextProfileType, sNextCtrIn = WinCalculate.GetProfileData( nProfileType, nNextOutlineId, nOutlineId, nProfileFrameLayerId)
|
|
local dNextCPDelta, _ = WinCalculate.GetDeltaProfile( nProfileFrameLayerId, sNextProfileType, sNextCtrIn)
|
|
-- calcolo spostamento della curva iniziale dovuto a posizione riferimento
|
|
local nProfileFrameId = EgtGetFirstNameInGroup( nCurrProfileId, WIN_SECTIONFRAME)
|
|
local frProfile = EgtFR( nProfileFrameId)
|
|
local b3CurrProfileFrame = EgtGetBBoxRef( nCurrProfileRefId, GDB_BB.STANDARD, frProfile)
|
|
local dCurrOffset = b3CurrProfileFrame:getMax():getX()
|
|
-- creo copie degli outline e li offsetto opportunamente
|
|
nCurrCurveId = EgtCopy( nOutlineId, nGeoLayerId)
|
|
EgtOffsetCurve( nCurrCurveId, dCurrOffset)
|
|
nCurrOffsetId = EgtCopy( nOutlineId, nGeoLayerId)
|
|
EgtOffsetCurve( nCurrOffsetId, dCurrOffset - b3CurrProfileFrame:getDimX())
|
|
EgtInvertCurve( nCurrOffsetId)
|
|
if StartJointType == WIN_JNT.ANGLED then
|
|
-- calcolo la bisettrice
|
|
local vtMedia = ( ( EgtSV( nOutlineId) - EgtEV( nPrevOutlineId)) / 2)
|
|
if not vtMedia:normalize() then
|
|
vtMedia = EgtSV( nOutlineId)
|
|
vtMedia:rotate(Z_AX(), 90)
|
|
end
|
|
nPrevCurveId = EgtLinePVL( nGeoLayerId, EgtSP( nOutlineId), vtMedia, 3 * b3CurrProfileFrame:getDimX())
|
|
EgtInvertCurve( nPrevCurveId)
|
|
else
|
|
nPrevCurveId = EgtCopy( nPrevOutlineId, nGeoLayerId)
|
|
end
|
|
if ( StartJointType == WIN_JNT.FULL_V and ( nProfileType == WIN_PRF.BOTTOM or nProfileType == WIN_PRF.TOP or nProfileType == WIN_PRF.HORIZONTAL or nProfileType == WIN_PRF.BOTTOMRAIL)) or
|
|
( StartJointType == WIN_JNT.FULL_H and ( nProfileType == WIN_PRF.RIGHT or nProfileType == WIN_PRF.LEFT or nProfileType == WIN_PRF.VERTICAL)) or
|
|
nProfileType == WIN_PRF.SPLIT then
|
|
EgtOffsetCurve( nPrevCurveId, - dPrevCPDelta)
|
|
EgtSetInfo( nGeoLayerId, WIN_STARTCPDELTA, dPrevCPDelta)
|
|
end
|
|
if EndJointType == WIN_JNT.ANGLED then
|
|
-- calcolo la bisettrice
|
|
local vtMedia = ( ( EgtSV( nNextOutlineId) - EgtEV( nOutlineId)) / 2)
|
|
if not vtMedia:normalize() then
|
|
vtMedia = EgtEV( nOutlineId)
|
|
vtMedia:rotate(Z_AX(), 90)
|
|
end
|
|
nNextCurveId = EgtLinePVL( nGeoLayerId, EgtEP( nOutlineId), vtMedia, 3 * b3CurrProfileFrame:getDimX())
|
|
else
|
|
nNextCurveId = EgtCopy( nNextOutlineId, nGeoLayerId)
|
|
end
|
|
if ( EndJointType == WIN_JNT.FULL_V and ( nProfileType == WIN_PRF.BOTTOM or nProfileType == WIN_PRF.TOP or nProfileType == WIN_PRF.HORIZONTAL or nProfileType == WIN_PRF.BOTTOMRAIL)) or
|
|
( EndJointType == WIN_JNT.FULL_H and ( nProfileType == WIN_PRF.RIGHT or nProfileType == WIN_PRF.LEFT or nProfileType == WIN_PRF.VERTICAL)) or
|
|
nProfileType == WIN_PRF.SPLIT then
|
|
EgtOffsetCurve( nNextCurveId, - dNextCPDelta)
|
|
EgtSetInfo( nGeoLayerId, WIN_ENDCPDELTA, dNextCPDelta)
|
|
end
|
|
dGeoWidth = b3CurrProfileFrame:getDimX()
|
|
return nCurrCurveId, nCurrOffsetId, nPrevCurveId, nNextCurveId, dGeoWidth
|
|
end
|
|
|
|
-- funzione che dato il tipo di pezzo e di giunzione, restituisce se e' corto, lungo o angolato
|
|
local function CalcPartJointType( nProfileType, JointType)
|
|
if JointType == WIN_JNT.ANGLED then
|
|
return WIN_PART_JNT.ANGLED
|
|
end
|
|
if nProfileType == WIN_PRF.BOTTOMRAIL or nProfileType == WIN_PRF.SPLIT then
|
|
return WIN_PART_JNT.SHORT
|
|
elseif nProfileType == WIN_PRF.BOTTOM or nProfileType == WIN_PRF.TOP then
|
|
if JointType == WIN_JNT.FULL_H then
|
|
return WIN_PART_JNT.FULL
|
|
elseif JointType == WIN_JNT.FULL_V then
|
|
return WIN_PART_JNT.SHORT
|
|
end
|
|
elseif nProfileType == WIN_PRF.LEFT or nProfileType == WIN_PRF.RIGHT then
|
|
if JointType == WIN_JNT.FULL_V then
|
|
return WIN_PART_JNT.FULL
|
|
elseif JointType == WIN_JNT.FULL_H then
|
|
return WIN_PART_JNT.SHORT
|
|
end
|
|
end
|
|
end
|
|
|
|
-- funzione che calcola l'ingombro dei pezzi del telaio
|
|
function WinCalculate.CalcFrameGeo( nPartId, nOutlineId, nOutlineLayerId, bBottomRail)
|
|
-- recupero profilo
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nAreaId = nOutlineLayerId
|
|
local nAreaType
|
|
-- ciclo fino a trovare un child che non sia uno split
|
|
repeat
|
|
nAreaId = EgtGetParent( nAreaId)
|
|
nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
until not nAreaId or ( nAreaType ~= WIN_AREATYPES.SPLIT and nAreaType ~= WIN_AREATYPES.NULL)
|
|
local nProfileFrameLayerId
|
|
if nAreaType == WIN_AREATYPES.FRAME then
|
|
nProfileFrameLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_FRAME)
|
|
elseif nAreaType == WIN_AREATYPES.SASH then
|
|
nProfileFrameLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
|
|
end
|
|
-- creo layer per ingombro
|
|
local nGeoLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nGeoLayerId, WIN_GEO)
|
|
-- ricavo tipo dal nome
|
|
local sName = EgtGetName( nOutlineId)
|
|
local nProfileType = WIN_PRF.NULL
|
|
if bBottomRail then
|
|
nProfileType = WIN_PRF.BOTTOMRAIL
|
|
elseif sName == WIN_TOP then
|
|
nProfileType = WIN_PRF.TOP
|
|
elseif sName == WIN_BOTTOM then
|
|
nProfileType = WIN_PRF.BOTTOM
|
|
elseif sName == WIN_LEFT then
|
|
nProfileType = WIN_PRF.LEFT
|
|
elseif sName == WIN_RIGHT then
|
|
nProfileType = WIN_PRF.RIGHT
|
|
elseif sName == WIN_VERTICAL then
|
|
nProfileType = WIN_PRF.VERTICAL
|
|
elseif sName == WIN_HORIZONTAL then
|
|
nProfileType = WIN_PRF.HORIZONTAL
|
|
elseif sName == WIN_SPLIT then
|
|
nProfileType = WIN_PRF.SPLIT
|
|
end
|
|
local StartJointType
|
|
local EndJointType
|
|
local nNextOutlineId
|
|
local nPrevOutlineId
|
|
local nCurrCurveId
|
|
local nCurrOffsetId
|
|
local nPrevCurveId
|
|
local nNextCurveId
|
|
local dGeoWidth
|
|
if nProfileType == WIN_PRF.BOTTOMRAIL then
|
|
StartJointType = WIN_JNT.FULL_V
|
|
EndJointType = WIN_JNT.FULL_V
|
|
elseif nProfileType == WIN_PRF.TOP then
|
|
-- recupero tipo di giunzioni
|
|
StartJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_TR, 'i')
|
|
EndJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_TL, 'i')
|
|
-- imposto valori joint su outline per disegno solido
|
|
EgtSetInfo( nOutlineId, WIN_STARTJOINT, CalcPartJointType( nProfileType, StartJointType))
|
|
EgtSetInfo( nOutlineId, WIN_ENDJOINT, CalcPartJointType( nProfileType, EndJointType))
|
|
elseif nProfileType == WIN_PRF.BOTTOM then
|
|
-- recupero tipo di giunzioni
|
|
StartJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_BL, 'i')
|
|
EndJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_BR, 'i')
|
|
-- imposto valori joint su outline per disegno solido
|
|
EgtSetInfo( nOutlineId, WIN_STARTJOINT, CalcPartJointType( nProfileType, StartJointType))
|
|
EgtSetInfo( nOutlineId, WIN_ENDJOINT, CalcPartJointType( nProfileType, EndJointType))
|
|
elseif nProfileType == WIN_PRF.LEFT then
|
|
-- recupero tipo di giunzioni
|
|
StartJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_TL, 'i')
|
|
EndJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_BL, 'i')
|
|
-- imposto valori joint su outline per disegno solido
|
|
EgtSetInfo( nOutlineId, WIN_STARTJOINT, CalcPartJointType( nProfileType, StartJointType))
|
|
EgtSetInfo( nOutlineId, WIN_ENDJOINT, CalcPartJointType( nProfileType, EndJointType))
|
|
elseif nProfileType == WIN_PRF.RIGHT then
|
|
-- recupero tipo di giunzioni
|
|
StartJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_BR, 'i')
|
|
EndJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_TR, 'i')
|
|
-- imposto valori joint su outline per disegno solido
|
|
EgtSetInfo( nOutlineId, WIN_STARTJOINT, CalcPartJointType( nProfileType, StartJointType))
|
|
EgtSetInfo( nOutlineId, WIN_ENDJOINT, CalcPartJointType( nProfileType, EndJointType))
|
|
elseif nProfileType == WIN_PRF.VERTICAL then
|
|
-- recupero tipo di giunzioni
|
|
StartJointType = WIN_JNT.FULL_H
|
|
EndJointType = WIN_JNT.FULL_H
|
|
-- imposto valori joint su outline per disegno solido
|
|
EgtSetInfo( nOutlineId, WIN_STARTJOINT, CalcPartJointType( nProfileType, StartJointType))
|
|
EgtSetInfo( nOutlineId, WIN_ENDJOINT, CalcPartJointType( nProfileType, EndJointType))
|
|
-- recupero outline precedente
|
|
nPrevOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
nNextOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
elseif nProfileType == WIN_PRF.HORIZONTAL then
|
|
-- recupero tipo di giunzioni
|
|
StartJointType = WIN_JNT.FULL_V
|
|
EndJointType = WIN_JNT.FULL_V
|
|
-- imposto valori joint su outline per disegno solido
|
|
EgtSetInfo( nOutlineId, WIN_STARTJOINT, CalcPartJointType( nProfileType, StartJointType))
|
|
EgtSetInfo( nOutlineId, WIN_ENDJOINT, CalcPartJointType( nProfileType, EndJointType))
|
|
-- recupero outline precedente
|
|
nPrevOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
nNextOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
elseif nProfileType == WIN_PRF.SPLIT then
|
|
local nStartId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
local nEndId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
local sStartName = EgtGetName( nStartId)
|
|
local sEndName = EgtGetName( nEndId)
|
|
-- recupero tipo di giunzioni
|
|
if sStartName == WIN_BOTTOM or sStartName == WIN_TOP then
|
|
StartJointType = WIN_JNT.FULL_H
|
|
else
|
|
StartJointType = WIN_JNT.FULL_V
|
|
end
|
|
if sEndName == WIN_BOTTOM or sEndName == WIN_TOP then
|
|
EndJointType = WIN_JNT.FULL_H
|
|
else
|
|
EndJointType = WIN_JNT.FULL_V
|
|
end
|
|
-- imposto valori joint su outline per disegno solido
|
|
EgtSetInfo( nOutlineId, WIN_STARTJOINT, CalcPartJointType( nProfileType, StartJointType))
|
|
EgtSetInfo( nOutlineId, WIN_ENDJOINT, CalcPartJointType( nProfileType, EndJointType))
|
|
-- recupero outline precedente e successivo
|
|
local nPrevBaseOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
nPrevOutlineId = EgtGetInfo( nPrevBaseOutlineId, WIN_COPY, 'i')
|
|
local nNextBaseOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
nNextOutlineId = EgtGetInfo( nNextBaseOutlineId, WIN_COPY, 'i')
|
|
end
|
|
-- recupero outline precedente
|
|
if not nPrevOutlineId then
|
|
nPrevOutlineId = EgtGetPrev( nOutlineId)
|
|
if not nPrevOutlineId then
|
|
nPrevOutlineId = EgtGetLastInGroup( nOutlineLayerId)
|
|
end
|
|
end
|
|
if not nNextOutlineId then
|
|
nNextOutlineId = EgtGetNext( nOutlineId)
|
|
if not nNextOutlineId then
|
|
nNextOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
end
|
|
end
|
|
-- se pezzo non e' split, giunzione diversa da bisettrice ed arco a tutto sesto
|
|
if nProfileType ~= WIN_PRF.SPLIT and StartJointType ~= WIN_JNT.ANGLED and AreSameVectorApprox( EgtEV( nPrevOutlineId), EgtSV( nOutlineId)) then
|
|
-- imposto giunzione a bisettrice
|
|
StartJointType = WIN_JNT.ANGLED
|
|
-- EgtSetInfo( nOutlineLayerId, WIN_JOINT_TR, 'i')
|
|
end
|
|
if nProfileType ~= WIN_PRF.SPLIT and EndJointType ~= WIN_JNT.ANGLED and AreSameVectorApprox( EgtEV( nOutlineId), EgtSV( nNextOutlineId)) then
|
|
-- imposto giunzione a bisettrice
|
|
EndJointType = WIN_JNT.ANGLED
|
|
-- EgtSetInfo( nOutlineLayerId, WIN_JOINT_TR, 'i')
|
|
end
|
|
-- creo lati dell'outline
|
|
nCurrCurveId, nCurrOffsetId, nPrevCurveId, nNextCurveId, dGeoWidth = WinCalculate.CreateFrameGeo( nOutlineId, nPrevOutlineId, nNextOutlineId, StartJointType, EndJointType, nProfileType, nGeoLayerId, nProfileFrameLayerId, bBottomRail)
|
|
-- calcolo punti di intersezione
|
|
local ptIntersCurrPrev = EgtIP( nCurrCurveId, nPrevCurveId, EgtSP( nCurrCurveId))
|
|
if not ptIntersCurrPrev then
|
|
-- allungo per intersecare
|
|
EgtExtendCurveStartByLen( nCurrCurveId, 200)
|
|
EgtExtendCurveEndByLen( nPrevCurveId, 200)
|
|
ptIntersCurrPrev = EgtIP( nCurrCurveId, nPrevCurveId, EgtSP( nCurrCurveId))
|
|
end
|
|
local ptIntersCurrNext = EgtIP( nCurrCurveId, nNextCurveId, EgtEP( nCurrCurveId))
|
|
if not ptIntersCurrNext then
|
|
-- allungo per intersecare
|
|
EgtExtendCurveEndByLen( nCurrCurveId, 200)
|
|
EgtExtendCurveStartByLen( nNextCurveId, 200)
|
|
ptIntersCurrNext = EgtIP( nCurrCurveId, nNextCurveId, EgtEP( nCurrCurveId))
|
|
end
|
|
local ptIntersCurrOffsetPrev = EgtIP( nCurrOffsetId, nPrevCurveId, EgtEP( nCurrOffsetId))
|
|
if not ptIntersCurrOffsetPrev then
|
|
-- allungo per intersecare
|
|
EgtExtendCurveEndByLen( nCurrOffsetId, 1000)
|
|
EgtExtendCurveStartByLen( nPrevCurveId, 200)
|
|
ptIntersCurrOffsetPrev = EgtIP( nCurrOffsetId, nPrevCurveId, EgtEP( nCurrOffsetId))
|
|
end
|
|
local ptIntersCurrOffsetNext = EgtIP( nCurrOffsetId, nNextCurveId, EgtSP( nCurrOffsetId))
|
|
if not ptIntersCurrOffsetNext then
|
|
-- allungo per intersecare
|
|
EgtExtendCurveStartByLen( nCurrOffsetId, 1000)
|
|
EgtExtendCurveStartByLen( nNextCurveId, 200)
|
|
ptIntersCurrOffsetNext = EgtIP( nCurrOffsetId, nNextCurveId, EgtSP( nCurrOffsetId))
|
|
end
|
|
-- calcolo accorciamenti dei lati copiati alle intersezioni
|
|
local dIntersCurrPrevParam = EgtCurveParamAtPoint( nCurrCurveId, ptIntersCurrPrev)
|
|
EgtTrimCurveStartAtParam( nCurrCurveId, dIntersCurrPrevParam)
|
|
local dIntersCurrNextParam = EgtCurveParamAtPoint( nCurrCurveId, ptIntersCurrNext)
|
|
EgtTrimCurveEndAtParam( nCurrCurveId, dIntersCurrNextParam)
|
|
local dIntersCurrOffsetNextParam = EgtCurveParamAtPoint( nCurrOffsetId, ptIntersCurrOffsetNext)
|
|
EgtTrimCurveStartAtParam( nCurrOffsetId, dIntersCurrOffsetNextParam)
|
|
local dIntersCurrOffsetPrevParam = EgtCurveParamAtPoint( nCurrOffsetId, ptIntersCurrOffsetPrev)
|
|
EgtTrimCurveEndAtParam( nCurrOffsetId, dIntersCurrOffsetPrevParam)
|
|
local dIntersPrevOffsetParam = EgtCurveParamAtPoint( nPrevCurveId, ptIntersCurrOffsetPrev)
|
|
EgtTrimCurveStartAtParam( nPrevCurveId, dIntersPrevOffsetParam)
|
|
local dIntersPrevCurrParam = EgtCurveParamAtPoint( nPrevCurveId, ptIntersCurrPrev)
|
|
EgtTrimCurveEndAtParam( nPrevCurveId, dIntersPrevCurrParam)
|
|
local dIntersNextCurrParam = EgtCurveParamAtPoint( nNextCurveId, ptIntersCurrNext)
|
|
EgtTrimCurveStartAtParam( nNextCurveId, dIntersNextCurrParam)
|
|
local dIntersNextOffsetParam = EgtCurveParamAtPoint( nNextCurveId, ptIntersCurrOffsetNext)
|
|
EgtTrimCurveEndAtParam( nNextCurveId, dIntersNextOffsetParam)
|
|
-- creo composita dai lati
|
|
EgtSetName( nCurrCurveId, WIN_GEO_OUT)
|
|
EgtSetName( nCurrOffsetId, WIN_GEO_IN)
|
|
EgtSetName( nNextCurveId, WIN_GEO_RIGHT)
|
|
EgtSetName( nPrevCurveId, WIN_GEO_LEFT)
|
|
-- salvo spessore serramento in geo
|
|
EgtSetInfo( nCurrCurveId, WIN_GEOWIDTH, dGeoWidth)
|
|
|
|
return nCurrCurveId
|
|
end
|
|
|
|
-- funzione che calcola l'ingombro del fill
|
|
function WinCalculate.CalcFillGeo( nPartId, nOutlineLayerId)
|
|
-- creo layer per ingombro
|
|
local nGeoLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nGeoLayerId, WIN_GEO)
|
|
-- copio lati da Outline
|
|
local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
while nOutlineId do
|
|
EgtCopy( nOutlineId, nGeoLayerId)
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
-- recupero e salvo spessore vetro
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nSashProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
|
|
local dGlassThickness = EgtGetInfo( nSashProfileId, WIN_GLASSTHICKNESS, 'd')
|
|
EgtSetInfo( nGeoLayerId, WIN_GEOWIDTH, dGlassThickness)
|
|
return nGeoLayerId
|
|
end
|
|
|
|
-- funzione che recupera tipo di inizio e fine pezzo
|
|
function WinCalculate.CalcStartEndProfileType(nProfileType, nOutlineId, nStartProfileId, nEndProfileId)
|
|
local StartJointType
|
|
local EndJointType
|
|
local nOutlineLayerId = EgtGetParent( nOutlineId)
|
|
local sStartProfileType
|
|
local sEndProfileType
|
|
StartJointType = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'i')
|
|
if StartJointType == WIN_PART_JNT.ANGLED then
|
|
sStartProfileType = WIN_MINIZINKEN
|
|
elseif StartJointType == WIN_PART_JNT.SHORT then
|
|
sStartProfileType = WIN_CTRINOFST
|
|
elseif StartJointType == WIN_PART_JNT.FULL then
|
|
sStartProfileType = WIN_OUTOFST
|
|
end
|
|
EndJointType = EgtGetInfo( nOutlineId, WIN_ENDJOINT, 'i')
|
|
if EndJointType == WIN_PART_JNT.ANGLED then
|
|
sEndProfileType = WIN_MINIZINKEN
|
|
elseif EndJointType == WIN_PART_JNT.SHORT then
|
|
sEndProfileType = WIN_CTRINOFST
|
|
elseif EndJointType == WIN_PART_JNT.FULL then
|
|
sEndProfileType = WIN_OUTOFST
|
|
end
|
|
-- if nProfileType == WIN_PRF.BOTTOM then
|
|
-- if StartJointType == WIN_JNT.FULL_H then
|
|
-- sStartProfileType = WIN_OUTOFST
|
|
-- elseif StartJointType == WIN_JNT.FULL_V then
|
|
-- sStartProfileType = WIN_CTRINOFST
|
|
-- elseif StartJointType == WIN_JNT.ANGLED then
|
|
-- sStartProfileType = WIN_MINIZINKEN
|
|
-- end
|
|
-- if EndJointType == WIN_JNT.FULL_H then
|
|
-- sEndProfileType = WIN_OUTOFST
|
|
-- elseif EndJointType == WIN_JNT.FULL_V then
|
|
-- sEndProfileType = WIN_CTRINOFST
|
|
-- elseif EndJointType == WIN_JNT.ANGLED then
|
|
-- sEndProfileType = WIN_MINIZINKEN
|
|
-- end
|
|
-- elseif nProfileType == WIN_PRF.RIGHT then
|
|
-- if StartJointType == WIN_JNT.FULL_H then
|
|
-- sStartProfileType = WIN_CTRINOFST
|
|
-- elseif StartJointType == WIN_JNT.FULL_V then
|
|
-- sStartProfileType = WIN_OUTOFST
|
|
-- elseif StartJointType == WIN_JNT.ANGLED then
|
|
-- sStartProfileType = WIN_MINIZINKEN
|
|
-- end
|
|
-- if EndJointType == WIN_JNT.FULL_H then
|
|
-- sEndProfileType = WIN_CTRINOFST
|
|
-- elseif EndJointType == WIN_JNT.FULL_V then
|
|
-- sEndProfileType = WIN_OUTOFST
|
|
-- elseif EndJointType == WIN_JNT.ANGLED then
|
|
-- sEndProfileType = WIN_MINIZINKEN
|
|
-- end
|
|
-- elseif nProfileType == WIN_PRF.TOP then
|
|
-- if StartJointType == WIN_JNT.FULL_H then
|
|
-- sStartProfileType = WIN_OUTOFST
|
|
-- elseif StartJointType == WIN_JNT.FULL_V then
|
|
-- sStartProfileType = WIN_CTRINOFST
|
|
-- elseif StartJointType == WIN_JNT.ANGLED then
|
|
-- sStartProfileType = WIN_MINIZINKEN
|
|
-- end
|
|
-- if EndJointType == WIN_JNT.FULL_H then
|
|
-- sEndProfileType = WIN_OUTOFST
|
|
-- elseif EndJointType == WIN_JNT.FULL_V then
|
|
-- sEndProfileType = WIN_CTRINOFST
|
|
-- elseif EndJointType == WIN_JNT.ANGLED then
|
|
-- sEndProfileType = WIN_MINIZINKEN
|
|
-- end
|
|
-- elseif nProfileType == WIN_PRF.LEFT then
|
|
-- if StartJointType == WIN_JNT.FULL_H then
|
|
-- sStartProfileType = WIN_CTRINOFST
|
|
-- elseif StartJointType == WIN_JNT.FULL_V then
|
|
-- sStartProfileType = WIN_OUTOFST
|
|
-- elseif StartJointType == WIN_JNT.ANGLED then
|
|
-- sStartProfileType = WIN_MINIZINKEN
|
|
-- end
|
|
-- if EndJointType == WIN_JNT.FULL_H then
|
|
-- sEndProfileType = WIN_CTRINOFST
|
|
-- elseif EndJointType == WIN_JNT.FULL_V then
|
|
-- sEndProfileType = WIN_OUTOFST
|
|
-- elseif EndJointType == WIN_JNT.ANGLED then
|
|
-- sEndProfileType = WIN_MINIZINKEN
|
|
-- end
|
|
-- elseif nProfileType == WIN_PRF.VERTICAL then
|
|
if nProfileType == WIN_PRF.VERTICAL then
|
|
sStartProfileType = WIN_CTRINOFST
|
|
sEndProfileType = WIN_CTRINOFST
|
|
elseif nProfileType == WIN_PRF.HORIZONTAL then
|
|
sStartProfileType = WIN_CTRINOFST
|
|
sEndProfileType = WIN_CTRINOFST
|
|
elseif nProfileType == WIN_PRF.SPLIT then
|
|
local nStartId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
local nEndId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
local sStartName = EgtGetName( nStartId)
|
|
local sEndName = EgtGetName( nEndId)
|
|
sStartProfileType = WinCalculate.GetProfileCtrIn( nProfileType, nStartId, nOutlineId, nStartProfileId)
|
|
sEndProfileType = WinCalculate.GetProfileCtrIn( nProfileType, nEndId, nOutlineId, nEndProfileId)
|
|
sStartProfileType = WIN_OFST .. sStartProfileType
|
|
sEndProfileType = WIN_OFST .. sEndProfileType
|
|
elseif nProfileType == WIN_PRF.BOTTOMRAIL then
|
|
StartJointType = WIN_JNT.FULL_V
|
|
EndJointType = WIN_JNT.FULL_V
|
|
sStartProfileType = WIN_CTRINOFST
|
|
sEndProfileType = WIN_CTRINOFST
|
|
end
|
|
return sStartProfileType, sEndProfileType, StartJointType, EndJointType
|
|
end
|
|
|
|
-- funzione che posiziona i profili, li estrude e crea il solido
|
|
function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, nStartProfileId, nEndProfileId, nProfileType, nSolidLayerId, nAreaType)
|
|
-- recupero outline
|
|
local nPartId = EgtGetParent( nSolidLayerId)
|
|
local nAreaId = EgtGetInfo( nPartId, WIN_AREAASTERISK)
|
|
local nGeoLayerId = EgtGetParent( nGeoId)
|
|
local nOutlineLayerId = EgtGetParent( nOutlineId)
|
|
-- recupero geo
|
|
local nPrevGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
|
|
local nNextGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
|
|
-- recupero BBox e larghezza del geo
|
|
local dGeoWidth = EgtGetInfo( nGeoId, WIN_GEOWIDTH, 'd')
|
|
-- creo guida Main
|
|
local nGuideId = EgtCopy( nOutlineId, nSolidLayerId)
|
|
EgtSetName( nGuideId, WIN_MAINGUIDE)
|
|
EgtExtendCurveStartByLen( nGuideId, 2 * dGeoWidth)
|
|
EgtExtendCurveEndByLen( nGuideId, 2 * dGeoWidth)
|
|
-- recupero frame del profilo
|
|
local nMainProfileFrameId = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTIONFRAME)
|
|
local frInvertMainProfile = EgtFR( nMainProfileFrameId)
|
|
frInvertMainProfile:invert()
|
|
-- lo applico a tutte le geometrie del profilo
|
|
EgtTransform( EgtGetAllInGroup( nMainProfileId), frInvertMainProfile)
|
|
-- assegno come riferimento del profilo il punto start dell'outline
|
|
EgtChangeGroupFrame( nMainProfileId, Frame3d( EgtSP( nGuideId), - EgtSV( nGuideId)))
|
|
-- recupero outline del profilo Main e lo estrudo
|
|
local nMainOutlineId = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTION)
|
|
local nMainExtrusionId = EgtSurfTmSwept( nSolidLayerId, nMainOutlineId, nGuideId, false, WIN_SURF_APPROX)
|
|
-- posiziono il profilo Start
|
|
local nRefStartProfileId = EgtGetFirstNameInGroup( nStartProfileId, WIN_REF)
|
|
local b3RefStartProfile = EgtGetBBoxGlob(nRefStartProfileId, GDB_BB.STANDARD)
|
|
local dStartDelta = EgtGetInfo( nGeoLayerId, WIN_STARTCPDELTA, 'd') or 0
|
|
-- creo guida per estrusione
|
|
local nStartGuideId = EgtCopy( nPrevGeoId, nSolidLayerId)
|
|
EgtSetName( nStartGuideId, WIN_STARTGUIDE)
|
|
EgtExtendCurveStartByLen( nStartGuideId, 2 * dGeoWidth)
|
|
EgtExtendCurveEndByLen( nStartGuideId, 2 * dGeoWidth)
|
|
-- recupero frame del profilo
|
|
local nStartProfileFrameId = EgtGetFirstNameInGroup( nStartProfileId, WIN_SECTIONFRAME)
|
|
local frStartProfile = EgtFR( nStartProfileFrameId)
|
|
-- lo sposto se controprofilo
|
|
frStartProfile:move( - frStartProfile:getVersX() * dStartDelta)
|
|
frStartProfile:invert()
|
|
-- lo applico a tutte le geometrie del profilo
|
|
EgtTransform( EgtGetAllInGroup( nStartProfileId), frStartProfile)
|
|
-- assegno come riferimento del profilo il punto start dell'outline
|
|
EgtChangeGroupFrame( nStartProfileId, Frame3d( EgtSP( nStartGuideId), - EgtSV( nStartGuideId)))
|
|
-- in base al tipo di incastro e di pezzo, ricavo i controprofili
|
|
local sStartProfileType
|
|
local sEndProfileType
|
|
-- recupero tipo di giunzioni
|
|
sStartProfileType, sEndProfileType, StartJointType, EndJointType = WinCalculate.CalcStartEndProfileType( nProfileType, nOutlineId, nStartProfileId, nEndProfileId)
|
|
-- se Start e' split
|
|
local nStartId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
local nStartProfileType
|
|
if nStartId then
|
|
local nStartAreaId = EgtGetParent( EgtGetParent( nStartId))
|
|
if nStartAreaId then
|
|
nStartProfileType = EgtGetInfo( nStartAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
end
|
|
if nProfileType == WIN_PRF.SPLIT and nStartProfileType and nStartProfileType == WIN_AREATYPES.SPLIT then
|
|
local nStartSouId = nStartId
|
|
local nStartSouLayerId
|
|
local sStartSouLayer
|
|
repeat
|
|
nStartSouId = EgtGetInfo( nStartSouId, WIN_SOU)
|
|
nStartSouLayerId = EgtGetParent( nStartSouId)
|
|
if nStartSouLayerId then
|
|
sStartSouLayer = EgtGetName( nStartSouLayerId)
|
|
end
|
|
until not nStartSouId or not nStartSouLayerId or sStartSouLayer == WIN_BASESPLIT
|
|
if nStartSouId and nStartSouLayerId and sStartSouLayer == WIN_BASESPLIT then
|
|
-- recupero vettore tangente nel punto medio della curva di contorno
|
|
local ptMidStart = EgtMP( nStartId)
|
|
local vtMidStart = EgtMV( nStartId)
|
|
-- recupero vettore tangente nello stesso punto della curva split originale
|
|
local dMidStartOnStartSou = EgtCurveParamAtPoint( nStartSouId, ptMidStart)
|
|
local vtMidStartSou = EgtUV( nStartSouId, dMidStartOnStartSou, -1)
|
|
-- se i due vettori non sono orientati nella stessa direzione
|
|
if not AreSameVectorExact( vtMidStart, vtMidStartSou) then
|
|
-- ruoto di 180 gradi il profilo
|
|
local frStartProfileS = EgtFR( nStartProfileFrameId, GDB_ID.ROOT)
|
|
EgtRotate( nStartProfileId, frStartProfileS:getOrigin(), frStartProfileS:getVersY(), 180, GDB_RT.GLOB)
|
|
local nStartCntProfileId = EgtGetFirstNameInGroup( nStartProfileId, sStartProfileType)
|
|
EgtInvertCurve( nStartCntProfileId)
|
|
end
|
|
end
|
|
end
|
|
-- recupero outline del profilo Start e lo estrudo
|
|
local nOutStartProfileId
|
|
if sStartProfileType == WIN_MINIZINKEN then
|
|
nOutStartProfileId = EgtLine( nStartProfileId, EgtSP( nPrevGeoId), EgtSP( nPrevGeoId) - Z_AX() * b3RefStartProfile:getDimY(), GDB_RT.GLOB)
|
|
EgtInvertCurve( nOutStartProfileId)
|
|
else
|
|
nOutStartProfileId = EgtGetFirstNameInGroup( nStartProfileId, sStartProfileType)
|
|
end
|
|
local nStartExtrusionId = EgtSurfTmSwept( nSolidLayerId, nOutStartProfileId, nStartGuideId, false, WIN_SURF_APPROX)
|
|
-- taglio estrusi per ottenere solido
|
|
local nExtrCopyId = EgtCopy( nMainExtrusionId, nSolidLayerId)
|
|
EgtSurfTmCut( nMainExtrusionId, nStartExtrusionId, true, false)
|
|
EgtSurfTmCut( nStartExtrusionId, nExtrCopyId, true, false)
|
|
-- creo fori per spine su Start
|
|
local nDowelLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nDowelLayerId, 'Dowel')
|
|
local nPrevOutlineId = EgtGetPrev( nOutlineId)
|
|
if not nPrevOutlineId then
|
|
nPrevOutlineId = EgtGetLastInGroup( nOutlineLayerId)
|
|
end
|
|
local sOutlineName = EgtGetName( nOutlineId)
|
|
local sPrevOutlineName = EgtGetName( nPrevOutlineId)
|
|
if StartJointType == WIN_PART_JNT.ANGLED then
|
|
|
|
elseif StartJointType == WIN_PART_JNT.FULL then
|
|
-- recupero profondita' d'inizio e fine
|
|
local sStart = EgtIf( sOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPERPSTART, WIN_DWL_TOPPERPSTART)
|
|
local sEnd = EgtIf( sOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPERPEND, WIN_DWL_TOPPERPEND)
|
|
-- ciclo sui fori trovati
|
|
local nOrigDowelId = EgtGetFirstNameInGroup( nStartProfileId, WIN_DOWEL .. '*')
|
|
while nOrigDowelId do
|
|
local dStart = EgtGetInfo( nOrigDowelId, sStart, 'd')
|
|
if not dStart then
|
|
dStart = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPSTART, 'd')
|
|
end
|
|
local dEnd = EgtGetInfo( nOrigDowelId, sEnd, 'd')
|
|
if not dEnd then
|
|
dEnd = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPEND, 'd')
|
|
end
|
|
local nDowelId = EgtCopyGlob( nOrigDowelId, nDowelLayerId)
|
|
EgtSetColor( nDowelId, Color3d( 128, 128, 128))
|
|
local nInGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN)
|
|
local ptDowelCenter = EgtCP( nDowelId)
|
|
local vtPerpStartPoint = EgtSV( nOutlineId)
|
|
vtPerpStartPoint:rotate( Z_AX(), 90)
|
|
-- posiziono i fori e gli assegno estrusione e spessore
|
|
EgtMove( nDowelId, ( EgtSP( nInGeoId) - ptDowelCenter) * vtPerpStartPoint * vtPerpStartPoint - vtPerpStartPoint * dStart)
|
|
-- EgtMove( nDowelId, Point3d( ptDowelCenter:getX(), EgtSP( nInGeoId):getY(), ptDowelCenter:getZ()) - ptDowelCenter - vtPerpStartPoint * dStart)
|
|
EgtModifyCurveExtrusion( nDowelId, - vtPerpStartPoint)
|
|
EgtModifyCurveThickness( nDowelId, dEnd - dStart)
|
|
-- creo solido di estrusione
|
|
local nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nDowelId, - vtPerpStartPoint * ( dEnd - dStart + 1))
|
|
EgtMove( nDowelExtrusionId, vtPerpStartPoint)
|
|
EgtInvertSurf( nDowelExtrusionId)
|
|
-- taglio estrusi per ottenere solido
|
|
EgtSurfTmCut( nMainExtrusionId, nDowelExtrusionId, true, false)
|
|
EgtSurfTmCut( nDowelExtrusionId, nExtrCopyId, true, false)
|
|
nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*')
|
|
end
|
|
elseif StartJointType == WIN_PART_JNT.SHORT then
|
|
-- recupero profondita' d'inizio e fine
|
|
local sStart = EgtIf( sOutlineName == WIN_BOTTOM or sPrevOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPARASTART, WIN_DWL_TOPPARASTART)
|
|
local sEnd = EgtIf( sOutlineName == WIN_BOTTOM or sPrevOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPARAEND, WIN_DWL_TOPPARAEND)
|
|
-- ciclo sui fori trovati
|
|
local nOrigDowelId = EgtGetFirstNameInGroup( nMainProfileId, WIN_DOWEL .. '*')
|
|
while nOrigDowelId do
|
|
local dStart = EgtGetInfo( nOrigDowelId, sStart, 'd')
|
|
if not dStart then
|
|
dStart = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPARASTART, 'd')
|
|
end
|
|
local dEnd = EgtGetInfo( nOrigDowelId, sEnd, 'd')
|
|
if not dEnd then
|
|
dEnd = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPARAEND, 'd')
|
|
end
|
|
local nDowelId = EgtCopyGlob( nOrigDowelId, nDowelLayerId)
|
|
EgtSetColor( nDowelId, Color3d( 128, 128, 128))
|
|
local nLeftGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
|
|
local ptDowelCenter = EgtCP( nDowelId)
|
|
local vtParaStartPoint = EgtSV( nOutlineId)
|
|
-- posiziono i fori e gli assegno estrusione e spessore
|
|
EgtMove( nDowelId, ( EgtSP( nLeftGeoId) - ptDowelCenter) * vtParaStartPoint * vtParaStartPoint + vtParaStartPoint * dStart)
|
|
-- EgtMove( nDowelId, Point3d( ptDowelCenter:getX(), EgtSP( nLeftGeoId):getY(), ptDowelCenter:getZ()) - ptDowelCenter + vtParaStartPoint * dStart)
|
|
EgtModifyCurveExtrusion( nDowelId, vtParaStartPoint)
|
|
EgtModifyCurveThickness( nDowelId, dEnd - dStart)
|
|
-- creo solido di estrusione
|
|
local nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nDowelId, vtParaStartPoint * ( dEnd - dStart + 1))
|
|
EgtMove( nDowelExtrusionId, - vtParaStartPoint)
|
|
EgtInvertSurf( nDowelExtrusionId)
|
|
-- taglio estrusi per ottenere solido
|
|
local nDowelExtrCopyId = EgtCopy( nDowelExtrusionId, nSolidLayerId)
|
|
EgtSurfTmCut( nDowelExtrusionId, nStartExtrusionId, true, false)
|
|
EgtSurfTmCut( nStartExtrusionId, nDowelExtrCopyId, true, false)
|
|
EgtErase( nDowelExtrCopyId)
|
|
nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*')
|
|
end
|
|
end
|
|
-- posiziono il profilo End
|
|
local nRefEndProfileId = EgtGetFirstNameInGroup( nEndProfileId, WIN_REF)
|
|
local b3RefEndProfile = EgtGetBBoxGlob(nRefEndProfileId, GDB_BB.STANDARD)
|
|
local dEndDelta = EgtGetInfo( nGeoLayerId, WIN_ENDCPDELTA, 'd') or 0
|
|
-- creo guida per estrusione
|
|
local nEndGuideId = EgtCopy( nNextGeoId, nSolidLayerId)
|
|
EgtSetName( nEndGuideId, WIN_ENDGUIDE)
|
|
EgtExtendCurveStartByLen( nEndGuideId, 2 * dGeoWidth)
|
|
EgtExtendCurveEndByLen( nEndGuideId, 2 * dGeoWidth)
|
|
-- recupero frame del profilo
|
|
local nEndProfileFrameId = EgtGetFirstNameInGroup( nEndProfileId, WIN_SECTIONFRAME)
|
|
local frEndProfile = EgtFR( nEndProfileFrameId)
|
|
frEndProfile:move( - frEndProfile:getVersX() * dEndDelta)
|
|
frEndProfile:invert()
|
|
-- lo applico a tutte le geometrie del profilo
|
|
EgtTransform( EgtGetAllInGroup( nEndProfileId), frEndProfile)
|
|
-- assegno come riferimento del profilo il punto start dell'outline
|
|
EgtChangeGroupFrame( nEndProfileId, Frame3d( EgtSP( nEndGuideId), - EgtSV( nEndGuideId)))
|
|
-- se End e' split, ruoto di 180 gradi il profilo
|
|
local nEndId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
local nEndProfileType
|
|
if nEndId then
|
|
local nEndAreaId = EgtGetParent( EgtGetParent( nEndId))
|
|
if nEndAreaId then
|
|
nEndProfileType = EgtGetInfo( nEndAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
end
|
|
if nProfileType == WIN_PRF.SPLIT and nEndProfileType and nEndProfileType == WIN_AREATYPES.SPLIT then
|
|
local nEndSouId = nEndId
|
|
local nEndSouLayerId
|
|
local sEndSouLayer
|
|
repeat
|
|
nEndSouId = EgtGetInfo( nEndSouId, WIN_SOU)
|
|
nEndSouLayerId = EgtGetParent( nEndSouId)
|
|
if nEndSouLayerId then
|
|
sEndSouLayer = EgtGetName( nEndSouLayerId)
|
|
end
|
|
until not nEndSouId or not nEndSouLayerId or sEndSouLayer == WIN_BASESPLIT
|
|
if nEndSouId and nEndSouLayerId and sEndSouLayer == WIN_BASESPLIT then
|
|
-- recupero vettore tangente nel punto medio della curva di contorno
|
|
local ptMidEnd = EgtMP( nEndId)
|
|
local vtMidEnd = EgtMV( nEndId)
|
|
-- recupero vettore tangente nello stesso punto della curva split originale
|
|
local dMidStartOnEndSou = EgtCurveParamAtPoint( nEndSouId, ptMidEnd)
|
|
local vtMidEndSou = EgtUV( nEndSouId, dMidStartOnEndSou, -1)
|
|
-- se i due vettori non sono orientati nella stessa direzione
|
|
if not AreSameVectorExact( vtMidEnd, vtMidEndSou) then
|
|
-- ruoto di 180 gradi il profilo
|
|
local frEndProfileS = EgtFR( nEndProfileFrameId, GDB_ID.ROOT)
|
|
EgtRotate( nEndProfileId, frEndProfileS:getOrigin(), frEndProfileS:getVersY(), 180, GDB_RT.GLOB)
|
|
local nEndCntProfileId = EgtGetFirstNameInGroup( nEndProfileId, sEndProfileType)
|
|
EgtInvertCurve( nEndCntProfileId)
|
|
end
|
|
end
|
|
end
|
|
-- recupero outline del profilo End e lo estrudo
|
|
local nOutEndProfileId
|
|
if sEndProfileType == WIN_MINIZINKEN then
|
|
nOutEndProfileId = EgtLine( nEndProfileId, EgtSP( nNextGeoId), EgtSP( nNextGeoId) - Z_AX() * b3RefEndProfile:getDimY(), GDB_RT.GLOB)
|
|
EgtInvertCurve( nOutEndProfileId)
|
|
else
|
|
nOutEndProfileId = EgtGetFirstNameInGroup( nEndProfileId, sEndProfileType)
|
|
end
|
|
local nEndExtrusionId = EgtSurfTmSwept( nSolidLayerId, nOutEndProfileId, nEndGuideId, false, WIN_SURF_APPROX)
|
|
-- taglio estrusi per ottenere solido
|
|
EgtSurfTmCut( nMainExtrusionId, nEndExtrusionId, true, false)
|
|
EgtSurfTmCut( nEndExtrusionId, nExtrCopyId, true, false)
|
|
-- creo fori per spine su End
|
|
local nEndOutlineId = EgtGetNext( nOutlineId)
|
|
if not nEndOutlineId then
|
|
nEndOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
end
|
|
local sOutlineName = EgtGetName( nOutlineId)
|
|
local sEndOutlineName = EgtGetName( nEndOutlineId)
|
|
if StartJointType == WIN_PART_JNT.ANGLED then
|
|
|
|
elseif StartJointType == WIN_PART_JNT.FULL then
|
|
-- recupero profondita' d'inizio e fine
|
|
local sStart = EgtIf( sOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPERPSTART, WIN_DWL_TOPPERPSTART)
|
|
local sEnd = EgtIf( sOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPERPEND, WIN_DWL_TOPPERPEND)
|
|
-- ciclo sui fori trovati
|
|
local nOrigDowelId = EgtGetFirstNameInGroup( nEndProfileId, WIN_DOWEL .. '*')
|
|
while nOrigDowelId do
|
|
local dStart = EgtGetInfo( nOrigDowelId, sStart, 'd')
|
|
if not dStart then
|
|
dStart = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPSTART, 'd')
|
|
end
|
|
local dEnd = EgtGetInfo( nOrigDowelId, sEnd, 'd')
|
|
if not dEnd then
|
|
dEnd = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPERPEND, 'd')
|
|
end
|
|
local nDowelId = EgtCopyGlob( nOrigDowelId, nDowelLayerId)
|
|
EgtSetColor( nDowelId, Color3d( 128, 128, 128))
|
|
local nInGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_IN)
|
|
local ptDowelCenter = EgtCP( nDowelId)
|
|
local vtPerpEndPoint = EgtEV( nOutlineId)
|
|
vtPerpEndPoint:rotate( Z_AX(), 90)
|
|
-- posiziono i fori e gli assegno estrusione e spessore
|
|
EgtMove( nDowelId, ( EgtSP( nInGeoId) - ptDowelCenter) * vtPerpEndPoint * vtPerpEndPoint - vtPerpEndPoint * dStart)
|
|
EgtModifyCurveExtrusion( nDowelId, - vtPerpEndPoint)
|
|
EgtModifyCurveThickness( nDowelId, dEnd - dStart)
|
|
-- creo solido di estrusione
|
|
local nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nDowelId, - vtPerpEndPoint * ( dEnd - dStart + 1))
|
|
EgtMove( nDowelExtrusionId, vtPerpEndPoint)
|
|
EgtInvertSurf( nDowelExtrusionId)
|
|
-- taglio estrusi per ottenere solido
|
|
EgtSurfTmCut( nMainExtrusionId, nDowelExtrusionId, true, false)
|
|
EgtSurfTmCut( nDowelExtrusionId, nExtrCopyId, true, false)
|
|
nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*')
|
|
end
|
|
elseif StartJointType == WIN_PART_JNT.SHORT then
|
|
-- recupero profondita' d'inizio e fine
|
|
local sStart = EgtIf( sOutlineName == WIN_BOTTOM or sPrevOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPARASTART, WIN_DWL_TOPPARASTART)
|
|
local sEnd = EgtIf( sOutlineName == WIN_BOTTOM or sPrevOutlineName == WIN_BOTTOM, WIN_DWL_BOTTOMPARAEND, WIN_DWL_TOPPARAEND)
|
|
-- ciclo sui fori trovati
|
|
local nOrigDowelId = EgtGetFirstNameInGroup( nMainProfileId, WIN_DOWEL .. '*')
|
|
while nOrigDowelId do
|
|
local dStart = EgtGetInfo( nOrigDowelId, sStart, 'd')
|
|
if not dStart then
|
|
dStart = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPARASTART, 'd')
|
|
end
|
|
local dEnd = EgtGetInfo( nOrigDowelId, sEnd, 'd')
|
|
if not dEnd then
|
|
dEnd = EgtGetInfo( nOrigDowelId, WIN_DWL_TOPPARAEND, 'd')
|
|
end
|
|
local nDowelId = EgtCopyGlob( nOrigDowelId, nDowelLayerId)
|
|
EgtSetColor( nDowelId, Color3d( 128, 128, 128))
|
|
local nRightGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
|
|
local ptDowelCenter = EgtCP( nDowelId)
|
|
local vtParaEndPoint = EgtEV( nOutlineId)
|
|
-- posiziono i fori e gli assegno estrusione e spessore
|
|
EgtMove( nDowelId, ( EgtSP( nRightGeoId) - ptDowelCenter) * vtParaEndPoint * vtParaEndPoint - vtParaEndPoint * dStart)
|
|
EgtModifyCurveExtrusion( nDowelId, - vtParaEndPoint)
|
|
EgtModifyCurveThickness( nDowelId, dEnd - dStart)
|
|
-- creo solido di estrusione
|
|
local nDowelExtrusionId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nDowelId, - vtParaEndPoint * ( dEnd - dStart + 1))
|
|
EgtMove( nDowelExtrusionId, vtParaEndPoint)
|
|
EgtInvertSurf( nDowelExtrusionId)
|
|
-- taglio estrusi per ottenere solido
|
|
local nDowelExtrCopyId = EgtCopy( nDowelExtrusionId, nSolidLayerId)
|
|
EgtSurfTmCut( nDowelExtrusionId, nEndExtrusionId, true, false)
|
|
EgtSurfTmCut( nEndExtrusionId, nDowelExtrCopyId, true, false)
|
|
EgtErase( nDowelExtrCopyId)
|
|
nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*')
|
|
end
|
|
end
|
|
-- elimino copia dell'estrusione principale
|
|
EgtErase( { nExtrCopyId})
|
|
end
|
|
|
|
-- funzione che restitutisce lo Strip piu' vicino
|
|
function WinCalculate.GetStripNearestToOutline( nStartProfileId, nOutlineId, sStripName)
|
|
-- recupero strip
|
|
local ptStartOutline = EgtMP( nOutlineId)
|
|
local vtStartOutline = EgtSV( nOutlineId)
|
|
local nStartStripId = EgtGetFirstNameInGroup( nStartProfileId, sStripName)
|
|
if not nStartStripId then
|
|
local nStripMinDistId
|
|
local dMinDistance
|
|
local nStripId = EgtGetFirstNameInGroup( nStartProfileId, sStripName .. '*')
|
|
while nStripId do
|
|
local b3Strip = EgtGetBBoxGlob( nStripId, GDB_BB.STANDARD)
|
|
-- calcolo il vettore distanza
|
|
local vtDistance = b3Strip:getCenter() - ptStartOutline
|
|
-- ne ricavo la componente nella stessa direzione dell'outline
|
|
local dDistance = abs( vtDistance * vtStartOutline)
|
|
if not dMinDistance or dDistance < dMinDistance then
|
|
dMinDistance = dDistance
|
|
nStripMinDistId = nStripId
|
|
end
|
|
nStripId = EgtGetNextName( nStripId, sStripName .. '*')
|
|
end
|
|
nStartStripId = nStripMinDistId
|
|
end
|
|
return nStartStripId
|
|
end
|
|
|
|
-- funzione che crea gli Strip
|
|
function WinCalculate.CreateStripFromOutline( nAreaId, nOutlineId)
|
|
local nPartId = EgtGetInfo( nOutlineId, WIN_REF_PART)
|
|
local nAreaType = WIN_AREATYPES.SASH
|
|
local nGeoLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local nGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_OUT)
|
|
local nOutlineLayerId = EgtGetParent( nOutlineId)
|
|
-- recupero layer per solido e per profili di estrusione
|
|
local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID)
|
|
local nMainProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE)
|
|
-- ricavo tipo dal nome
|
|
local sName = EgtGetName( nPartId)
|
|
local nProfileType = WIN_PRF.NULL
|
|
if sName == WIN_TOP then
|
|
nProfileType = WIN_PRF.TOP
|
|
elseif sName == WIN_BOTTOM then
|
|
nProfileType = WIN_PRF.BOTTOM
|
|
-- verifico se BottomRail
|
|
local nBottomRail = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i')
|
|
if nBottomRail and nBottomRail > 1 then
|
|
nProfileType = WIN_PRF.BOTTOMRAIL
|
|
nSolidLayerId = EgtGetFirstNameInGroup( nBottomRail, WIN_SOLID)
|
|
nMainProfileLayerId = EgtGetFirstNameInGroup( nBottomRail, WIN_PROFILE)
|
|
end
|
|
elseif sName == WIN_LEFT then
|
|
nProfileType = WIN_PRF.LEFT
|
|
elseif sName == WIN_RIGHT then
|
|
nProfileType = WIN_PRF.RIGHT
|
|
elseif sName == WIN_VERTICAL then
|
|
nProfileType = WIN_PRF.VERTICAL
|
|
elseif sName == WIN_HORIZONTAL then
|
|
nProfileType = WIN_PRF.HORIZONTAL
|
|
elseif sName == WIN_SPLIT then
|
|
nProfileType = WIN_PRF.SPLIT
|
|
end
|
|
local nMainProfileId = GDB_ID.NULL
|
|
local nStartProfileId = GDB_ID.NULL
|
|
local nEndProfileId = GDB_ID.NULL
|
|
local nPrevOutlineId = EgtGetPrev( nOutlineId)
|
|
if not nPrevOutlineId then
|
|
nPrevOutlineId = EgtGetLastInGroup( nOutlineLayerId)
|
|
end
|
|
local nNextOutlineId = EgtGetNext( nOutlineId)
|
|
if not nNextOutlineId then
|
|
nNextOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
end
|
|
local nPrevPartId = EgtGetInfo( nPrevOutlineId, WIN_REF_PART)
|
|
local nPrevProfileLayerId = EgtGetFirstNameInGroup( nPrevPartId, WIN_PROFILE)
|
|
local nNextPartId = EgtGetInfo( nNextOutlineId, WIN_REF_PART)
|
|
local nNextProfileLayerId = EgtGetFirstNameInGroup( nNextPartId, WIN_PROFILE)
|
|
-- verifico se Prev o Next sono BottomRail
|
|
local nPrevBottomRail = EgtGetInfo( nPrevOutlineId, WIN_BOTTOMRAIL, 'i')
|
|
if nPrevBottomRail and nPrevBottomRail > 1 then
|
|
nPrevPartId = nPrevBottomRail
|
|
nPrevProfileLayerId = EgtGetFirstNameInGroup( nPrevBottomRail, WIN_PROFILE)
|
|
end
|
|
local nNextBottomRail = EgtGetInfo( nNextOutlineId, WIN_BOTTOMRAIL, 'i')
|
|
if nNextBottomRail and nNextBottomRail > 1 then
|
|
nNextPartId = nNextBottomRail
|
|
nNextProfileLayerId = EgtGetFirstNameInGroup( nNextBottomRail, WIN_PROFILE)
|
|
end
|
|
-- recupero profilo e controprofili
|
|
nMainProfileId = EgtGetFirstNameInGroup( nMainProfileLayerId, WIN_PRF_MAIN)
|
|
nStartProfileId = EgtGetFirstNameInGroup( nPrevProfileLayerId, WIN_PRF_MAIN)
|
|
nEndProfileId = EgtGetFirstNameInGroup( nNextProfileLayerId, WIN_PRF_MAIN)
|
|
-- recupero outline
|
|
local nOutlineLayerId = EgtGetParent( nOutlineId)
|
|
-- recupero geo
|
|
local nPrevGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_LEFT)
|
|
local nNextGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT)
|
|
-- recupero BBox e larghezza del geo
|
|
local dGeoWidth = EgtGetInfo( nGeoId, WIN_GEOWIDTH, 'd')
|
|
-- creo guida Main
|
|
local nGuideId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_MAINGUIDE)
|
|
-- recupero frame del profilo
|
|
local nMainProfileFrameId = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTIONFRAME)
|
|
-- se anta, estrudo anche il fermavetro
|
|
local nMainStripId
|
|
local nMainStripExtrusionId
|
|
local bStrip = false
|
|
if nAreaType == WIN_AREATYPES.SASH then
|
|
nMainStripId = WinCalculate.GetStripNearestToOutline( nMainProfileId, nPrevOutlineId, WIN_STRIP)
|
|
-- local nStripOutlineId = EgtGetFirstNameInGroup( nMainProfileId, WIN_STRIP)
|
|
if nMainStripId then
|
|
bStrip = true
|
|
-- recupero strip piu' vicino a prev outline
|
|
nMainStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nMainStripId, nGuideId, false, WIN_SURF_APPROX)
|
|
end
|
|
end
|
|
-- recupero frame del profilo start
|
|
local nStartProfileFrameId = EgtGetFirstNameInGroup( nStartProfileId, WIN_SECTIONFRAME)
|
|
local frStartProfile = EgtFR( nStartProfileFrameId, GDB_ID.ROOT)
|
|
-- posiziono il profilo Start
|
|
local nRefStartProfileId = EgtGetFirstNameInGroup( nStartProfileId, WIN_REF)
|
|
local b3RefStartProfile = EgtGetBBoxRef(nRefStartProfileId, GDB_BB.STANDARD, frStartProfile)
|
|
-- se anta, creo guida per il fermavetro
|
|
local nStartStripGuideId
|
|
local ptStripMinStart
|
|
local nMainStripMinOffsetId
|
|
local nMainStripMaxOffsetId
|
|
if nAreaType == WIN_AREATYPES.SASH and bStrip then
|
|
-- calcolo offset per Strip del Main
|
|
-- local nMainStripId = EgtGetFirstNameInGroup( nMainProfileId, WIN_STRIP)
|
|
local frMainProfile = EgtFR( nMainProfileFrameId, GDB_ID.ROOT)
|
|
-- se profilo e direzione prev uguali ( Prev e' Split), cambio segno all'offset di modo che rimanga sempre dalla stessa parte
|
|
local vtEndMain = EgtEV( nOutlineId)
|
|
local bMainInvertOffset = AreSameVectorApprox( frMainProfile:getVersZ(), vtEndMain)
|
|
-- calcolo BBox
|
|
local b3MainStrip = EgtGetBBoxRef( nMainStripId, GDB_BB.STANDARD, frMainProfile, GDB_RT.GLOB)
|
|
local dMainStripMinDelta = EgtIf( bMainInvertOffset, b3MainStrip:getMax():getX(), b3MainStrip:getMin():getX())
|
|
nMainStripMinOffsetId = EgtCopy( nOutlineId, nSolidLayerId)
|
|
EgtOffsetCurve( nMainStripMinOffsetId, EgtIf( bMainInvertOffset, -1, 1) * dMainStripMinDelta)
|
|
local dMainStripMaxDelta = EgtIf( bMainInvertOffset, b3MainStrip:getMin():getX(), b3MainStrip:getMax():getX())
|
|
nMainStripMaxOffsetId = EgtCopy( nOutlineId, nSolidLayerId)
|
|
EgtOffsetCurve( nMainStripMaxOffsetId, EgtIf( bMainInvertOffset, -1, 1) * dMainStripMaxDelta)
|
|
-- recupero strip piu' vicino ad outline
|
|
local nStartStripId = WinCalculate.GetStripNearestToOutline( nStartProfileId, nOutlineId, WIN_STRIP)
|
|
-- se profilo e direzione prev uguali ( Prev e' Split), cambio segno all'offset di modo che rimanga sempre dalla stessa parte
|
|
local vtEndPrev = EgtEV( nPrevOutlineId)
|
|
local bStartInvertOffset = AreSameVectorApprox( frStartProfile:getVersZ(), vtEndPrev)
|
|
-- calcolo BBox
|
|
local b3StartStrip = EgtGetBBoxRef( nStartStripId, GDB_BB.STANDARD, frStartProfile)
|
|
local dStarStripMinDelta = EgtIf( bStartInvertOffset, b3StartStrip:getMax():getX(), b3StartStrip:getMin():getX())
|
|
local nStartStripMinOffsetId = EgtCopy( nPrevOutlineId, nSolidLayerId)
|
|
-- creo offset Min e Max
|
|
EgtOffsetCurve( nStartStripMinOffsetId, EgtIf( bStartInvertOffset, -1, 1) * dStarStripMinDelta)
|
|
local dStarStripMaxDelta = EgtIf( bStartInvertOffset, b3StartStrip:getMin():getX(), b3StartStrip:getMax():getX())
|
|
local nStartStripMaxOffsetId = EgtCopy( nPrevOutlineId, nSolidLayerId)
|
|
EgtOffsetCurve( nStartStripMaxOffsetId, EgtIf( bStartInvertOffset, -1, 1) * dStarStripMaxDelta)
|
|
-- trovo intersezioni e disegno guida start per lo strip
|
|
ptStripMinStart = EgtIP( nMainStripMinOffsetId, nStartStripMinOffsetId, EgtSP( nMainStripMinOffsetId))
|
|
local ptStripMaxStart = EgtIP( nMainStripMaxOffsetId, nStartStripMaxOffsetId, EgtSP( nMainStripMaxOffsetId))
|
|
nStartStripGuideId = EgtLine( nSolidLayerId, ptStripMinStart, ptStripMaxStart)
|
|
EgtExtendCurveStartByLen( nStartStripGuideId, 10)
|
|
EgtExtendCurveEndByLen( nStartStripGuideId, 10)
|
|
end
|
|
-- se anta, estrudo Strip start e lo taglio con main
|
|
local nStartStripExtrusionId
|
|
local nStripExtrCopyId
|
|
if nAreaType == WIN_AREATYPES.SASH and bStrip then
|
|
local nStartStripProfileId = EgtLine( nStartProfileId, ptStripMinStart, ptStripMinStart - Z_AX() * b3RefStartProfile:getDimY(), GDB_RT.GLOB)
|
|
EgtInvertCurve( nStartStripProfileId)
|
|
nStartStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nStartStripProfileId, nStartStripGuideId, false, WIN_SURF_APPROX)
|
|
nStripExtrCopyId = EgtCopy( nMainStripExtrusionId, nSolidLayerId)
|
|
EgtSurfTmCut( nMainStripExtrusionId, nStartStripExtrusionId, true, false)
|
|
EgtSurfTmCut( nStartStripExtrusionId, nStripExtrCopyId, true, false)
|
|
end
|
|
-- recupero frame del profilo
|
|
local nEndProfileFrameId = EgtGetFirstNameInGroup( nEndProfileId, WIN_SECTIONFRAME)
|
|
local frEndProfile = EgtFR( nEndProfileFrameId, GDB_ID.ROOT)
|
|
-- -- posiziono il profilo End
|
|
local nRefEndProfileId = EgtGetFirstNameInGroup( nEndProfileId, WIN_REF)
|
|
local b3RefEndProfile = EgtGetBBoxRef(nRefEndProfileId, GDB_BB.STANDARD, frEndProfile)
|
|
-- se anta, creo guida per il fermavetro
|
|
local nEndStripGuideId
|
|
local ptStripMinEnd
|
|
if nAreaType == WIN_AREATYPES.SASH and bStrip then
|
|
-- recupero strip piu' vicino ad outline
|
|
local nEndStripId = WinCalculate.GetStripNearestToOutline( nEndProfileId, nOutlineId, WIN_STRIP)
|
|
-- se profilo e direzione next uguali ( Next e' Split), cambio segno all'offset di modo che rimanga sempre dalla stessa parte
|
|
local vtStartNext = EgtSV( nNextOutlineId)
|
|
local bInvertOffset = AreSameVectorApprox( frEndProfile:getVersZ(), vtStartNext)
|
|
-- recupero minimo e massimo del box dello Strip per avere offset da outline su Next
|
|
local b3EndStrip = EgtGetBBoxRef( nEndStripId, GDB_BB.STANDARD, frEndProfile)
|
|
local dEndStripMinDelta = EgtIf( bInvertOffset, b3EndStrip:getMax():getX(), b3EndStrip:getMin():getX())
|
|
local nEndStripMinOffsetId = EgtCopy( nNextOutlineId, nSolidLayerId)
|
|
EgtOffsetCurve( nEndStripMinOffsetId, EgtIf( bInvertOffset, -1, 1) * dEndStripMinDelta)
|
|
local dEndStripMaxDelta = EgtIf( bInvertOffset, b3EndStrip:getMin():getX(), b3EndStrip:getMax():getX())
|
|
local nEndStripMaxOffsetId = EgtCopy( nNextOutlineId, nSolidLayerId)
|
|
EgtOffsetCurve( nEndStripMaxOffsetId, EgtIf( bInvertOffset, -1, 1) * dEndStripMaxDelta)
|
|
-- calcolo intersezione degli outline minimi e massimi tra Main e Next per trovare guida dello strip
|
|
ptStripMinEnd = EgtIP( nMainStripMinOffsetId, nEndStripMinOffsetId, EgtSP( nMainStripMinOffsetId))
|
|
local ptStripMaxEnd = EgtIP( nMainStripMaxOffsetId, nEndStripMaxOffsetId, EgtSP( nMainStripMaxOffsetId))
|
|
nEndStripGuideId = EgtLine( nSolidLayerId, ptStripMinEnd, ptStripMaxEnd)
|
|
EgtExtendCurveStartByLen( nEndStripGuideId, 10)
|
|
EgtExtendCurveEndByLen( nEndStripGuideId, 10)
|
|
EgtInvertCurve(nEndStripGuideId)
|
|
end
|
|
-- se anta, estrudo Strip end e lo taglio con main
|
|
local nEndStripExtrusionId
|
|
if nAreaType == WIN_AREATYPES.SASH and bStrip then
|
|
local nEndStripProfileId = EgtLine( nEndProfileId, ptStripMinEnd, ptStripMinEnd - Z_AX() * b3RefEndProfile:getDimY(), GDB_RT.GLOB)
|
|
EgtInvertCurve( nEndStripProfileId)
|
|
nEndStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nEndStripProfileId, nEndStripGuideId, false, WIN_SURF_APPROX)
|
|
EgtSurfTmCut( nMainStripExtrusionId, nEndStripExtrusionId, true, false)
|
|
EgtSurfTmCut( nEndStripExtrusionId, nStripExtrCopyId, true, false)
|
|
end
|
|
EgtErase( { nStripExtrCopyId})
|
|
end
|
|
|
|
-- funzione che crea il solido del pezzo del telaio
|
|
function WinCalculate.CalcFrameSolid(nPartId, nOutlineId, nGeoId, nOutlineLayerId, bBottomRail)
|
|
local nAreaId = nOutlineLayerId
|
|
local nAreaType
|
|
-- ciclo fino a trovare un child che non sia uno split
|
|
repeat
|
|
nAreaId = EgtGetParent( nAreaId)
|
|
nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i')
|
|
until not nAreaId or ( nAreaType ~= WIN_AREATYPES.SPLIT and nAreaType ~= WIN_AREATYPES.NULL)
|
|
-- recupero profilo
|
|
local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
|
|
local nProfileFrameLayerId
|
|
if nAreaType == WIN_AREATYPES.FRAME then
|
|
nProfileFrameLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_FRAME)
|
|
elseif nAreaType == WIN_AREATYPES.SASH then
|
|
nProfileFrameLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH)
|
|
end
|
|
-- creo layer per solido e per profili di estrusione
|
|
local nSolidLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nSolidLayerId, WIN_SOLID)
|
|
local nFrameProfileLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nFrameProfileLayerId, WIN_PROFILE)
|
|
-- ricavo tipo dal nome
|
|
local sName = EgtGetName( nPartId)
|
|
local nProfileType = WIN_PRF.NULL
|
|
if bBottomRail then
|
|
nProfileType = WIN_PRF.BOTTOMRAIL
|
|
elseif sName == WIN_TOP then
|
|
nProfileType = WIN_PRF.TOP
|
|
elseif sName == WIN_BOTTOM then
|
|
nProfileType = WIN_PRF.BOTTOM
|
|
elseif sName == WIN_LEFT then
|
|
nProfileType = WIN_PRF.LEFT
|
|
elseif sName == WIN_RIGHT then
|
|
nProfileType = WIN_PRF.RIGHT
|
|
elseif sName == WIN_VERTICAL then
|
|
nProfileType = WIN_PRF.VERTICAL
|
|
elseif sName == WIN_HORIZONTAL then
|
|
nProfileType = WIN_PRF.HORIZONTAL
|
|
elseif sName == WIN_SPLIT then
|
|
nProfileType = WIN_PRF.SPLIT
|
|
end
|
|
local nPrevOutlineId
|
|
local nNextOutlineId
|
|
local nOrigMainProfileId = GDB_ID.NULL
|
|
local nMainProfileId = GDB_ID.NULL
|
|
local nOrigStartProfileId = GDB_ID.NULL
|
|
local nStartProfileId = GDB_ID.NULL
|
|
local nOrigEndProfileId = GDB_ID.NULL
|
|
local nEndProfileId = GDB_ID.NULL
|
|
-- recupero outline precedente e successivo
|
|
if nProfileType == WIN_PRF.BOTTOM then
|
|
-- nPrevOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_LEFT)
|
|
-- nNextOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_RIGHT)
|
|
elseif nProfileType == WIN_PRF.RIGHT then
|
|
-- nPrevOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_BOTTOM)
|
|
-- nNextOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_TOP)
|
|
elseif nProfileType == WIN_PRF.TOP then
|
|
-- nPrevOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_RIGHT)
|
|
-- nNextOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_LEFT)
|
|
elseif nProfileType == WIN_PRF.LEFT then
|
|
-- nPrevOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_TOP)
|
|
-- nNextOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_BOTTOM)
|
|
elseif nProfileType == WIN_PRF.VERTICAL then
|
|
-- nPrevOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_BOTTOM)
|
|
-- nNextOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_TOP)
|
|
nPrevOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
nNextOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
elseif nProfileType == WIN_PRF.HORIZONTAL then
|
|
-- nPrevOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_LEFT)
|
|
-- nNextOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_RIGHT)
|
|
nPrevOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
nNextOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
elseif nProfileType == WIN_PRF.SPLIT then
|
|
local nStartId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
local nEndId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
local sStartName = EgtGetName( nStartId)
|
|
local sEndName = EgtGetName( nEndId)
|
|
-- nPrevOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, sStartName)
|
|
-- nNextOutlineId = EgtGetFirstNameInGroup( nOutlineLayerId, sEndName)
|
|
nPrevOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i')
|
|
nNextOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i')
|
|
-- se di tipo split, cerco sou che non siano split
|
|
local nPrevSouId = nPrevOutlineId
|
|
local nPrevSouAreaId = EgtGetParent( EgtGetParent( nPrevSouId))
|
|
local nPrevSouType = EgtGetInfo( nPrevSouAreaId, WIN_AREATYPE, 'i')
|
|
while nPrevSouId and nPrevSouType == WIN_AREATYPES.SPLIT do
|
|
nPrevSouId = EgtGetInfo( nPrevSouId, WIN_SOU)
|
|
nPrevSouAreaId = EgtGetParent( EgtGetParent( nPrevSouId))
|
|
nPrevSouType = EgtGetInfo( nPrevSouAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
nPrevOutlineId = nPrevSouId
|
|
local nNextSouId = nNextOutlineId
|
|
local nNextSouAreaId = EgtGetParent( EgtGetParent( nNextSouId))
|
|
local nNextSouType = EgtGetInfo( nNextSouAreaId, WIN_AREATYPE, 'i')
|
|
while nNextSouId and nNextSouType == WIN_AREATYPES.SPLIT do
|
|
nNextSouId = EgtGetInfo( nNextSouId, WIN_SOU)
|
|
nNextSouAreaId = EgtGetParent( EgtGetParent( nNextSouId))
|
|
nNextSouType = EgtGetInfo( nNextSouAreaId, WIN_AREATYPE, 'i')
|
|
end
|
|
nNextOutlineId = nNextSouId
|
|
end
|
|
-- recupero outline precedente
|
|
if not nPrevOutlineId then
|
|
nPrevOutlineId = EgtGetPrev( nOutlineId)
|
|
if not nPrevOutlineId then
|
|
nPrevOutlineId = EgtGetLastInGroup( nOutlineLayerId)
|
|
end
|
|
end
|
|
if not nNextOutlineId then
|
|
nNextOutlineId = EgtGetNext( nOutlineId)
|
|
if not nNextOutlineId then
|
|
nNextOutlineId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
end
|
|
end
|
|
-- recupero profilo e controprofili
|
|
local sCurrProfileType = EgtGetInfo( nOutlineId, WIN_PROFILETYPE)
|
|
-- se profilo principale BottomRail, gli imposto il profilo
|
|
if nProfileType == WIN_PRF.BOTTOMRAIL then
|
|
sCurrProfileType = WIN_RAIL_BOTTOM
|
|
end
|
|
local sPrevProfileType = EgtGetInfo( nPrevOutlineId, WIN_PROFILETYPE)
|
|
local sNextProfileType = EgtGetInfo( nNextOutlineId, WIN_PROFILETYPE)
|
|
-- se e' di tipo split
|
|
if nProfileType == WIN_PRF.SPLIT then
|
|
-- se profilo Prev e' bottom
|
|
local sPrevName = EgtGetName( nPrevOutlineId)
|
|
if sPrevName == WIN_BOTTOM then
|
|
-- ed e' presente BottomRail
|
|
local nBottomRailId = EgtGetInfo( EgtGetParent( nPrevOutlineId), WIN_BOTTOMRAIL, 'i')
|
|
if nBottomRailId and nBottomRailId == 1 then
|
|
-- allora imposto profilo BottomRail
|
|
sPrevProfileType = WIN_RAIL_BOTTOM
|
|
end
|
|
end
|
|
-- se profilo Next e' bottom
|
|
local sNextName = EgtGetName( nNextOutlineId)
|
|
if sNextName == WIN_BOTTOM then
|
|
-- ed e' presente BottomRail
|
|
local nBottomRailId = EgtGetInfo( EgtGetParent( nNextOutlineId), WIN_BOTTOMRAIL, 'i')
|
|
if nBottomRailId and nBottomRailId == 1 then
|
|
-- allora imposto profilo BottomRail
|
|
sNextProfileType = WIN_RAIL_BOTTOM
|
|
end
|
|
end
|
|
end
|
|
nOrigMainProfileId = EgtGetFirstNameInGroup( nProfileFrameLayerId, sCurrProfileType)
|
|
nOrigStartProfileId = EgtGetFirstNameInGroup( nProfileFrameLayerId, sPrevProfileType)
|
|
nOrigEndProfileId = EgtGetFirstNameInGroup( nProfileFrameLayerId, sNextProfileType)
|
|
-- creo copie di profilo e controprofili
|
|
nMainProfileId = EgtCopy( nOrigMainProfileId, nFrameProfileLayerId)
|
|
EgtSetName( nMainProfileId, WIN_PRF_MAIN)
|
|
nStartProfileId = EgtCopy( nOrigStartProfileId, nFrameProfileLayerId)
|
|
EgtSetName( nStartProfileId, WIN_PRF_START)
|
|
nEndProfileId = EgtCopy( nOrigEndProfileId, nFrameProfileLayerId)
|
|
EgtSetName( nEndProfileId, WIN_PRF_END)
|
|
-- creo solido dai profili
|
|
WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, nStartProfileId, nEndProfileId, nProfileType, nSolidLayerId, nAreaType)
|
|
end
|
|
|
|
-- funzione che crea il solido del Fill
|
|
function WinCalculate.CalcFillSolid(nPartId, nOutlineLayerId, nGeoLayerId)
|
|
-- creo layer per solido
|
|
local nSolidLayerId = EgtGroup( nPartId)
|
|
EgtSetName( nSolidLayerId, WIN_SOLID)
|
|
-- creo compo di outline
|
|
local OutlineList ={}
|
|
local nFirstSideId = EgtGetFirstInGroup( nOutlineLayerId)
|
|
local nOutlineId = nFirstSideId
|
|
while nOutlineId do
|
|
table.insert( OutlineList, nOutlineId)
|
|
nOutlineId = EgtGetNext( nOutlineId)
|
|
end
|
|
local nCompoOutlineId = EgtCurveCompoByChain( nSolidLayerId, OutlineList, EgtSP( nFirstSideId), false)
|
|
-- recupero spessore vetro
|
|
local dGlassThickness = EgtGetInfo( nGeoLayerId, WIN_GEOWIDTH, 'd')
|
|
local nSurfId = EgtSurfTmByRegionExtrusion( nSolidLayerId, nCompoOutlineId, Z_AX() * dGlassThickness)
|
|
EgtErase(nCompoOutlineId)
|
|
end
|
|
|
|
-- funzione che calcola l'ingombro dei pezzi del telaio e i loro solidi
|
|
function WinCalculate.CreatePartFromOutline( nAreaLayerId, nOutlineId, bBottomRail)
|
|
local nAreaType = EgtGetInfo( nAreaLayerId, WIN_AREATYPE, 'i')
|
|
-- creo pezzo
|
|
local nPartId = EgtGroup( GDB_ID.ROOT)
|
|
-- se BottomRail, creo riferimento
|
|
if bBottomRail then
|
|
EgtSetInfo( nOutlineId, WIN_BOTTOMRAIL, nPartId)
|
|
-- local nBaseOutlineLayerId = EgtGetFirstNameInGroup( nAreaLayerId, WIN_AREAOUTLINE)
|
|
-- local nBaseOutlineId = EgtGetFirstInGroup( nBaseOutlineLayerId)
|
|
-- while nBaseOutlineId do
|
|
-- local nCopyId = EgtGetInfo( nBaseOutlineId, WIN_COPY)
|
|
-- if nCopyId == nOutlineId then
|
|
-- EgtSetInfo( nBaseOutlineId, WIN_BOTTOMRAIL, nPartId)
|
|
-- end
|
|
-- end
|
|
end
|
|
-- recupero outline
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaLayerId, WIN_OUTLINE)
|
|
local nProfileType = WIN_PRF.NULL
|
|
if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH or nAreaType == WIN_AREATYPES.SPLIT then
|
|
-- se area senza outline, cerco quella superiore
|
|
if not nOutlineLayerId then
|
|
local nParentAreaLayerId = EgtGetParent( nAreaLayerId)
|
|
if nParentAreaLayerId then
|
|
nOutlineLayerId = EgtGetFirstNameInGroup( nParentAreaLayerId, WIN_OUTLINE)
|
|
end
|
|
end
|
|
-- ricavo tipo dal nome
|
|
local sName = EgtGetName( nOutlineId)
|
|
if bBottomRail then
|
|
nProfileType = WIN_PRF.BOTTOMRAIL
|
|
sName = WIN_BOTTOMRAIL
|
|
elseif sName == WIN_TOP then
|
|
nProfileType = WIN_PRF.TOP
|
|
elseif sName == WIN_BOTTOM then
|
|
nProfileType = WIN_PRF.BOTTOM
|
|
elseif sName == WIN_LEFT then
|
|
nProfileType = WIN_PRF.LEFT
|
|
elseif sName == WIN_RIGHT then
|
|
nProfileType = WIN_PRF.RIGHT
|
|
elseif sName == WIN_VERTICAL then
|
|
nProfileType = WIN_PRF.VERTICAL
|
|
elseif sName == WIN_HORIZONTAL then
|
|
nProfileType = WIN_PRF.HORIZONTAL
|
|
elseif sName == WIN_SPLIT then
|
|
nProfileType = WIN_PRF.SPLIT
|
|
end
|
|
-- imposto nome
|
|
EgtSetName( nPartId, sName)
|
|
-- imposto colore
|
|
if nProfileType == WIN_PRF.BOTTOM or nProfileType == WIN_PRF.TOP or nProfileType == WIN_PRF.HORIZONTAL or nProfileType == WIN_PRF.BOTTOMRAIL then
|
|
EgtSetColor( nPartId, Color3d( 204, 102, 0))
|
|
elseif nProfileType == WIN_PRF.RIGHT or nProfileType == WIN_PRF.LEFT or nProfileType == WIN_PRF.VERTICAL then
|
|
EgtSetColor( nPartId, Color3d( 251, 128, 4))
|
|
else
|
|
EgtSetColor( nPartId, Color3d( 255, 159, 57))
|
|
end
|
|
elseif nAreaType == WIN_AREATYPES.FILL then
|
|
-- imposto nome
|
|
EgtSetName( nPartId, WIN_FILL)
|
|
-- ricavo tipo
|
|
local nFillType = EgtGetInfo( nAreaLayerId, WIN_FILLTYPE, 'i')
|
|
if nFillType == WIN_FILLTYPES.GLASS then
|
|
EgtSetColor( nPartId, Color3d( 71, 161, 255))
|
|
EgtSetAlpha( nPartId, 30)
|
|
elseif nFillType == WIN_FILLTYPES.WOOD then
|
|
EgtSetColor( nPartId, Color3d( 194, 148, 103))
|
|
end
|
|
end
|
|
|
|
-- inserisco riferimento alla sua area ed al suo outline
|
|
EgtSetInfo( nPartId, WIN_AREA, nAreaLayerId)
|
|
if nAreaType ~= WIN_AREATYPES.FILL then
|
|
EgtSetInfo( nPartId, WIN_REF_OUTLINE, nOutlineId)
|
|
if not bBottomRail then EgtSetInfo( nOutlineId, WIN_REF_PART, nPartId) end
|
|
end
|
|
|
|
if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH or nAreaType == WIN_AREATYPES.SPLIT then
|
|
-- disegno ingombro
|
|
local nGeoId = WinCalculate.CalcFrameGeo( nPartId, nOutlineId, nOutlineLayerId, bBottomRail)
|
|
|
|
-- disegno solido
|
|
if bCalcSolid then
|
|
WinCalculate.CalcFrameSolid(nPartId, nOutlineId, nGeoId, nOutlineLayerId, bBottomRail)
|
|
end
|
|
elseif nAreaType == WIN_AREATYPES.FILL then
|
|
-- disegno ingombro
|
|
local nGeoLayerId = WinCalculate.CalcFillGeo( nPartId, nOutlineLayerId)
|
|
|
|
-- disegno solido
|
|
if bCalcSolid then
|
|
WinCalculate.CalcFillSolid(nPartId, nOutlineLayerId, nGeoLayerId)
|
|
end
|
|
end
|
|
|
|
-- se di tipo bottom
|
|
if nProfileType == WIN_BOTTOM then
|
|
-- se ha BottomRail
|
|
local nBottomRail = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i')
|
|
if nBottomRail and nBottomRail == 1 then
|
|
|
|
end
|
|
end
|
|
|
|
-- offset per distanziare i pezzi
|
|
--local dYPosOffset = 300 * ( nProfileType - 1)
|
|
--EgtChangeGroupFrame( nPartId, Frame3d( Point3d( 0, dYPosOffset, 0)))
|
|
|
|
end
|
|
|
|
-- funzione che posiziona un pezzo
|
|
function WinCalculate.PositionPart(nPartId)
|
|
-- ricavo tipo dal nome
|
|
local sName = EgtGetName( nPartId)
|
|
local sDelta = ''
|
|
if sName == WIN_BOTTOM then
|
|
sDelta = WIN_STARTCPDELTA
|
|
elseif sName == WIN_RIGHT then
|
|
sDelta = WIN_STARTCPDELTA
|
|
elseif sName == WIN_TOP then
|
|
sDelta = WIN_STARTCPDELTA
|
|
elseif sName == WIN_LEFT then
|
|
sDelta = WIN_STARTCPDELTA
|
|
end
|
|
-- calcolo nuovo riferimento
|
|
local nGeoPartLayerId = EgtGetFirstNameInGroup( nPartId, WIN_GEO)
|
|
local nGeoPartId = EgtGetFirstNameInGroup( nGeoPartLayerId, sName)
|
|
local dDelta = EgtGetInfo( nGeoPartId, sDelta, 'd') or 0
|
|
local nFrameLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_FRAME)
|
|
local nOutlineLayerId = EgtGetFirstNameInGroup( nFrameLayerId, WIN_OUTLINE)
|
|
local nFramePartId = EgtGetFirstNameInGroup( nOutlineLayerId, sName)
|
|
local vtStart = EgtSV( nFramePartId)
|
|
local ptStart = EgtSP( nFramePartId) + vtStart * dDelta
|
|
local _, _, dAngRight = SphericalFromVector(vtStart)
|
|
local frStart = Frame3d( ptStart)
|
|
frStart:rotate( frStart:getOrigin(), Z_AX(), dAngRight)
|
|
EgtChangeGroupFrame( nPartId, frStart)
|
|
end
|
|
|
|
-- funzione che assembla i pezzi
|
|
function WinCalculate.AssembleFrame()
|
|
local nBottomPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_BOTTOM)
|
|
WinCalculate.PositionPart(nBottomPartId)
|
|
local nRightPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_RIGHT)
|
|
WinCalculate.PositionPart(nRightPartId)
|
|
local nTopPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_TOP)
|
|
WinCalculate.PositionPart(nTopPartId)
|
|
local nLeftPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_LEFT)
|
|
WinCalculate.PositionPart(nLeftPartId)
|
|
-- assemblo i pezzi
|
|
--local nRightPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_RIGHT)
|
|
--local nGeoRightLayerId = EgtGetFirstNameInGroup( nRightPartId, WIN_GEO)
|
|
--local nGeoRightId = EgtGetFirstNameInGroup( nGeoRightLayerId, WIN_RIGHT)
|
|
--local dDelta = EgtGetInfo( nGeoRightId, WIN_BOTTOMCPDELTA, 'd')
|
|
--local nFrameLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_FRAME)
|
|
--local nOutlineLayerId = EgtGetFirstNameInGroup( nFrameLayerId, WIN_OUTLINE)
|
|
--local nFrameRightId = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_RIGHT)
|
|
--local vtRight = EgtSV( nFrameRightId)
|
|
--local ptRight = EgtSP( nFrameRightId) + vtRight * dDelta
|
|
--local _, _, dAngRight = SphericalFromVector(vtRight)
|
|
--local frRight = Frame3d( ptRight)
|
|
--frRight:rotate( frRight:getOrigin(), Z_AX(), dAngRight)
|
|
--EgtChangeGroupFrame( nRightPartId, frRight)
|
|
end
|
|
|
|
---------------------------------------------------------------------
|
|
return WinCalculate
|