From 17f97c21f25e68b4f7a9a5dc874b19488cfe5251 Mon Sep 17 00:00:00 2001 From: SaraP Date: Mon, 13 May 2024 16:22:28 +0200 Subject: [PATCH] EgwWindowLua : - modifiche stilistiche varie ( rese locali alcune funzioni, unite parti ripetute, eliminate variabili inultizzate,...). --- Profiles/WinLib/WinCalculate.lua | 2980 ++++++++++++------------------ 1 file changed, 1156 insertions(+), 1824 deletions(-) diff --git a/Profiles/WinLib/WinCalculate.lua b/Profiles/WinLib/WinCalculate.lua index e0bb4e8..2b69746 100644 --- a/Profiles/WinLib/WinCalculate.lua +++ b/Profiles/WinLib/WinCalculate.lua @@ -28,180 +28,10 @@ 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 - -function WinCalculate.AddSplitDowelToParts( nAreaId) - -- se non ho calcolato i solidi, esco - if not bCalcSolid then - return - end - -- recupero tipo di area - local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') - if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then - -- recupero pezzi outline - local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) - local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) - while nOutlineId do - WinCalculate.AddSplitDowelToExtrusion( nOutlineId, nAreaType, false) - -- 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.AddSplitDowelToExtrusion( nOutlineId, nAreaType, true) - end - end - nOutlineId = EgtGetNext( nOutlineId) - end - 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.AddSplitDowelToExtrusion( nSplitId, nAreaType, false) - end - end - end - -- verifico se ci sono aree - local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') - while nChildAreaId do - -- lancio costruzione pezzi di quell'area - WinCalculate.AddSplitDowelToParts( 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 function TrimAndOrientOrderedCurveLayer( nLayerId) local IntersCurveList = {} local LastCurveInters local ptInters @@ -214,7 +44,7 @@ function WinCalculate.TrimAndOrientOrderedCurveLayer( nLayerId) end ptInters = EgtIP( nCurveId, nPrevId, EgtSP( nCurveId)) if not ptInters then - local dDist = abs( ( EgtEP( nPrevId) - EgtSP(nCurveId)):len()) + local dDist = dist( EgtEP( nPrevId), EgtSP( nCurveId)) EgtExtendCurveStartByLen( nCurveId, 2 * dDist) EgtExtendCurveEndByLen( nCurveId, 2 * dDist) EgtExtendCurveStartByLen( nPrevId, 2 * dDist) @@ -242,27 +72,8 @@ function WinCalculate.TrimAndOrientOrderedCurveLayer( nLayerId) 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) +--------------------------------------------------------------------- +local function TrimSplitWithOutline( nSplitId) -- lo taglio con outline local nStartIntersId = EgtGetInfo( nSplitId, WIN_SPLIT_STARTINTERS, 'i') local nOutlineId = EgtGetInfo( nStartIntersId, WIN_CHILD, 'i') @@ -276,328 +87,51 @@ function WinCalculate.TrimSplitWithOutline( nSplitId) 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 ... +--------------------------------------------------------------------- +-- funzione che data una curva di outline restituisce l'id del suo profilo +local function GetOutlineProfileId( nOutlineId, bUseBottomRail) + -- ciclo fino a trovare il primo parent che abbia un AreaType definito ( frame o sash) + local nCurrId = nOutlineId + local nAreaType = WIN_AREATYPES.NULL + while nCurrId and ( nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL) do + nCurrId = EgtGetParent( nCurrId) + nAreaType = EgtGetInfo( nCurrId or GDB_ID.NULL, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL end + + -- recupero il gruppo contenente il profilo + local nProfilesGrpId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) + local nLayerId + if nAreaType == WIN_AREATYPES.FRAME then + nLayerId = EgtGetFirstNameInGroup( nProfilesGrpId, WIN_FRAME) + elseif nAreaType == WIN_AREATYPES.SASH then + nLayerId = EgtGetFirstNameInGroup( nProfilesGrpId, WIN_SASH) + end + + -- recupero il nome del profilo + local sProfileName = EgtGetInfo( nOutlineId, WIN_PROFILETYPE) + + -- verifico se bottom rail + if bUseBottomRail then + local nOutlineLay = EgtGetParent( nOutlineId) + local bBottomRail = EgtGetInfo( nOutlineLay, WIN_BOTTOMRAIL, 'b') or false + local sOutlineName = EgtGetName( nOutlineId) + if sOutlineName == WIN_BOTTOM and bBottomRail then + -- allora imposto profilo BottomRail + sProfileName = WIN_RAIL_BOTTOM + end + end + + -- recupero il profilo + return EgtGetFirstNameInGroup( nLayerId, sProfileName) end + +--------------------------------------------------------------------- +----------------- CALCOLO DEI PROFILI ------------------------------ +--------------------------------------------------------------------- -- funzione che verifica se ci sono Sash dopo -function WinCalculate.VerifyChildArea( nAreaId) +local function VerifyChildArea( nAreaId) local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAASTERISK) local nChildAreaType if nChildAreaId then @@ -605,7 +139,7 @@ function WinCalculate.VerifyChildArea( nAreaId) if nChildAreaType == WIN_AREATYPES.SASH then return true end - if WinCalculate.VerifyChildArea( nChildAreaId) then return true end + if VerifyChildArea( nChildAreaId) then return true end end while nChildAreaId and nChildAreaType ~= WIN_AREATYPES.SASH do nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREAASTERISK) @@ -615,208 +149,137 @@ function WinCalculate.VerifyChildArea( nAreaId) return true end end - if WinCalculate.VerifyChildArea( nChildAreaId) then return true end + if 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 +--------------------------------------------------------------------- +-- funzione che identifica il tipo di split ( mullion, french, null) +local function GetSplitType( nSplitLayerId) + + local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') + -- se non ha split impostato verifico se ha sash prima o dopo per capire se è implicitamente di tipo mullion + if not nSplitType then + local nParentAreaId = EgtGetParent( nSplitLayerId) + local nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL + while nParentAreaId and nParentAreaType ~= WIN_AREATYPES.SASH do + nParentAreaId = EgtGetParent( nParentAreaId) + nParentAreaType = EgtGetInfo( nParentAreaId or GDB_ID.NULL, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL + end + -- devi confrontare il type con sash + if not nParentAreaId or nParentAreaType ~= WIN_AREATYPES.SASH then + -- verifico se ci sono Sash dopo + local nAreaId = EgtGetParent( nSplitLayerId) + local bSashAfter = VerifyChildArea( nAreaId) + -- se ci sono assegno tipo di profilo a mullion + if bSashAfter then + EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, WIN_SPLITTYPES.MULLION) + nSplitType = WIN_SPLITTYPES.MULLION 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 + end + if not nSplitType then + -- EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, WIN_SPLITTYPES.NULL) + nSplitType = WIN_SPLITTYPES.NULL + end + + return nSplitType +end + +--------------------------------------------------------------------- +-- funzione che imposta i tipi di profilo per gli split +local function CalcSplitProfileType( nSplitLayerId, nAreaId) + + local nSplitId = EgtGetFirstInGroup( nSplitLayerId) + -- verifico il tipo di split + local nSplitType = GetSplitType( nSplitLayerId) + if nSplitType == WIN_SPLITTYPES.MULLION then + -- 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 + + elseif nSplitType == WIN_SPLITTYPES.NULL then + -- verifico se interno ad anta o a frame + local nParentAreaId = 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 + 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 split di tipo french non ha profilo assegnato perchè non ha un pezzo associato +end + +--------------------------------------------------------------------- +-- funzione che imposta i tipi di profilo in base al tipo di pezzi +local function CalcProfileType( nAreaId) + local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') + + -- FRAME + if nAreaType == WIN_AREATYPES.FRAME then + -- assegno il profilo alle curve di 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 - 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) - if nChildId then - nChildAreaId = EgtGetParent( EgtGetParent( nChildId)) - nChildType = EgtGetInfo( nChildAreaId, WIN_AREATYPE, 'i') - end - until not nChildId or ( nChildType ~= WIN_AREATYPES.SPLIT and nChildType ~= WIN_AREATYPES.NULL) - local sName = EgtGetName( nOutlineId) - -- se vetro fisso o interno non definito - if not nChildId or 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 - elseif 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 end - nOutlineId = EgtGetNext( nOutlineId) + 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 - elseif nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then - -- verifico se ci sono Split + + -- verifico se ci sono split e ne assegno il profilo 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 + if nSplitLayerId then + CalcSplitProfileType( nSplitLayerId, nAreaId) + end + + -- SPLIT + elseif nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then + -- verifico se ci sono split e ne assegno il profilo + local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) + if nSplitLayerId then + CalcSplitProfileType( nSplitLayerId, nAreaId) + end + + -- SASH elseif nAreaType == WIN_AREATYPES.SASH then -- verifico se e' di tipo battente ricevente local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') @@ -828,9 +291,8 @@ function WinCalculate.CalcProfileType( nAreaId) -- 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 + local sSouName = EgtGetName( nSouId) + if sSouName == WIN_SPLIT then if nSashType == WIN_SASHTYPES.ACTIVE then EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE) elseif nSashType == WIN_SASHTYPES.INACTIVE then @@ -860,287 +322,363 @@ function WinCalculate.CalcProfileType( nAreaId) nOutlineId = EgtGetNext( nOutlineId) end end - -- verifico se ci sono Split + + -- 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 ... - + EgtSetInfo( nSplitId, WIN_PROFILETYPE, WIN_SASH_SPLIT) + end 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 .. 1 then - dCPDelta = abs( b3CP:getMin():getX()) - else - dCPDelta = abs( b3CP:getMax():getX()) +--------------------------------------------------------------------- +--------------------- CALCOLO OUTLINE ------------------------------- +--------------------------------------------------------------------- +-- funzione che calcola l'outline dall'area outline ( base outline) +local function CalculateOutlineFromAreaOutline( nAreaId) + + local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') + -- recupero il base outline e lo copio + local nAreaOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) + local nOutlineLayerId = EgtCopyGlob( nAreaOutlineLayerId, nAreaId) + EgtSetName( nOutlineLayerId, WIN_OUTLINE) + + -- FRAME + if nAreaType == WIN_AREATYPES.FRAME then + -- sistemo le info + 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 - --local dCPDelta = abs( b3Ref:getMin():getX() - b3CP:getDimX()) - end - return dCPDelta, b3Ref, nProfileId, nProfileRefId -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 + --- 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') - local nLastOrigPrevSouId = nOrigPrevSouId - while nOrigPrevSouId and nOrigPrevSouType == WIN_AREATYPES.SPLIT do - nOrigPrevSouId = EgtGetInfo( nOrigPrevSouId, WIN_SOU) - -- se esiste un SOU, ne recupero l'area ed il tipo, altrimenti lascio nullo per uscire perche' sono arrivato allo split originale - if nOrigPrevSouId and nOrigPrevSouId ~= GDB_ID.NULL then - nLastOrigPrevSouId = nOrigPrevSouId - nOrigPrevSouAreaId = EgtGetParent( EgtGetParent( nOrigPrevSouId)) - nOrigPrevSouType = EgtGetInfo( nOrigPrevSouAreaId, WIN_AREATYPE, 'i') + -- SPLIT + elseif nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then + -- svuoto il gruppo + EgtEmptyGroup( nOutlineLayerId) + -- recupero outline di livello precedente e lo copio pezzo per pezzo + local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId) + while nBaseOutlineId do + -- recupero la curva di outline corrispondente alla curva del base outline da cui deriva e la copio + local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') + local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') + local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) + + -- se deriva da split devo aggiornare il nome + local sSouName = EgtGetName( nSouId) + if sSouName == WIN_SPLIT then + local sBaseName = EgtGetName( nBaseOutlineId) + EgtSetName( nOutlineId, sBaseName) + end + + -- sistemo le info + EgtSetInfo( nOutlineId, WIN_SOU, nBaseOutlineId) + EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId) + EgtRemoveInfo( nOutlineId, WIN_CHILD) + EgtRemoveInfo( nOutlineId, WIN_COPY) + + nBaseOutlineId = EgtGetNext( nBaseOutlineId) + end + -- taglio tutti i contorni + TrimAndOrientOrderedCurveLayer( nOutlineLayerId) + + -- 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 + 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 - if not nOrigPrevSouId then - nOrigPrevSouId = nLastOrigPrevSouId - 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 + + + -- SASH + elseif nAreaType == WIN_AREATYPES.SASH then + -- svuoto il gruppo + EgtEmptyGroup( nOutlineLayerId) + -- recupero se anta battente ricevente + local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL + + -- ciclo su profilo disegnato anta + local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId) + while nBaseOutlineId do + -- recupero la curva di outline del base outline da cui deriva e la copio + local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') + local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') + local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) + + -- recupero tipo di profili anta + local sSashProfile = EgtGetInfo( nBaseOutlineId, 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') + + -- sposto anta in Z + EgtMove( nOutlineId, Z_AX() * dSashZOffset) + + -- sistemo le info + EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId) + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, sSashProfile) + EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId) --- 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 + -- verifico se outline e' segmento battente o ricevente che quindi deriva da split + local bOnFrenchSplit = false + if nSashType ~= WIN_SASHTYPES.NULL then + -- faccio sou due volte per trovare il tipo dell'outline originale da cui deriva + local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') + nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') + local sSouName = EgtGetName( nSouId) + -- se deriva da split è segmento battente/ricevente + if sSouName == WIN_SPLIT then + bOnFrenchSplit = true end - nCtrInId = EgtGetNextName( nCtrInId, WIN_CTRIN .. '*') end - if nMinCtrInId then - sPrevCtrIn = EgtGetName( nMinCtrInId) + + -- se outline non è segmento battente o ricevente ( che quindi deriva da split) necessita di offset + if not bOnFrenchSplit then + + -- recupero a ritroso il profilo dell'elemento del frame su cui poggia + local nFrameBaseOutlineId = nSouId + local sFrameProfile = EgtGetInfo( nFrameBaseOutlineId, WIN_PROFILETYPE) + while not sFrameProfile and nFrameBaseOutlineId do + nFrameBaseOutlineId = EgtGetInfo( nFrameBaseOutlineId, WIN_SOU , 'i') + sFrameProfile = EgtGetInfo( nFrameBaseOutlineId or GDB_ID.NULL, WIN_PROFILETYPE) + end + 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) + local b3FrameProfile = EgtGetBBoxRef( nRefFrameProfileId, GDB_BB.STANDARD, frFrameProfileId) + -- calcolo offset perpendicolare + local dOverlap = EgtGetInfo( nSashProfileId, WIN_OVERLAP, 'd') + local dSashPerpOffset = abs( b3FrameProfile:getMin():getX()) - dOverlap + + -- faccio offset + EgtOffsetCurve( nOutlineId, - dSashPerpOffset) end - end + + nBaseOutlineId = EgtGetNext( nBaseOutlineId) + end + -- accorcio gli offset + TrimAndOrientOrderedCurveLayer( nOutlineLayerId) + + -- se presente, copio split + local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) + if nBaseSplitLayerId then + local nBaseSplitId = EgtGetFirstInGroup( nBaseSplitLayerId) + -- creo copia + local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId) + EgtSetName( nSplitLayerId, WIN_SPLIT) + local nSplitId = EgtGetFirstInGroup( nSplitLayerId) + EgtSetInfo( nBaseSplitId, WIN_COPY, nSplitId) + EgtRemoveInfo( nSplitId, WIN_SOU) + -- la taglio con outline + TrimSplitWithOutline( nSplitId) + + -- recupero profilo usato per anta + local sSplitProfile = EgtGetInfo( nBaseSplitId, WIN_PROFILETYPE) + 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') + -- sposto split in Z + EgtMove( nSplitId, Z_AX() * dSplitZOffset) + end + + + -- FILL + elseif nAreaType == WIN_AREATYPES.FILL then + -- svuoto il gruppo + EgtEmptyGroup( nOutlineLayerId) + -- ciclo su BaseArea riempimento + local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId) + while nBaseOutlineId do + -- recupero la curva di outline del base outline da cui deriva e la copio + local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU) + local nCopyId = EgtGetInfo( nSouId, WIN_COPY) + local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) + -- sistemo le info + EgtSetInfo( nBaseOutlineId, WIN_CHILD, nOutlineId) + + -- recupero a ritroso il profilo dell'elemento su cui poggia ( anta, split o frame) + local nParentBaseOutlineId = nSouId + local sParentProfile = EgtGetInfo( nParentBaseOutlineId, WIN_PROFILETYPE) + while not sParentProfile and nParentBaseOutlineId do + nParentBaseOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_SOU , 'i') + sParentProfile = EgtGetInfo( nParentBaseOutlineId or GDB_ID.NULL, WIN_PROFILETYPE) + end + local nParentOutlineId = EgtGetInfo( nParentBaseOutlineId, WIN_COPY) + local nParentProfileId = GetOutlineProfileId( nParentOutlineId, true) + + -- recupero le relative origini + local nFrameParentProfileId = EgtGetFirstNameInGroup( nParentProfileId, WIN_SECTIONFRAME) + local frParentProfileId = EgtFR(nFrameParentProfileId) + -- calcolo il box del riferimento del profilo del frame + local nRefParentProfileId = EgtGetFirstNameInGroup( nParentProfileId, WIN_REF) + local b3FrameProfile = EgtGetBBoxRef( nRefParentProfileId, GDB_BB.STANDARD, frParentProfileId) + -- calcolo offset perpendicolare e sulla z dell'anta + local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd') + local dFillPerpOffset = abs( b3FrameProfile:getMin():getX()) - dOverlap + local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd') + + -- faccio offset e muovo in z + EgtOffsetCurve( nOutlineId, - dFillPerpOffset) + EgtMove( nOutlineId, Z_AX() * dFillZOffset) + + nBaseOutlineId = EgtGetNext( nBaseOutlineId) + end + -- accorcio gli offset + TrimAndOrientOrderedCurveLayer( nOutlineLayerId) 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 +--------------------------------------------------------------------- +---------------------- CALCOLO PEZZI ------------------------------ +--------------------------------------------------------------------- +-- funzione che calcola l'ingombro del fill +local function 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 crea il solido del Fill +local function 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 - - - --- -- -- 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) +-------------------------------------------------------------------- +-- funzione che restituisce il WIN_PRF in base al nome della curva +local function GetOutlineProfileType( nOutlineId, bBottomRail) + -- ricavo tipo dal nome + local sName = EgtGetName( nOutlineId) + local nProfileType = WIN_PRF.NULL if bBottomRail then - sCurrProfileType = WIN_RAIL_BOTTOM + 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_SPLIT then + nProfileType = WIN_PRF.SPLIT 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 + return nProfileType end +--------------------------------------------------------------------- +-- funzione che recupera l'outline precedente e successivo +local function GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) + + local nPrevOutlineId + local nNextOutlineId + + if nProfileType == WIN_PRF.SPLIT then + -- se split individuo l'outline associato al base outline che lo taglia + 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') + else + nPrevOutlineId = EgtGetPrev( nOutlineId) + if not nPrevOutlineId then + nPrevOutlineId = EgtGetLastInGroup( nOutlineLayerId) + end + nNextOutlineId = EgtGetNext( nOutlineId) + if not nNextOutlineId then + nNextOutlineId = EgtGetFirstInGroup( nOutlineLayerId) + end + end + + return nPrevOutlineId, nNextOutlineId +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 @@ -1161,159 +699,195 @@ local function CalcPartJointType( nProfileType, JointType) 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) +--------------------------------------------------------------------- +-- funzione che restituisce il tipo di controprofilo dell'outline adiacente +local function GetProfileCtrIn( nProfileType, nPrevOutlineId, nOutlineId, nPrevProfileId) + local sPrevCtrIn = WIN_CTRIN + -- gestione particolare nel caso di split su split + 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( nPrevProfileId, WIN_SECTIONFRAME) + local frSectionFrame = EgtFR( nSectionFrameId, GDB_ID.ROOT) + local dMinDist = GEO.INFINITO + -- confronto distanze dei controprofili rispetto a distanza dell'outline per trovare il controprofilo piu' vicino + local nMinCtrInId + local nCtrInId = EgtGetFirstNameInGroup( nPrevProfileId, WIN_CTRIN .. '*') + while nCtrInId do + local b3CtrIn = EgtGetBBoxRef( nCtrInId, GDB_BB.STANDARD, frSectionFrame) + local dCtrInDist = abs( ( dSide * dOutlineDist) - b3CtrIn:getCenter():getX()) + if 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 + +--------------------------------------------------------------------- +local function GetDeltaProfile( nProfileType, nPrevOutlineId, nOutlineId) + -- recupero il profilo dell'outline precedente + local nPrevProfileId = GetOutlineProfileId( nPrevOutlineId, nProfileType == WIN_PRF.SPLIT) + local sCtrIn = GetProfileCtrIn( nProfileType, nPrevOutlineId, nOutlineId, nPrevProfileId) + + local dCPDelta = 0 + local nSectionFrId = EgtGetFirstNameInGroup( nPrevProfileId, WIN_SECTIONFRAME) + local frSectionFrame = EgtFR( nSectionFrId) + local nCPId = EgtGetFirstNameInGroup( nPrevProfileId, sCtrIn) + local b3CP = EgtGetBBoxRef( nCPId, GDB_BB.STANDARD, frSectionFrame) + if sCtrIn == WIN_CTRIN .. 1 then + dCPDelta = abs( b3CP:getMin():getX()) + else + dCPDelta = abs( b3CP:getMax():getX()) + end + return dCPDelta +end + +--------------------------------------------------------------------- +-- funzione che crea le curve del geo +local function CreateFrameGeo( nOutlineId, nPrevOutlineId, nNextOutlineId, nStartPartJointType, nEndPartJointType, nProfileType, nGeoLayerId, bBottomRail) + + local nCurrProfileId = GetOutlineProfileId( nOutlineId, bBottomRail) + local nCurrProfileRefId = EgtGetFirstNameInGroup( nCurrProfileId, WIN_REF) + -- 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 le offsetto opportunamente + -- curva out + local nCurrCurveId = EgtCopy( nOutlineId, nGeoLayerId) + EgtOffsetCurve( nCurrCurveId, dCurrOffset) + EgtSetName( nCurrCurveId, WIN_GEO_OUT) + + -- cruva in + local nCurrOffsetId = EgtCopy( nOutlineId, nGeoLayerId) + EgtOffsetCurve( nCurrOffsetId, dCurrOffset - b3CurrProfileFrame:getDimX()) + EgtInvertCurve( nCurrOffsetId) + EgtSetName( nCurrOffsetId, WIN_GEO_IN) + + -- curva left + local nPrevCurveId + if nStartPartJointType == WIN_PART_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) + if nStartPartJointType == WIN_PART_JNT.SHORT then + local dPrevCPDelta = GetDeltaProfile( nProfileType, nPrevOutlineId, nOutlineId) + EgtOffsetCurve( nPrevCurveId, - dPrevCPDelta) + EgtSetInfo( nGeoLayerId, WIN_STARTCPDELTA, dPrevCPDelta) + end + end + EgtSetName( nPrevCurveId, WIN_GEO_LEFT) + + -- curva right + local nNextCurveId + if nEndPartJointType == WIN_PART_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) + if nEndPartJointType == WIN_PART_JNT.SHORT then + local dNextCPDelta = GetDeltaProfile( nProfileType, nNextOutlineId, nOutlineId) + EgtOffsetCurve( nNextCurveId, - dNextCPDelta) + EgtSetInfo( nGeoLayerId, WIN_ENDCPDELTA, dNextCPDelta) + end + end + EgtSetName( nNextCurveId, WIN_GEO_RIGHT) + + local dGeoWidth = b3CurrProfileFrame:getDimX() + return nCurrCurveId, nCurrOffsetId, nPrevCurveId, nNextCurveId, dGeoWidth +end + +--------------------------------------------------------------------- +-- funzione che calcola l'ingombro dei pezzi del telaio +local function CalcFrameGeo( nPartId, nOutlineId, nOutlineLayerId, bBottomRail) + -- 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)) + + -- ricavo tipo di profilo + local nProfileType = GetOutlineProfileType( nOutlineId, bBottomRail) + + -- recupero outline precedente e successivo + local nPrevOutlineId, nNextOutlineId = GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) + + -- recupero il tipo di giunzioni + local nStartJointType + local nEndJointType + if nProfileType == WIN_PRF.TOP then + nStartJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_TR, 'i') + nEndJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_TL, 'i') 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)) + nStartJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_BL, 'i') + nEndJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_BR, 'i') 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)) + nStartJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_TL, 'i') + nEndJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_BL, 'i') 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') + nStartJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_BR, 'i') + nEndJointType = EgtGetInfo( nOutlineLayerId, WIN_JOINT_TR, 'i') + else + -- nei casi di profilo BottomRail e Split non serve settare dei valori per StartJointType ed EndJointType perchè + -- in CalcPartJointType la loro giunzione viene settata a short end - -- recupero outline precedente - if not nPrevOutlineId then - nPrevOutlineId = EgtGetPrev( nOutlineId) - if not nPrevOutlineId then - nPrevOutlineId = EgtGetLastInGroup( nOutlineLayerId) - end + -- se pezzo non e' split, giunzione diversa da bisettrice ed arco a tutto sesto forzo il tipo a bisettrice + if nProfileType ~= WIN_PRF.SPLIT and nStartJointType ~= WIN_JNT.ANGLED and AreSameVectorApprox( EgtEV( nPrevOutlineId), EgtSV( nOutlineId)) then + nStartJointType = WIN_JNT.ANGLED end - if not nNextOutlineId then - nNextOutlineId = EgtGetNext( nOutlineId) - if not nNextOutlineId then - nNextOutlineId = EgtGetFirstInGroup( nOutlineLayerId) - end + if nProfileType ~= WIN_PRF.SPLIT and nEndJointType ~= WIN_JNT.ANGLED and AreSameVectorApprox( EgtEV( nOutlineId), EgtSV( nNextOutlineId)) then + nEndJointType = WIN_JNT.ANGLED 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( nOutlineId, WIN_STARTJOINT, 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( nOutlineId, WIN_ENDJOINT, WIN_JNT.ANGLED) - -- EgtSetInfo( nOutlineLayerId, WIN_JOINT_TR, 'i') + + -- calcolo il tipo di giunzione per la parte + local nStartPartJointType = CalcPartJointType( nProfileType, nStartJointType) + local nEndPartJointType = CalcPartJointType( nProfileType, nEndJointType) + + -- salvo i valori joint su outline per disegno solido + if nProfileType ~= WIN_PRF.BOTTOMRAIL then + EgtSetInfo( nOutlineId, WIN_STARTJOINT, nStartPartJointType) + EgtSetInfo( nOutlineId, WIN_ENDJOINT, nEndPartJointType) end + -- creo lati dell'outline - nCurrCurveId, nCurrOffsetId, nPrevCurveId, nNextCurveId, dGeoWidth = WinCalculate.CreateFrameGeo( nOutlineId, nPrevOutlineId, nNextOutlineId, StartJointType, EndJointType, nProfileType, nGeoLayerId, nProfileFrameLayerId, bBottomRail) + local nCurrCurveId, nCurrOffsetId, nPrevCurveId, nNextCurveId, dGeoWidth = CreateFrameGeo( nOutlineId, nPrevOutlineId, nNextOutlineId, nStartPartJointType, nEndPartJointType, nProfileType, nGeoLayerId, bBottomRail) + + -- trim delle curve + -- se le curve fossero ordinate correttamente ( out-right-in-left) potresti usare la funzione TrimAndOrientOrderedCurveLayer( nGeoLayerId) -- calcolo punti di intersezione local ptIntersCurrPrev = EgtIP( nCurrCurveId, nPrevCurveId, EgtSP( nCurrCurveId)) if not ptIntersCurrPrev then @@ -1360,44 +934,20 @@ function WinCalculate.CalcFrameGeo( nPartId, nOutlineId, nOutlineLayerId, bBotto 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 function CalcStartEndProfileType( nProfileType, nOutlineId, nStartProfileId, nEndProfileId) + local sStartProfileType local sEndProfileType - StartJointType = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'i') + local StartJointType = EgtGetInfo( nOutlineId, WIN_STARTJOINT, 'i') if StartJointType == WIN_PART_JNT.ANGLED then sStartProfileType = WIN_MINIZINKEN elseif StartJointType == WIN_PART_JNT.SHORT then @@ -1405,7 +955,8 @@ function WinCalculate.CalcStartEndProfileType(nProfileType, nOutlineId, nStartPr elseif StartJointType == WIN_PART_JNT.FULL then sStartProfileType = WIN_OUTOFST end - EndJointType = EgtGetInfo( nOutlineId, WIN_ENDJOINT, 'i') + + local EndJointType = EgtGetInfo( nOutlineId, WIN_ENDJOINT, 'i') if EndJointType == WIN_PART_JNT.ANGLED then sEndProfileType = WIN_MINIZINKEN elseif EndJointType == WIN_PART_JNT.SHORT then @@ -1413,80 +964,14 @@ function WinCalculate.CalcStartEndProfileType(nProfileType, nOutlineId, nStartPr 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 + + if 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 = GetProfileCtrIn( nProfileType, nStartId, nOutlineId, nStartProfileId) + sEndProfileType = GetProfileCtrIn( nProfileType, nEndId, nOutlineId, nEndProfileId) sStartProfileType = WIN_OFST .. sStartProfileType sEndProfileType = WIN_OFST .. sEndProfileType elseif nProfileType == WIN_PRF.BOTTOMRAIL then @@ -1495,82 +980,15 @@ function WinCalculate.CalcStartEndProfileType(nProfileType, nOutlineId, nStartPr sStartProfileType = WIN_CTRINOFST sEndProfileType = WIN_CTRINOFST end + return sStartProfileType, sEndProfileType, StartJointType, EndJointType end --- funzione che recupera l'outline precedente e successivo -local function GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) - local nPrevOutlineId - local nNextOutlineId - -- recupero outline precedente e successivo -if nProfileType == WIN_PRF.VERTICAL then - nPrevOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i') - nNextOutlineId = EgtGetInfo( nOutlineId, WIN_SPLIT_ENDINTERS, 'i') - elseif nProfileType == WIN_PRF.HORIZONTAL then - 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 = 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') - local nLastPrevSouId = nPrevSouId - while nPrevSouId and nPrevSouType == WIN_AREATYPES.SPLIT do - nPrevSouId = EgtGetInfo( nPrevSouId, WIN_SOU) - if nPrevSouId and nPrevSouId ~= GDB_ID.NULL then - nLastPrevSouId = nPrevSouId - nPrevSouAreaId = EgtGetParent( EgtGetParent( nPrevSouId)) - nPrevSouType = EgtGetInfo( nPrevSouAreaId, WIN_AREATYPE, 'i') - end - end - if not nPrevSouId then - nPrevSouId = nLastPrevSouId - end - nPrevOutlineId = nPrevSouId - local nNextSouId = nNextOutlineId - local nNextSouAreaId = EgtGetParent( EgtGetParent( nNextSouId)) - local nNextSouType = EgtGetInfo( nNextSouAreaId, WIN_AREATYPE, 'i') - local nLastNextSouId = nNextSouId - while nNextSouId and nNextSouType == WIN_AREATYPES.SPLIT do - nNextSouId = EgtGetInfo( nNextSouId, WIN_SOU) - if nNextSouId and nNextSouId ~= GDB_ID.NULL then - nLastNextSouId = nNextSouId - nNextSouAreaId = EgtGetParent( EgtGetParent( nNextSouId)) - nNextSouType = EgtGetInfo( nNextSouAreaId, WIN_AREATYPE, 'i') - end - end - if not nNextSouId then - nNextSouId = nLastNextSouId - 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 - return nPrevOutlineId, nNextOutlineId -end - +--------------------------------------------------------------------- -- funzione che posiziona i profili, li estrude e crea il solido -function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, nStartProfileId, nEndProfileId, nProfileType, nSolidLayerId, nAreaType) +local function 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 @@ -1578,6 +996,14 @@ function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, n local nNextGeoId = EgtGetFirstNameInGroup( nGeoLayerId, WIN_GEO_RIGHT) -- recupero BBox e larghezza del geo local dGeoWidth = EgtGetInfo( nGeoId, WIN_GEOWIDTH, 'd') + + -- recupero tipo di giunzioni e i controprofili + local sStartProfileType, sEndProfileType, StartJointType, EndJointType = CalcStartEndProfileType( nProfileType, nOutlineId, nStartProfileId, nEndProfileId) + + -- recupero outline precedente e successivo + local nPrevOutlineId, nEndOutlineId = GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) + + -- a) MAIN EXTRUSION -- creo guida Main local nGuideId = EgtCopy( nOutlineId, nSolidLayerId) EgtSetName( nGuideId, WIN_MAINGUIDE) @@ -1595,9 +1021,12 @@ function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, n local nMainOutlineId = EgtGetFirstNameInGroup( nMainProfileId, WIN_SECTION) local nMainExtrusionId = EgtSurfTmSwept( nSolidLayerId, nMainOutlineId, nGuideId, false, WIN_SURF_APPROX) EgtSetName( nMainExtrusionId, WIN_SRF_MAIN) + -- creo una copia dell'estrusione principale per trim successivi local nOrigMainExtrusionId = EgtCopy( nMainExtrusionId, nSolidLayerId) EgtSetName( nOrigMainExtrusionId, WIN_SRF_ORIGMAIN) EgtSetStatus( nOrigMainExtrusionId, GDB_ST.OFF) + + -- b) START PROFILE -- posiziono il profilo Start local nRefStartProfileId = EgtGetFirstNameInGroup( nStartProfileId, WIN_REF) local b3RefStartProfile = EgtGetBBoxGlob(nRefStartProfileId, GDB_BB.STANDARD) @@ -1617,12 +1046,8 @@ function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, n 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 + + -- se Start e' split verifico se è necessaria inversione del profilo local nStartId = EgtGetInfo( nOutlineId, WIN_SPLIT_STARTINTERS, 'i') local nStartProfileType if nStartId then @@ -1667,16 +1092,18 @@ function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, n else nOutStartProfileId = EgtGetFirstNameInGroup( nStartProfileId, sStartProfileType) end + local nStartExtrusionId = EgtSurfTmSwept( nSolidLayerId, nOutStartProfileId, nStartGuideId, false, WIN_SURF_APPROX) EgtSetName( nStartExtrusionId, WIN_SRF_START) -- 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, WIN_DOWEL) - local nPrevOutlineId, nEndOutlineId = GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) + local sOutlineName = EgtGetName( nOutlineId) local sPrevOutlineName = EgtGetName( nPrevOutlineId) if StartJointType == WIN_PART_JNT.ANGLED then @@ -1717,30 +1144,27 @@ function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, n nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*') end elseif StartJointType == WIN_PART_JNT.SHORT then - -- recupero profondita' d'inizio e fine + -- recupero info di profondita' d'inizio e fine in base al profilo dello start local sStart = WIN_DWL_TOPPARASTART local sEnd = WIN_DWL_TOPPARAEND - if sOutlineName == WIN_BOTTOM or sPrevOutlineName == WIN_BOTTOM then + if sPrevOutlineName == WIN_BOTTOM then sStart = WIN_DWL_BOTTOMPARASTART sEnd = WIN_DWL_BOTTOMPARAEND end if sOutlineName == WIN_SPLIT then - local sStartType = EgtGetInfo( nStartProfileId, WIN_PRF_TYPE) - if ( sStartType and sStartType == WIN_RAIL_BOTTOM) then + local sStartProfileType = EgtGetInfo( nStartProfileId, WIN_PRF_TYPE) + if sStartProfileType == WIN_RAIL_BOTTOM then sStart = WIN_DWL_RAILBOTTOMPARASTART sEnd = WIN_DWL_RAILBOTTOMPARAEND - elseif sPrevOutlineName == WIN_SPLIT then - local sPrevProfileType = EgtGetInfo( nPrevOutlineId, WIN_PROFILETYPE) - if sPrevProfileType == WIN_SASH_HORIZONTAL then - sStart = WIN_DWL_HORIZONTALSPLITPARASTART - sEnd = WIN_DWL_HORIZONTALSPLITPARAEND - elseif sPrevProfileType == WIN_SASH_VERTICAL then - sStart = WIN_DWL_VERTICALSPLITPARASTART - sEnd = WIN_DWL_VERTICALSPLITPARAEND - else -- sProfileType == WIN_FRAME_SPLIT - sStart = WIN_DWL_SPLITPARASTART - sEnd = WIN_DWL_SPLITPARAEND - end + elseif sStartProfileType == WIN_SASH_HORIZONTAL then + sStart = WIN_DWL_HORIZONTALSPLITPARASTART + sEnd = WIN_DWL_HORIZONTALSPLITPARAEND + elseif sStartProfileType == WIN_SASH_VERTICAL then + sStart = WIN_DWL_VERTICALSPLITPARASTART + sEnd = WIN_DWL_VERTICALSPLITPARAEND + elseif sStartProfileType == WIN_FRAME_SPLIT or sStartProfileType == WIN_SASH_SPLIT then + sStart = WIN_DWL_SPLITPARASTART + sEnd = WIN_DWL_SPLITPARAEND end end -- ciclo sui fori trovati @@ -1763,7 +1187,6 @@ function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, n 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 @@ -1779,6 +1202,8 @@ function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, n nOrigDowelId = EgtGetNextName( nOrigDowelId, WIN_DOWEL .. '*') end end + + -- c) END PROFILE -- posiziono il profilo End local nRefEndProfileId = EgtGetFirstNameInGroup( nEndProfileId, WIN_REF) local b3RefEndProfile = EgtGetBBoxGlob(nRefEndProfileId, GDB_BB.STANDARD) @@ -1889,26 +1314,23 @@ function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, n -- recupero profondita' d'inizio e fine local sStart = WIN_DWL_TOPPARASTART local sEnd = WIN_DWL_TOPPARAEND - if sOutlineName == WIN_BOTTOM or sEndOutlineName == WIN_BOTTOM then + if sEndOutlineName == WIN_BOTTOM then -- sOutlineName == WIN_BOTTOM or sEndOutlineName == WIN_BOTTOM then sStart = WIN_DWL_BOTTOMPARASTART sEnd = WIN_DWL_BOTTOMPARAEND end if sOutlineName == WIN_SPLIT then - local sEndType = EgtGetInfo( nEndProfileId, WIN_PRF_TYPE) - if ( sEndType and sEndType == WIN_RAIL_BOTTOM) then + local sEndProfileType = EgtGetInfo( nEndProfileId, WIN_PRF_TYPE) + if sEndProfileType == WIN_RAIL_BOTTOM then sStart = WIN_DWL_RAILBOTTOMPARASTART sEnd = WIN_DWL_RAILBOTTOMPARAEND - elseif sEndOutlineName == WIN_SPLIT then - local sEndProfileType = EgtGetInfo( nEndOutlineId, WIN_PROFILETYPE) - if sEndProfileType == WIN_SASH_HORIZONTAL then - -- non faccio nulla perche' e' uguale al top - elseif sEndProfileType == WIN_SASH_VERTICAL then - sStart = WIN_DWL_VERTICALSPLITPARASTART - sEnd = WIN_DWL_VERTICALSPLITPARAEND - else -- sProfileType == WIN_FRAME_SPLIT - sStart = WIN_DWL_SPLITPARASTART - sEnd = WIN_DWL_SPLITPARAEND - end + elseif sEndProfileType == WIN_SASH_HORIZONTAL then + -- non faccio nulla perche' e' uguale al top + elseif sEndProfileType == WIN_SASH_VERTICAL then + sStart = WIN_DWL_VERTICALSPLITPARASTART + sEnd = WIN_DWL_VERTICALSPLITPARAEND + elseif sEndProfileType == WIN_FRAME_SPLIT or sEndProfileType == WIN_SASH_SPLIT then -- sProfileType == WIN_FRAME_SPLIT + sStart = WIN_DWL_SPLITPARASTART + sEnd = WIN_DWL_SPLITPARAEND end end -- ciclo sui fori trovati @@ -1950,8 +1372,346 @@ function WinCalculate.MakeSolidByExtrusion(nGeoId, nOutlineId, nMainProfileId, n EgtErase( { nExtrCopyId}) end +--------------------------------------------------------------------- +-- funzione che crea il solido del pezzo del telaio +local function CalcFrameSolid( nPartId, nOutlineId, nGeoId, nOutlineLayerId, bBottomRail) + + -- 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 di profilo + local nProfileType = GetOutlineProfileType( nOutlineId, bBottomRail) + + -- recupero outline precedente e successivo + local nPrevOutlineId, nNextOutlineId = GetPrevNextOutline( nProfileType, nOutlineId, nOutlineLayerId) + + -- recupero profili e controprofili + local nOrigMainProfileId = GetOutlineProfileId( nOutlineId, bBottomRail) + -- se il tipo corrente è split il pezzo va tagliato con il bottomrail, altrimenti con il bottom + local nOrigStartProfileId = GetOutlineProfileId( nPrevOutlineId, nProfileType == WIN_PRF.SPLIT) + local nOrigEndProfileId = GetOutlineProfileId( nNextOutlineId, nProfileType == WIN_PRF.SPLIT) + + -- creo copie di profilo e controprofili + local nMainProfileId = EgtCopy( nOrigMainProfileId, nFrameProfileLayerId) + local sMainProfileType = EgtGetName( nMainProfileId) + EgtSetInfo( nMainProfileId, WIN_PRF_TYPE, sMainProfileType) + EgtSetName( nMainProfileId, WIN_PRF_MAIN) + local nStartProfileId = EgtCopy( nOrigStartProfileId, nFrameProfileLayerId) + local sStartProfileType = EgtGetName( nStartProfileId) + EgtSetInfo( nStartProfileId, WIN_PRF_TYPE, sStartProfileType) + EgtSetName( nStartProfileId, WIN_PRF_START) + local nEndProfileId = EgtCopy( nOrigEndProfileId, nFrameProfileLayerId) + local sEndProfileType = EgtGetName( nEndProfileId) + EgtSetInfo( nEndProfileId, WIN_PRF_TYPE, sEndProfileType) + EgtSetName( nEndProfileId, WIN_PRF_END) + + -- creo solido dai profili + MakeSolidByExtrusion( nGeoId, nOutlineId, nMainProfileId, nStartProfileId, nEndProfileId, nProfileType, nSolidLayerId) + end + +--------------------------------------------------------------------- +-- funzione che calcola l'ingombro dei pezzi del telaio e i loro solidi +local function 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) + 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 + + -- imposto nome + local sName = EgtGetName( nOutlineId) + if bBottomRail then + sName = WIN_BOTTOMRAIL + end + EgtSetName( nPartId, sName) + + -- imposto colore + if sName == WIN_BOTTOM or sName == WIN_TOP or bBottomRail then + EgtSetColor( nPartId, Color3d( 204, 102, 0)) + elseif sName == WIN_RIGHT or sName == WIN_LEFT 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 = CalcFrameGeo( nPartId, nOutlineId, nOutlineLayerId, bBottomRail) + -- disegno solido + if bCalcSolid then + CalcFrameSolid( nPartId, nOutlineId, nGeoId, nOutlineLayerId, bBottomRail) + end + elseif nAreaType == WIN_AREATYPES.FILL then + -- disegno ingombro + local nGeoLayerId = CalcFillGeo( nPartId, nOutlineLayerId) + -- disegno solido + if bCalcSolid then + CalcFillSolid(nPartId, nOutlineLayerId, nGeoLayerId) + end + end +end + + +--------------------------------------------------------------------- +---------------------------- STRIP ---------------------------------- +--------------------------------------------------------------------- +-- funzione che restitutisce lo Strip piu' vicino +local function GetStripNearestToOutline( nProfileId, nOutlineId) + -- recupero strip + local ptStartOutline = EgtMP( nOutlineId) + local vtStartOutline = EgtSV( nOutlineId) + local nStartStripId = EgtGetFirstNameInGroup( nProfileId, WIN_STRIP) + if not nStartStripId then + local nStripMinDistId + local dMinDistance + local nStripId = EgtGetFirstNameInGroup( nProfileId, WIN_STRIP .. '*') + 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, WIN_STRIP .. '*') + end + nStartStripId = nStripMinDistId + end + return nStartStripId +end + +--------------------------------------------------------------------- +-- funzione che crea le linee di contorno massima e minima degli strip +local function CreateStripGuideLines( nOutlineId, nStripId, nProfileId, nSolidLayerId) + + -- recupero il frame del profilo + local nProfileFrameId = EgtGetFirstNameInGroup( nProfileId, WIN_SECTIONFRAME) + local frProfile = EgtFR( nProfileFrameId, 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 vtE = EgtEV( nOutlineId) + local bMainInvertOffset = AreSameVectorApprox( frProfile:getVersZ(), vtE) + -- calcolo BBox + local b3MainStrip = EgtGetBBoxRef( nStripId, GDB_BB.STANDARD, frProfile, GDB_RT.GLOB) + -- calcolo offset per Strip + local dMainStripMinDelta = EgtIf( bMainInvertOffset, - b3MainStrip:getMax():getX(), b3MainStrip:getMin():getX()) + local dMainStripMaxDelta = EgtIf( bMainInvertOffset, - b3MainStrip:getMin():getX(), b3MainStrip:getMax():getX()) + + local nStripMinOffsetId = EgtCopy( nOutlineId, nSolidLayerId) + EgtOffsetCurve( nStripMinOffsetId, dMainStripMinDelta) + local nStripMaxOffsetId = EgtCopy( nOutlineId, nSolidLayerId) + EgtOffsetCurve( nStripMaxOffsetId, dMainStripMaxDelta) + + return nStripMinOffsetId, nStripMaxOffsetId + +end + +--------------------------------------------------------------------- +-- funzione che crea gli Strip +local function CreateStripFromOutline( nAreaId, nOutlineId) + + -- recupero il pezzo associato ( prendendo quello di bottomrail se esiste) + local nPartId = EgtGetInfo( nOutlineId, WIN_BOTTOMRAIL, 'i') or EgtGetInfo( nOutlineId, WIN_REF_PART, 'i') + -- recupero layer per solido e per profili di estrusione + local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) + local nMainProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) + + -- recupero il pezzo precedente ( prendendo eventualmente quello di bottomrail) + local nOutlineLayerId = EgtGetParent( nOutlineId) + local nPrevOutlineId = EgtGetPrev( nOutlineId) + if not nPrevOutlineId then + nPrevOutlineId = EgtGetLastInGroup( nOutlineLayerId) + end + local nPrevPartId = EgtGetInfo( nPrevOutlineId, WIN_BOTTOMRAIL, 'i') or EgtGetInfo( nPrevOutlineId, WIN_REF_PART) + local nPrevProfileLayerId = EgtGetFirstNameInGroup( nPrevPartId, WIN_PROFILE) + + -- recupero il pezzo successivo ( prendendo eventualmente quello di bottomrail) + local nNextOutlineId = EgtGetNext( nOutlineId) + if not nNextOutlineId then + nNextOutlineId = EgtGetFirstInGroup( nOutlineLayerId) + end + local nNextPartId = EgtGetInfo( nNextOutlineId, WIN_BOTTOMRAIL, 'i') or EgtGetInfo( nNextOutlineId, WIN_REF_PART) + local nNextProfileLayerId = EgtGetFirstNameInGroup( nNextPartId, WIN_PROFILE) + + -- recupero profilo e controprofili + local nMainProfileId = EgtGetFirstNameInGroup( nMainProfileLayerId, WIN_PRF_MAIN) + local nStartProfileId = EgtGetFirstNameInGroup( nPrevProfileLayerId, WIN_PRF_MAIN) + local nEndProfileId = EgtGetFirstNameInGroup( nNextProfileLayerId, WIN_PRF_MAIN) + + -- a) estrudo il fermavetro + -- recupero guida Main + local nGuideId = EgtGetFirstNameInGroup( nSolidLayerId, WIN_MAINGUIDE) + -- recupero strip piu' vicino a prev outline + local nMainStripId = GetStripNearestToOutline( nMainProfileId, nPrevOutlineId, WIN_STRIP) + -- estrudo MainStrip + local nMainStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nMainStripId, nGuideId, false, WIN_SURF_APPROX) + + -- b) taglio con start + -- recupero strip dello start piu' vicino ad outline + local nStartStripId = GetStripNearestToOutline( nStartProfileId, nOutlineId, WIN_STRIP) + + -- disegno guida start per lo strip trovando le intersezioni degli outline minimi e massimi tra MainStrip e StartStrip + local nMainStripMinOffsetId, nMainStripMaxOffsetId = CreateStripGuideLines( nOutlineId, nMainStripId, nMainProfileId, nSolidLayerId) + local nStartStripMinOffsetId, nStartStripMaxOffsetId = CreateStripGuideLines( nPrevOutlineId, nStartStripId, nStartProfileId, nSolidLayerId) + local ptStripMinStart = EgtIP( nMainStripMinOffsetId, nStartStripMinOffsetId, EgtSP( nMainStripMinOffsetId)) + local ptStripMaxStart = EgtIP( nMainStripMaxOffsetId, nStartStripMaxOffsetId, EgtSP( nMainStripMaxOffsetId)) + local nStartStripGuideId = EgtLine( nSolidLayerId, ptStripMinStart, ptStripMaxStart) + EgtExtendCurveStartByLen( nStartStripGuideId, 10) + EgtExtendCurveEndByLen( nStartStripGuideId, 10) + + -- estrudo Strip start + local nStartProfileFrameId = EgtGetFirstNameInGroup( nStartProfileId, WIN_SECTIONFRAME) + local frStartProfile = EgtFR( nStartProfileFrameId, GDB_ID.ROOT) + local nRefStartProfileId = EgtGetFirstNameInGroup( nStartProfileId, WIN_REF) + local b3RefStartProfile = EgtGetBBoxRef( nRefStartProfileId, GDB_BB.STANDARD, frStartProfile) + local nStartStripProfileId = EgtLine( nStartProfileId, ptStripMinStart, ptStripMinStart - Z_AX() * b3RefStartProfile:getDimY(), GDB_RT.GLOB) + EgtInvertCurve( nStartStripProfileId) + local nStartStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nStartStripProfileId, nStartStripGuideId, false, WIN_SURF_APPROX) + + -- taglio con main + local nStripExtrCopyId = EgtCopy( nMainStripExtrusionId, nSolidLayerId) + EgtSurfTmCut( nMainStripExtrusionId, nStartStripExtrusionId, true, false) + EgtSurfTmCut( nStartStripExtrusionId, nStripExtrCopyId, true, false) + + -- c) taglio con end + -- recupero strip piu' vicino ad outline + local nEndStripId = GetStripNearestToOutline( nEndProfileId, nOutlineId, WIN_STRIP) + + -- disegno guida end per lo strip trovando le intersezioni degli outline minimi e massimi tra MainStrip ed EndStrip + local nEndStripMinOffsetId, nEndStripMaxOffsetId = CreateStripGuideLines( nNextOutlineId, nEndStripId, nEndProfileId, nSolidLayerId) + local ptStripMinEnd = EgtIP( nMainStripMinOffsetId, nEndStripMinOffsetId, EgtSP( nMainStripMinOffsetId)) + local ptStripMaxEnd = EgtIP( nMainStripMaxOffsetId, nEndStripMaxOffsetId, EgtSP( nMainStripMaxOffsetId)) + local nEndStripGuideId = EgtLine( nSolidLayerId, ptStripMinEnd, ptStripMaxEnd) + EgtExtendCurveStartByLen( nEndStripGuideId, 10) + EgtExtendCurveEndByLen( nEndStripGuideId, 10) + EgtInvertCurve(nEndStripGuideId) + + -- estrudo Strip end + local nEndProfileFrameId = EgtGetFirstNameInGroup( nEndProfileId, WIN_SECTIONFRAME) + local frEndProfile = EgtFR( nEndProfileFrameId, GDB_ID.ROOT) + local nRefEndProfileId = EgtGetFirstNameInGroup( nEndProfileId, WIN_REF) + local b3RefEndProfile = EgtGetBBoxRef(nRefEndProfileId, GDB_BB.STANDARD, frEndProfile) + local nEndStripProfileId = EgtLine( nEndProfileId, ptStripMinEnd, ptStripMinEnd - Z_AX() * b3RefEndProfile:getDimY(), GDB_RT.GLOB) + EgtInvertCurve( nEndStripProfileId) + local nEndStripExtrusionId = EgtSurfTmSwept( nSolidLayerId, nEndStripProfileId, nEndStripGuideId, false, WIN_SURF_APPROX) + + -- taglio con main + EgtSurfTmCut( nMainStripExtrusionId, nEndStripExtrusionId, true, false) + EgtSurfTmCut( nEndStripExtrusionId, nStripExtrCopyId, true, false) + + EgtErase( nStripExtrCopyId) +end + +---------------------------------------------------------------------------------- +------------------------------- SPLIT DOWELS ------------------------------------- +---------------------------------------------------------------------------------- +function WinCalculate.AddSplitDowelToParts( nAreaId) + -- se non ho calcolato i solidi, esco + if not bCalcSolid then + return + end + -- recupero tipo di area + local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') + if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then + -- recupero pezzi outline + local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) + local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) + while nOutlineId do + WinCalculate.AddSplitDowelToExtrusion( nOutlineId, nAreaType, false) + -- 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.AddSplitDowelToExtrusion( nOutlineId, nAreaType, true) + end + end + nOutlineId = EgtGetNext( nOutlineId) + end + 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.AddSplitDowelToExtrusion( nSplitId, nAreaType, false) + end + end + end + -- verifico se ci sono aree + local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') + while nChildAreaId do + -- lancio costruzione pezzi di quell'area + WinCalculate.AddSplitDowelToParts( nChildAreaId) + nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*') + end +end + +---------------------------------------------------------------------------------- -- funzione che calcola intersezione, geometrie e superfici dei dowel degli split -function CalSplitDowel( nSplitLayerId, nOutlineId, nProfileFrameLayerId, nFrameProfileLayerId, nProfileType, nPartId, nSolidLayerId) +local function CalSplitDowel( nSplitLayerId, nOutlineId, nProfileFrameLayerId, nFrameProfileLayerId, nProfileType, nPartId, nSolidLayerId) local nSplitId = EgtGetFirstInGroup( nSplitLayerId) -- se presenti, verifico se intersecano l'outline che sto analizzando @@ -1961,6 +1721,10 @@ function CalSplitDowel( nSplitLayerId, nOutlineId, nProfileFrameLayerId, nFrameP end -- se interseca, recupero il profilo dello split local sSplitProfileType = EgtGetInfo( nSplitId, WIN_PROFILETYPE) + if not sSplitProfileType then + return + end + local nOrigSplitProfileId = EgtGetFirstNameInGroup( nProfileFrameLayerId, sSplitProfileType) -- creo copia del profilo local nSplitProfileId = EgtCopy( nOrigSplitProfileId, nFrameProfileLayerId) @@ -2055,8 +1819,9 @@ function CalSplitDowel( nSplitLayerId, nOutlineId, nProfileFrameLayerId, nFrameP end end +---------------------------------------------------------------------------------- -- funzione ricorsiva che cerca gli split che possono dare origine a dei dowel -function VerifyDowelArea( nAreaLayerId, nOutlineId, nPartId, nProfileType, nOrigAreaType) +local function VerifyDowelArea( nAreaLayerId, nOutlineId, nPartId, nProfileType, nOrigAreaType) --EgtSaveFile('c://Temp//DowelSplit.nge') -- recupero profilo local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) @@ -2091,6 +1856,7 @@ function VerifyDowelArea( nAreaLayerId, nOutlineId, nPartId, nProfileType, nOrig end end +---------------------------------------------------------------------------------- -- funzione che posiziona i fori delle spine degli split, li estrude e crea il solido function WinCalculate.AddSplitDowelToExtrusion(nOutlineId, nAreaType, bIsBottomRail) -- ricavo tipo dal @@ -2131,537 +1897,102 @@ function WinCalculate.AddSplitDowelToExtrusion(nOutlineId, nAreaType, bIsBottomR end -- verifico la presenza di eventuali Split VerifyDowelArea( nAreaLayerId, nOutlineId, nPartId, nProfileType, nAreaType) - 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') - local nLastPrevSouId = nPrevSouId - while nPrevSouId and nPrevSouType == WIN_AREATYPES.SPLIT do - nPrevSouId = EgtGetInfo( nPrevSouId, WIN_SOU) - if nPrevSouId and nPrevSouId ~= GDB_ID.NULL then - nLastPrevSouId = nPrevSouId - nPrevSouAreaId = EgtGetParent( EgtGetParent( nPrevSouId)) - nPrevSouType = EgtGetInfo( nPrevSouAreaId, WIN_AREATYPE, 'i') - end - end - if not nPrevSouId then - nPrevSouId = nLastPrevSouId - end - nPrevOutlineId = nPrevSouId - local nNextSouId = nNextOutlineId - local nNextSouAreaId = EgtGetParent( EgtGetParent( nNextSouId)) - local nNextSouType = EgtGetInfo( nNextSouAreaId, WIN_AREATYPE, 'i') - local nLastNextSouId = nNextSouId - while nNextSouId and nNextSouType == WIN_AREATYPES.SPLIT do - nNextSouId = EgtGetInfo( nNextSouId, WIN_SOU) - if nNextSouId and nNextSouId ~= GDB_ID.NULL then - nLastNextSouId = nNextSouId - nNextSouAreaId = EgtGetParent( EgtGetParent( nNextSouId)) - nNextSouType = EgtGetInfo( nNextSouAreaId, WIN_AREATYPE, 'i') - end - end - if not nNextSouId then - nNextSouId = nLastNextSouId - 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) - local sMainProfileType = EgtGetName( nMainProfileId) - EgtSetInfo( nMainProfileId, WIN_PRF_TYPE, sMainProfileType) - EgtSetName( nMainProfileId, WIN_PRF_MAIN) - nStartProfileId = EgtCopy( nOrigStartProfileId, nFrameProfileLayerId) - local sStartProfileType = EgtGetName( nStartProfileId) - EgtSetInfo( nStartProfileId, WIN_PRF_TYPE, sStartProfileType) - EgtSetName( nStartProfileId, WIN_PRF_START) - nEndProfileId = EgtCopy( nOrigEndProfileId, nFrameProfileLayerId) - local sEndProfileType = EgtGetName( nEndProfileId) - EgtSetInfo( nEndProfileId, WIN_PRF_TYPE, sEndProfileType) - 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') +--------------------------------------------------------------------- +------------------------- FUNZIONI ---------------------------------- +--------------------------------------------------------------------- +-- funzione che cicla ricorsivamente sulla struttura per creare tutti i pezzi della finestra +function WinCalculate.CreatePartFromArea( nAreaId) + + -- assengo il tipo di profilo alle curve del base outline + CalcProfileType(nAreaId) + + -- calcolo outline a partire dal base outline + CalculateOutlineFromAreaOutline( nAreaId) + -- 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 + local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') + if nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH then + -- creo pezzi per ogni outline + local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) + local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) + while nOutlineId do + -- creo pezzo + CreatePartFromOutline( nAreaId, nOutlineId) + -- se di tipo bottom verifico se ha bottomrail + local sName = EgtGetName( nOutlineId) + if sName == WIN_BOTTOM then + local bBottomRail = EgtGetInfo( nOutlineLayerId, WIN_BOTTOMRAIL, 'b') or false + if bBottomRail then + CreatePartFromOutline( nAreaId, nOutlineId, true) + end + end + nOutlineId = EgtGetNext( nOutlineId) + end + elseif nAreaType == WIN_AREATYPES.FILL then + -- creo riempimento + CreatePartFromOutline( nAreaId) 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) + + -- verifico se c'e' uno split da realizzare + local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) + if nSplitLayerId then + local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL + -- se split non è di tipo french ha un pezzo associato + if nSplitType ~= WIN_SPLITTYPES.FRENCH then + local nSplitId = EgtGetFirstInGroup( nSplitLayerId) + if nSplitId then + -- creo pezzo split + CreatePartFromOutline( nAreaId, nSplitId) 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)) + 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 + -- è uguale al codice sotto per area child di tipo fill??? + local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) + local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) + while nOutlineId do + 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 + CreateStripFromOutline( nAreaId, nOutlineId) + nOutlineId = EgtGetNext( nOutlineId) + end + end + end 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 + -- verifico se ci sono sotto-aree da realizzare + local nChildAreaId = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') + while nChildAreaId do + -- lancio costruzione pezzi di quell'area + WinCalculate.CreatePartFromArea( nChildAreaId) + nChildAreaId = EgtGetNextName( nChildAreaId, WIN_AREA .. '*') 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 @@ -2691,6 +2022,7 @@ function WinCalculate.PositionPart(nPartId) EgtChangeGroupFrame( nPartId, frStart) end +--------------------------------------------------------------------- -- funzione che assembla i pezzi function WinCalculate.AssembleFrame() local nBottomPartId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_BOTTOM)