diff --git a/Designing/WinConst.lua b/Designing/WinConst.lua index d6e0798..7182fa9 100644 --- a/Designing/WinConst.lua +++ b/Designing/WinConst.lua @@ -181,12 +181,12 @@ WIN_PART_DIM = 'PartDim' WIN_SOU = 'SOU' WIN_CHILD = 'CHILD' WIN_COPY = 'COPY' +WIN_SOU_OUTLINE = 'SouOutline' WIN_REF_OUTLINE = 'OutlineRef' WIN_REF_PART = 'PartRef' WIN_REF_BOTTOMRAIL_PART = 'BottomRailPartRef' WIN_PREV_OUTLINES = 'PrevOutlines' WIN_NEXT_OUTLINES = 'NextOutlines' -WIN_REF_SPLIT = 'RefSplit' WIN_INV_SPLIT = 'InvSplit' WIN_CRV_ON_FRENCH_SPLIT = 'OutlineOnFrenchSplit' WIN_SPLIT_STARTINTERS = 'SplitStartInters' @@ -201,9 +201,10 @@ WIN_AREA_PROFILES = 'AreaProfiles' WIN_MEASURE_VALUE = 'MeasureValue' WIN_GRIDSPLIT_ORDER = 'GridSplitOrder' WIN_SPLIT_POSITION = 'SplitPosition' -WIN_SPLIT_REF_DIM = 'SplitRefDim' WIN_SPLIT_OFFS = 'SplitOffs' WIN_GRID_SPLIT = 'GridSplit' +WIN_DAYLIGHT_MEASURE = 'DaylightMeasure' + -- PROFILI WIN_PROFILE = 'Profile' diff --git a/Designing/WinJWDConst.lua b/Designing/WinJWDConst.lua index 5fe3b19..e83c4ec 100644 --- a/Designing/WinJWDConst.lua +++ b/Designing/WinJWDConst.lua @@ -32,6 +32,7 @@ JWD_VALUE = 'Value' JWD_ID_GROUP = 'GroupId' JWD_ID_SASH = 'SashId' JWD_MEASURE_TYPE = 'MeasureType' +JWD_MEASURE_DAYLIGHT = 'IsDimensionLight' JWD_ELEMENT_DIMENSION = 'ElementDimensionList' JWD_FRAME_SHAPE = 'Shape' diff --git a/Designing/WinLib/WinCalculate.lua b/Designing/WinLib/WinCalculate.lua index ef3e0bb..89ef839 100644 --- a/Designing/WinLib/WinCalculate.lua +++ b/Designing/WinLib/WinCalculate.lua @@ -251,16 +251,20 @@ local function AddExtension( nCrvId, nRefCrvId) local dParS = EgtCurveParamAtPoint( nCrvId, EgtSP( nRefCrvId), 100 * GEO.EPS_SMALL) if not dParS then local dParTrim = EgtCurveParamAtPoint( nRefCrvId, EgtSP( nCrvId), 100 * GEO.EPS_SMALL) - local nNewCrv = EgtCopyParamRange( nRefCrvId, 0, dParTrim, EgtGetParent( nCrvId)) - EgtAddCurveCompoCurve( nCrvId, nNewCrv, true, false) + if dParTrim then + local nNewCrv = EgtCopyParamRange( nRefCrvId, 0, dParTrim, EgtGetParent( nCrvId)) + EgtAddCurveCompoCurve( nCrvId, nNewCrv, true, false) + end end local dParE = EgtCurveParamAtPoint( nCrvId, EgtEP( nRefCrvId), 100 * GEO.EPS_SMALL) if not dParE then local dParTrim = EgtCurveParamAtPoint( nRefCrvId, EgtEP( nCrvId), 100 * GEO.EPS_SMALL) - local _, dE = EgtCurveDomain( nRefCrvId) - local nNewCrv = EgtCopyParamRange( nRefCrvId, dParTrim, dE, EgtGetParent( nCrvId)) - EgtAddCurveCompoCurve( nCrvId, nNewCrv) + if dParTrim then + local _, dE = EgtCurveDomain( nRefCrvId) + local nNewCrv = EgtCopyParamRange( nRefCrvId, dParTrim, dE, EgtGetParent( nCrvId)) + EgtAddCurveCompoCurve( nCrvId, nNewCrv) + end end end @@ -405,33 +409,9 @@ local function CalcIntersectionRegion( vCrvs, nGrp) return nSurfId end ---------------------------------------------------------------------- --- Gestione delle curve superflue in TrimOrderedCurves : le modalità di trattamento sono indicate da nMode e sono le seguenti --- 0/nil = curva eliminata ( caso standard) --- 1 = curva eliminata rimuovendo la corrispondenza dalle info della curva di base outline da cui deriva ( se chiamata da outline) --- 2 = curva non viene eliminata ma viene settata info che indica di ignorarla ( se chiamata dal geo) -local function AdjustExtraCurvesForTrim( nCrvId, nSurfId, nMode) - - if not nMode or nMode == 0 then - EgtErase( nCrvId) - - elseif nMode == 1 then - -- rimuovo la info che riconduce alla curva che sto per eliminare dalla curva corrispondente del base outline - local nBaseOutline = EgtGetInfo( nCrvId, WIN_COPY, 'i') - EgtRemoveInfo( nBaseOutline, WIN_COPY) - -- elimino la curva - EgtErase( nCrvId) - - elseif nMode == 2 then - -- se la curva è fuori dalla regione non va eliminata ma viene settata info che indica di ignorarla - EgtSetInfo( nCrvId, WIN_GEO_EXTRA, true) - EgtSetStatus( nCrvId, GDB_ST.OFF) - end -end - --------------------------------------------------------------------- -- funzione che data una lista di curve ordinate e orientate le estende o le taglia per creare una curva chiusa -local function TrimOrderedCurves( vCrvs, nExtraCurvesMode, nSurfId) +local function TrimOrderedCurves( vCrvs, bDelete, nSurfId) local nGrpTmp = EgtGroup( GDB_ID.ROOT) EgtSetStatus( nGrpTmp, GDB_ST.OFF) @@ -509,8 +489,14 @@ local function TrimOrderedCurves( vCrvs, nExtraCurvesMode, nSurfId) for i = 1, #vCrvs do if not tabAss[vCrvs[i]] then - -- se non ha curve di bordo associate è extra curve da gestire in modo speciale - AdjustExtraCurvesForTrim( vCrvs[i], nSurfId, nExtraCurvesMode) + -- se non ha curve di bordo associate è curva extra da gestire in modo speciale + if bDelete then + EgtErase( vCrvs[i]) + else + -- se non va eliminata setto info che ricorda di gestirla in modo speciale + EgtSetInfo( vCrvs[i], WIN_GEO_EXTRA, true) + EgtSetStatus( vCrvs[i], GDB_ST.OFF) + end else local nCrvId @@ -587,28 +573,27 @@ local function GetOutlineProfileId( nOutlineId, bForceBottomRail, nBottomRail) return nMainProfileId end +--------------------------------------------------------------------- +-- funzione che restituisce l'outline non virtuale associato alla curva ( potrebbe anche essere la curva stessa) +local function GetNonVirtualOutline( nOutlineId) + + local nSouOutlineId = nOutlineId + local nAreaType = EgtGetInfo( EgtGetParent( EgtGetParent( nSouOutlineId)), WIN_AREATYPE, 'i') + while nAreaType ~= WIN_AREATYPES.FRAME and nAreaType ~= WIN_AREATYPES.SASH and EgtGetName( abs( nSouOutlineId)) ~= WIN_SPLIT do + nSouOutlineId = EgtGetInfo( abs( nSouOutlineId), WIN_SOU_OUTLINE, 'i') + local nAreaId = EgtGetParent( EgtGetParent( abs( nSouOutlineId))) + nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') + end + return nSouOutlineId +end + --------------------------------------------------------------------- -- funzione che recupera il pezzo associato ad un outline local function FindAssociatedPart( nOutlineId, bUseBottomRail) - local nCrvId = nOutlineId + -- ricavo la curva non virtuale associata ( ovvero la curva da cui deriva che ha un pezzo associato) + local nCrvId = abs( GetNonVirtualOutline( nOutlineId)) local nPartId = EgtGetInfo( nCrvId, WIN_REF_PART, 'i') - if not nPartId then - -- cerco la prima curva da cui deriva che ha un pezzo associato - -- recupero il base outline da cui deriva - local nBaseOutline = EgtGetInfo( nOutlineId, WIN_COPY, 'i') - nBaseOutline = EgtGetInfo( nBaseOutline, WIN_SOU, 'i') - while nBaseOutline and not nPartId do - -- verifico se ha un profilo associato ( e quindi un pezzo) - local sProfileType = EgtGetInfo( nBaseOutline, WIN_PROFILETYPE) - if sProfileType then - -- recupero l'outline associato - nCrvId = EgtGetInfo( nBaseOutline, WIN_COPY, 'i') - nPartId = EgtGetInfo( nCrvId, WIN_REF_PART, 'i') - end - nBaseOutline = EgtGetInfo( nBaseOutline, WIN_SOU, 'i') - end - end -- se serve bottomrail verifico se presente if bUseBottomRail then @@ -639,19 +624,20 @@ local function GetProfileCtrIn( nPrevOutlineId, nOutlineId, nPrevProfileId) local sPrevCtrIn = WIN_CTRIN -- gestione particolare del caso di split o cambio profilo if not EgtGetFirstNameInGroup( nPrevProfileId, sPrevCtrIn) then - - local nRefSplitId = EgtGetInfo( nPrevOutlineId, WIN_REF_SPLIT, 'i') - if nRefSplitId or EgtGetName( nPrevOutlineId) == WIN_SPLIT then - -- 1) split + + -- 1) split + if EgtGetName( nPrevOutlineId) == WIN_SPLIT then -- verifico da quale lato dello split originale si trova l'outline per decidere quale controprofilo considerare - local _, _, nSide = EgtPointCurveDistSide( EgtMP( nOutlineId), nRefSplitId or nPrevOutlineId, Z_AX()) + -- TODO si potrebbe considerare il segno di nPrevOutlineId ? + local _, _, nSide = EgtPointCurveDistSide( EgtMP( nOutlineId), nPrevOutlineId, Z_AX()) if nSide == 1 then sPrevCtrIn = WIN_CTRIN .. '1' -- dx else sPrevCtrIn = WIN_CTRIN .. '2' -- sx end + + -- 2) pezzo del telaio con cambio profilo else - -- 2) pezzo del telaio con cambio profilo -- il profilo da usare dipende dal pezzo corrente: se ha figli di tipo fill allora è legato alla parte fill del cambio profilo, se ha figli di tipo sash è legato alla parte sash, -- se ha entrambe le tipologie di figli allora è mixed split e va considerata la parte sash ( perchè è quella utilizzata per tagliare il pezzo) local vSashChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi') @@ -686,12 +672,7 @@ local function CreateProfileSurfById( nOutlineId, nProfileId, nSectionId, dExtra local dOffs = EgtGetInfo( nProfileId, WIN_RAILOFFS, 'd') EgtOffsetCurve( nGuideId, - dOffs) end - - -- verifico se necessaria inversione della guida nel caso sia curva "virtuale" ( ovvero in area null o split) che deriva da pezzo di split - if EgtExistsInfo( nOutlineId, WIN_INV_SPLIT) then - EgtInvertCurve( nGuideId) - end - + -- recupero il profilo da estrudere local nSectionRefId = EgtCopyGlob( nSectionId, nLayerId) @@ -818,13 +799,13 @@ end --------------------------------------------------------------------- -- funzione che identifica il tipo di split ( mullion, mixed, ...) -local function GetSplitType( nSplitId, nSplitLayerId) +local function GetSplitType( nSplitId, nAreaId) - local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') - -- la tipologia è salvata nel layer solo se si tratta di un french split, negli altri casi va calcolata + local nSplitType = EgtGetInfo( nAreaId, WIN_SPLITTYPE, 'i') + -- la tipologia è salvata nell'area solo se si tratta di un french split, negli altri casi va calcolata if not nSplitType then -- controllo se è dentro anta o telaio - local nParentAreaId = EgtGetParent( nSplitLayerId) + local nParentAreaId = nAreaId local nParentAreaType = EgtGetInfo( nParentAreaId, WIN_AREATYPE, 'i') or WIN_AREATYPES.NULL while nParentAreaId and nParentAreaType ~= WIN_AREATYPES.SASH and nParentAreaType ~= WIN_AREATYPES.FRAME do nParentAreaId = EgtGetParent( nParentAreaId) @@ -856,14 +837,131 @@ local function GetSplitType( nSplitId, nSplitLayerId) end --------------------------------------------------------------------- -local function FindAdjacentSashType( nSplitId, nCurrId) - -- recupero l'altro child dello split +local function FindAdjacentSashType( nSplitId, nCurrType) + -- i figli della curva nSouId sono base outlines e non posso sapere a quali outlines corrispondono quindi per capire se sto guardando il figlio + -- corretto controllo se il tipo di anta è lo stesso del corrente oppure no local vSplitChildren = EgtGetInfo( nSplitId, WIN_CHILD, 'vi') - local nAdjChild = EgtIf( vSplitChildren[1] == nCurrId, vSplitChildren[2], vSplitChildren[1]) - -- recupero la sua tipologia dalla sua area - local nAdjSash = EgtGetParent( EgtGetParent( nAdjChild)) - local nAdjType = EgtGetInfo( nAdjSash, WIN_SASHTYPE, 'i') - return nAdjType + local nAdjSashType = EgtGetInfo( EgtGetParent( EgtGetParent( vSplitChildren[1])), WIN_SASHTYPE, 'i') + if nAdjSashType == nCurrType then + -- se il tipo è lo stesso allora devo guardare l'altro figlio dello split + nAdjSashType = EgtGetInfo( EgtGetParent( EgtGetParent( vSplitChildren[2])), WIN_SASHTYPE, 'i') + end + return nAdjSashType +end + +--------------------------------------------------------------------- +-- funzione che calcola i profili delle ante sulle curve di outline ( non di base outline) +local function CalcSashProfiles( vOutlines, nAreaId) + + local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL + local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0 + + -- imposto profili sash + for i = 1, #vOutlines do + local nOutlineId = vOutlines[i] + local sName = EgtGetName( nOutlineId) + + -- se non è definita tipologia + if nSashType == WIN_SASHTYPES.NULL then + if sName == WIN_BOTTOM then + if nBottomRail == 0 then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM) + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL_BOTTOM) + end + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) + end + + else + -- verifico se deriva da una curva di split french ( e quindi deve avere profilo speciale e.g. battente/ricevente) + local nSouId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i')) + local nSplitType = EgtGetInfo( nSouId, WIN_SPLITTYPE, 'i') + if nSplitType == WIN_SPLITTYPES.FRENCH then + + EgtSetInfo( nOutlineId, WIN_CRV_ON_FRENCH_SPLIT, true) + + -- a) battente/ricevente + if nSashType == WIN_SASHTYPES.ACTIVE then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE) + elseif nSashType == WIN_SASHTYPES.INACTIVE then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_INACTIVE) + elseif nSashType == WIN_SASHTYPES.ACTIVE_OUT or nSashType == WIN_SASHTYPES.INACTIVE_OUT then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_OUT) + elseif nSashType == WIN_SASHTYPES.ACTIVE_IN then + -- scelgo il profilo in base al tipo dell'anta adiacente + local nAdjSashType = FindAdjacentSashType( nSouId, WIN_SASHTYPES.ACTIVE_IN) + if nAdjSashType == WIN_SASHTYPES.ACTIVE_OUT then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_IN) + else -- adiacente è inactive + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE) + end + elseif nSashType == WIN_SASHTYPES.INACTIVE_IN then + -- scelgo il profilo in base al tipo dell'anta adiacente + local nAdjSashType = FindAdjacentSashType( nSouId, WIN_SASHTYPES.INACTIVE_IN) + if nAdjSashType == WIN_SASHTYPES.INACTIVE_OUT then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_IN) + else -- adiacente è active + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_INACTIVE) + end + + -- b) alzante scorrevole + elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then + local nAdjSashType = FindAdjacentSashType( nSouId, WIN_SASHTYPES.SLIDE_MOVABLE) + if nAdjSashType == WIN_SASHTYPES.SLIDE_MOVABLE then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_ACTIVE_IN) + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_ACTIVE) + end + elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_INACTIVE) + elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_INACTIVE) + end + + else + -- a) alzante scorrevole + if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then + if sName == WIN_BOTTOM then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_BOTTOM) + elseif sName == WIN_TOP then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_TOP) + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_SIDE) + end + elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then + if sName == WIN_BOTTOM then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_BOTTOM) + elseif sName == WIN_TOP then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_TOP) + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_SIDE) + end + elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then + if sName == WIN_BOTTOM then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_BOTTOM) + elseif sName == WIN_TOP then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_TOP) + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_SIDE) + end + + -- b) standard + else + if sName == WIN_BOTTOM then + -- verifico se bottomrail + if nBottomRail == 0 then + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM) + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL_BOTTOM) + end + else + EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) + end + end + end + end + end end --------------------------------------------------------------------- @@ -990,7 +1088,7 @@ local function CalcProfileType( nAreaId) local vSplitIds = EgtGetAllInGroup( nSplitLayerId) for i = 1, #vSplitIds do -- ricavo il tipo di split - local nSplitType = GetSplitType( vSplitIds[i], nSplitLayerId) + local nSplitType = GetSplitType( vSplitIds[i], nAreaId) if nSplitType == WIN_SPLITTYPES.MULLION then -- verifico direzione per assengare il profilo @@ -1022,130 +1120,29 @@ local function CalcProfileType( nAreaId) -- se si trova a destra, lo split va invertito if nSide == 1 then EgtInvertCurve( vSplitIds[i]) - -- scambio le info di intersezione - local vStartInters = EgtGetInfo( vSplitIds[i], WIN_SPLIT_STARTINTERS, 'vi') - local vEndInters = EgtGetInfo( vSplitIds[i], WIN_SPLIT_ENDINTERS, 'vi') - EgtSetInfo( vSplitIds[i], WIN_SPLIT_STARTINTERS, vEndInters) - EgtSetInfo( vSplitIds[i], WIN_SPLIT_ENDINTERS, vStartInters) + EgtSetInfo( vSplitIds[i], WIN_INV_SPLIT, true) end end -- se split di tipo french non ha profilo assegnato perchè non ha un pezzo associato end + -- NULL + elseif nAreaType == WIN_AREATYPES.NULL then + -- le aree null sono aree virtuali quindi non hanno pezzi ( e dunque profili) associati + -- SASH elseif nAreaType == WIN_AREATYPES.SASH then - -- verifico tipologia di anta ( battente, ricevente, alzante scorrevole) - local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL - -- verifico se bottomrail - local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') or 0 - -- imposto profili sash - local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) - local nOutlineId = EgtGetFirstInGroup( nOutlineLayerId) - while nOutlineId do - local sName = EgtGetName( nOutlineId) - - -- se non è definita tipologia - if nSashType == WIN_SASHTYPES.NULL then - if sName == WIN_BOTTOM then - if nBottomRail == 0 then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM) - else - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL_BOTTOM) - end - else - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) - end - - else - -- verifico se deriva da una curva di split ( e quindi deve avere profilo speciale e.g. battente/ricevente) - local nSouId = EgtGetInfo( nOutlineId, WIN_SOU, 'i') - if EgtGetName( nSouId) == WIN_SPLIT then - -- setto info sulla curva per ricordare che deriva da un french split - EgtSetInfo( nOutlineId, WIN_CRV_ON_FRENCH_SPLIT, true) - - -- a) battente/ricevente - if nSashType == WIN_SASHTYPES.ACTIVE then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE) - elseif nSashType == WIN_SASHTYPES.INACTIVE then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_INACTIVE) - elseif nSashType == WIN_SASHTYPES.ACTIVE_OUT or nSashType == WIN_SASHTYPES.INACTIVE_OUT then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_OUT) - elseif nSashType == WIN_SASHTYPES.ACTIVE_IN or nSashType == WIN_SASHTYPES.INACTIVE_IN then - -- devo verificare il tipo dell'anta adiacente - local nAdjSashType = FindAdjacentSashType( nSouId, nOutlineId) - if nSashType == WIN_SASHTYPES.ACTIVE_IN then - if nAdjSashType == WIN_SASHTYPES.ACTIVE_OUT then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_IN) - else -- adiacente è inactive - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_ACTIVE) - end - elseif nSashType == WIN_SASHTYPES.INACTIVE_IN then - if nAdjSashType == WIN_SASHTYPES.INACTIVE_OUT then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRENCH_IN) - else -- adiacente è active - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SASH_INACTIVE) - end - end - - -- b) alzante scorrevole - elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then - local nAdjSashType = FindAdjacentSashType( nSouId, nOutlineId) - if nAdjSashType == WIN_SASHTYPES.SLIDE_MOVABLE then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_ACTIVE_IN) - else - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_ACTIVE) - end - elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_INACTIVE) - elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_INACTIVE) - end + -- i profili verranno calcolati direttamente sulle curve di outline - else - -- a) alzante scorrevole - if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then - if sName == WIN_BOTTOM then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_BOTTOM) - elseif sName == WIN_TOP then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_TOP) - else - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLE_SIDE) - end - elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then - if sName == WIN_BOTTOM then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_BOTTOM) - elseif sName == WIN_TOP then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_TOP) - else - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_FIXED_SIDE) - end - elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then - if sName == WIN_BOTTOM then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_BOTTOM) - elseif sName == WIN_TOP then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_TOP) - else - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_SLIDE_MOVABLEBACK_SIDE) - end - - -- b) standard - else - if sName == WIN_BOTTOM then - -- verifico se bottomrail - if nBottomRail == 0 then - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_BOTTOM) - else - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_RAIL_BOTTOM) - end - else - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, WIN_FRAME_TOP) - end - end - end - end - nOutlineId = EgtGetNext( nOutlineId) + -- dimensioni + local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) + local vOutlineIds = EgtGetAllInGroup( nOutlineLayerId) + local vPartDim = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vi') or {} + for i = 1, #vOutlineIds do + EgtSetInfo( vOutlineIds[i], WIN_PART_DIM, vPartDim[i]) end end + end --------------------------------------------------------------------- @@ -1517,11 +1514,16 @@ end --------------------------------------------------------------------- local function CreatePartsFromOutlines( vOutlines, nAreaId, sName) - - local vPartsDim = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vd') or {} + local nBottomRail = EgtGetInfo( nAreaId, WIN_BOTTOMRAIL, 'i') + -- calcolo le giunzioni + local vJoints = EgtGetInfo( nAreaId, WIN_JOINTS, 'vi') + GetOutlineJoints( vOutlines, vJoints) + -- sistemo le dimensioni in modo che pezzi coinvolti da giunzione a bisettrice ( scelta o forzata) abbiano la stessa dimensione + -- TODO meglio correzione o segnalare errore? Nelle ante usi le dimensioni teoriche per posizionare gli split, se venissero cambiate i conti non tornano + local vPartsDim = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vd') or {} for i = 2, #vOutlines do local nStartJoint = EgtGetInfo( vOutlines[i], WIN_STARTJOINT, 'i') if nStartJoint == WIN_PART_JNT.ANGLED then @@ -1585,6 +1587,755 @@ end ---------------------------------------------------------------------------------- ------------------------------ CALCOLO OUTLINE --------------------------------- ---------------------------------------------------------------------------------- +local function GetPrevNextOutline( vOutlines, nOutlineLayerId) + + for i = 2, #vOutlines - 1 do + EgtSetInfo( vOutlines[i], WIN_PREV_OUTLINES, { vOutlines[i-1]}) + EgtSetInfo( vOutlines[i], WIN_NEXT_OUTLINES, { vOutlines[i+1]}) + end + -- gestione particolare per primo e ultimo + EgtSetInfo( vOutlines[1], WIN_PREV_OUTLINES, { vOutlines[#vOutlines]}) + EgtSetInfo( vOutlines[1], WIN_NEXT_OUTLINES, { vOutlines[2]}) + EgtSetInfo( vOutlines[#vOutlines], WIN_PREV_OUTLINES, { vOutlines[#vOutlines - 1]}) + EgtSetInfo( vOutlines[#vOutlines], WIN_NEXT_OUTLINES, { vOutlines[1]}) +end + + +------------------------------ NULL ------------------------------ +--------------------------------------------------------------------- +local function GetBorderRegions( nSplitId, nCompo, nAreaId) + + -- taglio il bordo in due in corrispondenza dello split + local nCrv1 = EgtCopyGlob( nCompo, nAreaId) + local nCrv2 = EgtCopyGlob( nCompo, nAreaId) + local dPar1 = EgtCurveParamAtPoint( nCompo, EgtSP( nSplitId), 100 * GEO.EPS_SMALL) + local dPar2 = EgtCurveParamAtPoint( nCompo, EgtEP( nSplitId), 100 * GEO.EPS_SMALL) + EgtTrimCurveStartEndAtParam( nCrv1, dPar2, dPar1) + EgtTrimCurveStartEndAtParam( nCrv2, dPar1, dPar2) + + -- aggiungo la curva di split al bordo per chiuderlo orientandola opportunamente + local nSplitId1 = EgtCopyGlob( nSplitId, nAreaId) + EgtAddCurveCompoCurve( nCrv1, nSplitId1) + local _, dParE1 = EgtCurveDomain( nCrv1) + EgtCurveCompoSetTempProp( nCrv1, dParE1 - 1, nSplitId) + + local nSplitId2 = EgtCopyGlob( nSplitId, nAreaId) + EgtInvertCurve( nSplitId2) + EgtAddCurveCompoCurve( nCrv2, nSplitId2) + local _, dParE2 = EgtCurveDomain( nCrv2) + EgtCurveCompoSetTempProp( nCrv2, dParE2 - 1, - nSplitId) + + -- se mixed split inverito le regioni finali vanno scambiate + local bInvert = EgtGetInfo( nSplitId, WIN_INV_SPLIT, 'b') or false + if bInvert then + return nCrv2, nCrv1 + else + return nCrv1, nCrv2 + end +end + +--------------------------------------------------------------------- +local function CalculateNullOutline( nCompoOutline, vSplitIds, vChildAreas) + + local nGrpTmp = EgtGroup( GDB_ID.ROOT) + + -- calcolo i bordi delle sottoregioni null tagliando il bordo complessivo dell'area di split con gli split + local vBorders = {} + local nCompoRef = nCompoOutline + for i = 1, #vSplitIds do + -- calcolo i bordi delle due regioni definite dallo split + local nCrv1, nCrv2 = GetBorderRegions( vSplitIds[i], nCompoRef, nGrpTmp) + table.insert( vBorders, nCrv1) + -- il secondo bordo è quello da suddividere con lo split successivo ( se esiste) + nCompoRef = nCrv2 + if i == #vSplitIds then + table.insert( vBorders, nCrv2) + end + end + + -- creo gli outline delle sottoaree a partire dai bordi calcolati + for i = 1, #vChildAreas do + + if vBorders[i] then + local nOutlineLayerId = EgtGroup( vChildAreas[i]) + EgtSetName( nOutlineLayerId, WIN_OUTLINE) + EgtSetStatus( nOutlineLayerId, GDB_ST.OFF) + EgtRelocateGlob( vBorders[i], nOutlineLayerId) + + -- dalla curva di bordo ricavo le sottocurve che compongono l'outline + local vSouCrvs = EgtCurveCompoGetTempProp( vBorders[i]) + local nFirst, nCnt = EgtExplodeCurveCompo( vBorders[i]) + + -- assegno nome e info a tutte le curve a partire dalla curva da cui derviano ( salvata nella temp prop della curva) + for j = 0, nCnt - 1 do + local nCrvId = nFirst + j + EgtSetInfo( nCrvId, WIN_SOU_OUTLINE, vSouCrvs[j+1]) + -- assengo il nome : se deriva da split lo scelgo in base all'orientamento, se deriva da outline lo copio + if EgtGetName( abs( vSouCrvs[j+1])) == WIN_SPLIT then + local vtS = EgtSV( nCrvId) + if AreSameVectorApprox( vtS, X_AX()) then + EgtSetName( nCrvId, WIN_BOTTOM) + elseif AreOppositeVectorApprox( vtS, X_AX()) then + EgtSetName( nCrvId, WIN_TOP) + elseif AreSameVectorApprox( vtS, Y_AX()) then + EgtSetName( nCrvId, WIN_RIGHT) + elseif AreOppositeVectorApprox( vtS, Y_AX()) then + EgtSetName( nCrvId, WIN_LEFT) + end + else + EgtSetName( nCrvId, EgtGetName( abs( vSouCrvs[j+1]))) + end + end + + -- riordino le curve per avere la bottom come prima + for j = 0, nCnt - 1 do + if EgtGetName( nFirst + j) ~= WIN_BOTTOM then + EgtRelocate( nFirst + j, nOutlineLayerId) + else + break + end + end + else + -- se non c'è bordo l'area non è valida e va eliminata + EgtErase( vChildAreas[i]) + end + end + EgtErase( nGrpTmp) +end + + +------------------------------ SPLIT ------------------------------ +--------------------------------------------------------------------- +-- funzione che corregge i profili del telaio individuati di tipo mixed dallo split +local function AdjustMixedFrames( vOutlines) + -- pezzi consecutivi coinvolti da cambio profilo devono avere : profilo di tipo mixed, stesse dimensioni, separazione con giunzione a bisettrice + if vOutlines == 1 then return end + + -- fisso come dimensione quella del primo pezzo + local dDimRef = EgtGetInfo( vOutlines[1], WIN_PART_DIM, 'd') + + for i = 1, #vOutlines do + local bMixed = EgtGetInfo( vOutlines[i], WIN_PRF_CHANGE, 'b') or false + local dDim = EgtGetInfo( vOutlines[i], WIN_PART_DIM, 'd') + -- se non era stato individuato correttamente come profilo mixed oppure la dimensione va modificata ricalcolo il profilo + if not bMixed or abs( dDim - dDimRef) > GEO.EPS_SMALL then + if not bMixed then + EgtSetInfo( vOutlines[i], WIN_PRF_CHANGE, true) + local sRealProfile = EgtIf( EgtGetName( vOutlines[i]) == WIN_BOTTOM, WIN_MIXED_BOTTOM, WIN_MIXED_TOP) + EgtSetInfo( vOutlines[i], WIN_PROFILETYPE, sRealProfile) + end + if abs( dDim - dDimRef) > GEO.EPS_SMALL then + EgtSetInfo( vOutlines[i], WIN_PART_DIM, dDimRef) + end + local nPartId = EgtGetInfo( vOutlines[i], WIN_REF_PART, 'i') + CreatePartProfile( nPartId, vOutlines[i], dDimRef) + end + + -- imposto giunzione + if i ~= 1 then + EgtSetInfo( vOutlines[i], WIN_STARTJOINT, WIN_PART_JNT.ANGLED) + end + if i ~= #vOutlines then + EgtSetInfo( vOutlines[i], WIN_ENDJOINT, WIN_PART_JNT.ANGLED) + end + end +end + +--------------------------------------------------------------------- +-- funzione che verifica gli outlines prev/next per lo split controllando l'interferenza tra i profili +local function TestSplitTrimOutlines( nOutlineId, nTrimOutline, tabOutlines, nMainProfile, b3Profile, nGrpTmp, bPrevOrNext) + + local vTrimOutlines = {} + + -- 1) recupero le curve da testare : + -- a) curva individuata dall'intersezione dello split con l'outline + local vTestOutlines = { tabOutlines[nTrimOutline]} + + -- b) curve vicine a quella individuata dall'intersezione che interferiscono con lo split ( guardando interferenza grossolana dei pezzi) + -- recupero le curve di bordo del pezzo di split + local nOutlineCopyId = EgtCopyGlob( nOutlineId, nGrpTmp) + if bPrevOrNext then + EgtTrimCurveEndAtParam( nOutlineCopyId, 0.5) + else + EgtTrimCurveStartAtParam( nOutlineCopyId, 0.5) + end + local nOutId = EgtOffsetCurveAdv( nOutlineCopyId, b3Profile:getMax():getX()) + local nInId = EgtOffsetCurveAdv( nOutlineCopyId, b3Profile:getMin():getX()) + + -- curve precedenti + local nTestCurve = EgtGetPrev( nTrimOutline) or EgtGetLastInGroup( EgtGetParent( nTrimOutline)) + local bInters = true + while bInters and nTestCurve ~= nTrimOutline do + + local nRefOutline = abs( tabOutlines[nTestCurve]) + local nProfileId = GetOutlineProfileId( nRefOutline, true) + local b3Profile = GetProfileLocalBox( nProfileId) + local nRefSurf = EgtSurfFrFatCurve( nGrpTmp, nRefOutline, b3Profile:getMin():getX(), false) + + local nClassOut = EgtCurveWithRegionClassify( nOutId, nRefSurf) + if nClassOut == GDB_CRC.OUT then + local nClassIn = EgtCurveWithRegionClassify( nInId, nRefSurf) + -- se non c'è interferenza interrompo la ricerca + if nClassIn == GDB_CRC.OUT then + bInters = false + end + end + -- se interferenza lo aggiungo tra le curve da controllare + if bInters then + table.insert( vTestOutlines, 1, tabOutlines[nTestCurve]) + nTestCurve = EgtGetPrev( nTestCurve) or EgtGetLastInGroup( EgtGetParent( nTestCurve)) + end + end + + -- curve successive + nTestCurve = EgtGetNext( nTrimOutline) or EgtGetFirstInGroup( EgtGetParent( nTrimOutline)) + bInters = true + while bInters and nTestCurve ~= nTrimOutline do + + local nRefOutline = abs( tabOutlines[nTestCurve]) + local nProfileId = GetOutlineProfileId( nRefOutline, true) + local b3Profile = GetProfileLocalBox( nProfileId) + local nRefSurf = EgtSurfFrFatCurve( nGrpTmp, nRefOutline, b3Profile:getMin():getX(), false) + + local nClassOut = EgtCurveWithRegionClassify( nOutId, nRefSurf) + if nClassOut == GDB_CRC.OUT then + local nClassIn = EgtCurveWithRegionClassify( nInId, nRefSurf) + if nClassIn == GDB_CRC.OUT then + bInters = false + end + end + if bInters then + table.insert( vTestOutlines, tabOutlines[nTestCurve]) + nTestCurve = EgtGetNext( nTestCurve) or EgtGetFirstInGroup( EgtGetParent( nTestCurve)) + end + end + + if #vTestOutlines == 1 then + return vTestOutlines + end + + -- 2) testo le curve controllando intersezione tra le superfici dei pezzi + -- creo il solido principale + local dExtraLen = b3Profile:getDimX() + local nMainSurf = CreateProfileSurf( nOutlineId, nMainProfile, WIN_SECTION, 4 * dExtraLen, nGrpTmp) + EgtCutSurfTmPlane( nMainSurf, EgtMP( nOutlineId), EgtIf( bPrevOrNext, 1, -1) * EgtSV( nOutlineId)) + + -- recupero profili per i conti + local vProfiles = {} + local vsCtrIn = {} + for i = 1, #vTestOutlines do + vProfiles[i] = GetOutlineProfileId( abs( vTestOutlines[i]), true) + vsCtrIn[i] = GetProfileCtrIn( abs( vTestOutlines[i]), nOutlineId, vProfiles[i]) + end + + -- testo le curve + for i = 1, #vTestOutlines do + -- creo la superficie di test limitandola con le sue vicine + local nTestSurf = CreateProfileSurf( abs( vTestOutlines[i]), vProfiles[i], vsCtrIn[i], 4 * dExtraLen, nGrpTmp) + if i > 1 then + if AreSameVectorApprox( EgtEV( abs( vTestOutlines[i-1])), EgtSV( abs( vTestOutlines[i]))) then + EgtCutSurfTmPlane( nTestSurf, EgtEP( abs( vTestOutlines[i-1])), - EgtEV( abs( vTestOutlines[i-1])), false) + else + local nTrimSurf = CreateProfileSurf( abs( vTestOutlines[i-1]), vProfiles[i-1], WIN_OFST .. vsCtrIn[i-1], 4 * dExtraLen, nGrpTmp) + EgtSurfTmCut( nTestSurf, nTrimSurf, true, false) + end + end + if i < #vTestOutlines then + if AreSameVectorApprox( EgtEV( abs( vTestOutlines[i])), EgtSV( abs( vTestOutlines[i+1]))) then + EgtCutSurfTmPlane( nTestSurf, EgtEP( abs( vTestOutlines[i])), EgtEV( abs( vTestOutlines[i])), false) + else + local nTrimSurf = CreateProfileSurf( abs( vTestOutlines[i+1]), vProfiles[i+1], WIN_OFST .. vsCtrIn[i+1], 4 * dExtraLen, nGrpTmp) + EgtSurfTmCut( nTestSurf, nTrimSurf, true, false) + end + end + -- calcolo intersezione con il solido : se c'è intersezione è una vera curva di trim, altrimenti non va considerata + local nId, _, nCrvCnt = EgtSurfTmSurfTmInters( nMainSurf, nTestSurf, nGrpTmp) + if nId and nCrvCnt > 0 then + table.insert( vTrimOutlines, vTestOutlines[i]) + end + end + + return vTrimOutlines +end + +--------------------------------------------------------------------- +-- funzione che recupera gli outline precedenti e successivi degli split +local function GetSplitsPrevNextOutline( vSplitIds, vOutlineIds) + + local nGrpTmp = EgtGroup( GDB_ID.ROOT) + + -- ad ogni outline dell'area di split associo l'outline non virtuale corrispondente ( per rendere più solidi i conti successivi) + local tabOutlines = {} + for i = 1, #vOutlineIds do + tabOutlines[vOutlineIds[i]] = GetNonVirtualOutline( vOutlineIds[i]) + end + + -- per ogni split individuo i prev e i next + for i = 1, #vSplitIds do + + local nMainProfile = GetOutlineProfileId( vSplitIds[i]) + local b3Profile = GetProfileLocalBox( nMainProfile) + + -- controllo la validità delle curve prev/next trovate dall'intersezione degli outlines e la validità di eventuali curve vicine verificando l'interferenza tra i profili + local nPrevOutlineId = EgtGetInfo( vSplitIds[i], WIN_SPLIT_STARTINTERS, 'i') + local vPrevOutlineId = TestSplitTrimOutlines( vSplitIds[i], nPrevOutlineId, tabOutlines, nMainProfile, b3Profile, nGrpTmp, true) + EgtSetInfo( vSplitIds[i], WIN_PREV_OUTLINES, vPrevOutlineId) + + local nNextOutlineId = EgtGetInfo( vSplitIds[i], WIN_SPLIT_ENDINTERS, 'i') + local vNextOutlineId = TestSplitTrimOutlines( vSplitIds[i], nNextOutlineId, tabOutlines, nMainProfile, b3Profile, nGrpTmp, false) + EgtSetInfo( vSplitIds[i], WIN_NEXT_OUTLINES, vNextOutlineId) + + -- se split di tipo mixed i pezzi che incontra deve essere di tipo mixed ( anche se avevo trovato una sola tipologia di figli), devono essere separati da giunzione + -- a bisettrice e devono avere le stesse dimensioni. Impongo queste condizioni eventualmente ricalcolando i profili + local bChangeProfile = EgtGetInfo( vSplitIds[i], WIN_PRF_CHANGE, 'b') or false + if bChangeProfile then + AdjustMixedFrames( vPrevOutlineId) + AdjustMixedFrames( vNextOutlineId) + end + end + + EgtErase( nGrpTmp) +end + +--------------------------------------------------------------------- +-- funzione che adatta la curva di split al bordo +local function TrimSplitWithOutline( nSplitId, nOutlineCompo, vOutlineIds) + -- estendo agli estremi ( TO DO : gestire caso di split non lineare) + EgtExtendCurveStartByLen( nSplitId, 1000) + EgtExtendCurveEndByLen( nSplitId, 1000) + + local ptS = EgtIP( nSplitId, nOutlineCompo, EgtSP( nSplitId)) + local ptE = EgtIP( nSplitId, nOutlineCompo, EgtEP( nSplitId)) + -- se non trovo punti di intersezione lo split è fuori dall'outline e quindi va eliminato + if not ptS and not ptE then + return false + end + + local dParS = EgtCurveParamAtPoint( nSplitId, ptS) + local dParE = EgtCurveParamAtPoint( nSplitId, ptE) + EgtTrimCurveStartEndAtParam( nSplitId, dParS, dParE) + + -- recupero le curve con cui avviene l'intersezione e le salvo come info + local dParCrvS = EgtCurveParamAtPoint( nOutlineCompo, ptS) + local nCrv = vOutlineIds[ floor( dParCrvS) + 1] + EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, nCrv) + local dParCrvE = EgtCurveParamAtPoint( nOutlineCompo, ptE) + nCrv = vOutlineIds[ floor( dParCrvE) + 1] + EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, nCrv) + + return true +end + +--------------------------------------------------------------------- +local function CalcSplitDimensions( nAreaId, dDim) + + local vMeasureTypes = EgtGetInfo( nAreaId, WIN_MEASURE_TYPE, 'vi') + local vMeasureValues = EgtGetInfo( nAreaId, WIN_MEASURE_VALUE, 'vd') + local vDimensions = {} + -- calcolo le dimensioni di tutti gli split assoluti e percentuali e calcolo i valori di riferimento per eventuali split proporzionali + local nPropTot = 0 + local dPropDim = dDim + local bProportional = false + for i = 1, #vMeasureTypes do + if vMeasureTypes[i] == WIN_MEASURE.ABSOLUTE then + vDimensions[i] = vMeasureValues[i] + dPropDim = dPropDim - vDimensions[i] + elseif vMeasureTypes[i] == WIN_MEASURE.PERCENTAGE then + vDimensions[i] = dDim * vMeasureValues[i] / 100 + dPropDim = dPropDim - vDimensions[i] + elseif vMeasureTypes[i] == WIN_MEASURE.PROPORTIONAL then + nPropTot = nPropTot + vMeasureValues[i] + bProportional = true + end + end + + -- calcolo le dimensioni degli split proporzionali + if bProportional then + if dPropDim < GEO.EPS_SMALL then + return {} + end + for i = 1, #vMeasureTypes do + if vMeasureTypes[i] == WIN_MEASURE.PROPORTIONAL then + vDimensions[i] = dPropDim * vMeasureValues[i] / nPropTot + end + end + end + + return vDimensions +end + +--------------------------------------------------------------------- +local function GetSplitAreaBorderCurves( nSplitDir, nOutlineLayerId) + + local vCrvs = {} + -- se split verticale servono le curve di sinistra e di destra, che sono rispettivamente quella prima e quella dopo il bottom + -- non ricerco la left/right per casi dove non sono definite ( e.g. triangolo) + if nSplitDir == WIN_SPLITORIENTATION.VERTICAL then + vCrvs[1] = EgtGetLastInGroup( nOutlineLayerId) + vCrvs[2] = EgtGetNext( EgtGetFirstNameInGroup( nOutlineLayerId, WIN_BOTTOM)) + + -- se split orizzontale servono le curve inferiore e superiore + elseif nSplitDir == WIN_SPLITORIENTATION.HORIZONTAL then + vCrvs[1] = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_BOTTOM) + vCrvs[2] = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_TOP) + end + + return vCrvs +end + +--------------------------------------------------------------------- +local function CalcStandardSplitContributions( nSplitDir, nOutlineLayerId, vSplitIds) + -- nel caso di split standard la dimensione è sempre luce + + local tPartsDim = {} + + -- 1) contributo dei pezzi che delimitano la regione degli split + local vDim = {} + local vCrvs = GetSplitAreaBorderCurves( nSplitDir, nOutlineLayerId) + for i = 1, 2 do + -- recupero il pezzo contro cui poggia + local nSouId = GetNonVirtualOutline( vCrvs[i]) + -- recupero il profilo ( eventualmente di bottomrail) + local nProfileId = GetOutlineProfileId( abs( nSouId), true) + local dRailOffs = EgtGetInfo( nProfileId, WIN_RAILOFFS, 'd') or 0 + local b3Profile = GetProfileLocalBox( nProfileId) + -- calcolo il contributo + if nSouId < 0 then + vDim[i] = b3Profile:getMax():getX() + dRailOffs + else + vDim[i] = abs( b3Profile:getMin():getX()) + dRailOffs + end + end + + tPartsDim[1] = { 0, vDim[1]} + + -- 2) contributo degli split + for i = 1, #vSplitIds do + local nProfileId = GetOutlineProfileId( vSplitIds[i]) + local b3Profile = GetProfileLocalBox( nProfileId) + local vCurrSplitDim = {} + vCurrSplitDim[1] = abs( b3Profile:getMin():getX()) + vCurrSplitDim[2] = b3Profile:getMax():getX() + -- se cambio profilo invertito devo scambiare le dimensioni del profilo + local bInvert = EgtGetInfo( vSplitIds[i], WIN_INV_SPLIT, 'b') or false + if bInvert then + vCurrSplitDim[1], vCurrSplitDim[2] = vCurrSplitDim[2], vCurrSplitDim[1] + end + table.insert( tPartsDim, vCurrSplitDim) + end + + table.insert( tPartsDim, { vDim[2], 0}) + + return tPartsDim +end + +--------------------------------------------------------------------- +local function CalcFrenchSplitContributions( nSplitDir, nOutlineLayerId, nBaseOutlineLayerId, vSplitIds, bDaylight) + -- nel caso di french split ( gruppo di ante) la dimensione può essere di tipo luce o esterno anta + + local tPartsDim = {} + local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) + local nSashProfileGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_SASH) + + -- 1) contributo dei pezzi che delimitano la regione degli split + local vDim = {} + local vCrvs = GetSplitAreaBorderCurves( nSplitDir, nOutlineLayerId) + local vBaseCrvs = GetSplitAreaBorderCurves( nSplitDir, nBaseOutlineLayerId) + for i = 1, 2 do + + -- recupero l'outline del pezzo telaio/split su cui poggia e il base outline dell'anta che poggerà + local nSouId = GetNonVirtualOutline( vCrvs[i]) + local nSashBaseOutline = EgtGetInfo( vBaseCrvs[i], WIN_CHILD, 'i') + + -- a) contributo del telaio + local nProfileId = GetOutlineProfileId( abs( nSouId)) + local b3Profile = GetProfileLocalBox( nProfileId) + if nSouId < 0 then + vDim[i] = abs( b3Profile:getMax():getX()) + else + vDim[i] = abs( b3Profile:getMin():getX()) + end + -- considero l'overlap in base all'anta che vi poggerà + local sKey = EgtIf( EgtGetName( nSashBaseOutline) == WIN_BOTTOM, WIN_SASH_BOTTOM_OVERLAP, WIN_SASH_TOP_OVERLAP) + local dSashOverlap = EgtGetInfo( nProfileId, sKey, 'd') + vDim[i] = vDim[i] - dSashOverlap + + -- b) se luce devo considerare anche il contributo dell'anta + if bDaylight then + -- anta non è ancora calcolata quindi devo usare profilo e dimensione teorica ricavandole dal base outline + local sSashName = EgtGetName( nSashBaseOutline) + local sSashProfile = EgtIf( sSashName == WIN_BOTTOM, WIN_FRAME_BOTTOM, WIN_FRAME_TOP) + local nSashType = EgtGetInfo( EgtGetParent( EgtGetParent( nSashBaseOutline)), WIN_SASHTYPE, 'i') + if nSashType == WIN_SASHTYPES.SLIDE_MOVABLE then + if sSashName == WIN_BOTTOM then + sSashProfile = WIN_SLIDE_MOVABLE_BOTTOM + elseif sSashName == WIN_TOP then + sSashProfile = WIN_SLIDE_MOVABLE_TOP + else + sSashProfile = WIN_SLIDE_MOVABLE_SIDE + end + elseif nSashType == WIN_SASHTYPES.SLIDE_FIXED then + if sSashName == WIN_BOTTOM then + sSashProfile = WIN_SLIDE_FIXED_BOTTOM + elseif sSashName == WIN_TOP then + sSashProfile = WIN_SLIDE_FIXED_TOP + else + sSashProfile = WIN_SLIDE_FIXED_SIDE + end + elseif nSashType == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then + if sSashName == WIN_BOTTOM then + sSashProfile = WIN_SLIDE_MOVABLEBACK_BOTTOM + elseif sSashName == WIN_TOP then + sSashProfile = WIN_SLIDE_MOVABLEBACK_TOP + else + sSashProfile = WIN_SLIDE_MOVABLEBACK_SIDE + end + end + local nProfileId = EgtGetFirstNameInGroup( nSashProfileGrp, sSashProfile) + local dDim = EgtGetInfo( nSashBaseOutline, WIN_PART_DIM, 'd') or EgtGetInfo( nProfileId, WIN_DIM_STD, 'd') + vDim[i] = vDim[i] + dDim + end + end + + tPartsDim[1] = { 0, vDim[1]} + + -- 2) contributo degli split + for i = 1, #vSplitIds do + + local vCurrSplitDim = { 0, 0} + -- ricavo i base outlines delle ante che poggeranno sullo split + local vSashChildren = EgtGetInfo( vSplitIds[i], WIN_CHILD, 'vi') + + local vSashTypes = {} + vSashTypes[1] = EgtGetInfo( EgtGetParent( EgtGetParent( vSashChildren[1])), WIN_SASHTYPE, 'i') + vSashTypes[2] = EgtGetInfo( EgtGetParent( EgtGetParent( vSashChildren[2])), WIN_SASHTYPE, 'i') + for j = 1, 2 do + -- recupero il profilo teorico + local sSashProfile + local nOther = EgtIf( j == 1, 2, 1) + if vSashTypes[j] == WIN_SASHTYPES.ACTIVE then + sSashProfile = WIN_SASH_ACTIVE + elseif vSashTypes[j] == WIN_SASHTYPES.INACTIVE then + sSashProfile = WIN_SASH_INACTIVE + elseif vSashTypes[j] == WIN_SASHTYPES.ACTIVE_OUT or vSashTypes[j] == WIN_SASHTYPES.INACTIVE_OUT then + sSashProfile = WIN_FRENCH_OUT + elseif vSashTypes[j] == WIN_SASHTYPES.ACTIVE_IN then + if vSashTypes[nOther] == WIN_SASHTYPES.ACTIVE_OUT then + sSashProfile = WIN_FRENCH_IN + else + sSashProfile = WIN_SASH_ACTIVE + end + elseif vSashTypes[j] == WIN_SASHTYPES.INACTIVE_IN then + if vSashTypes[nOther] == WIN_SASHTYPES.INACTIVE_OUT then + sSashProfile = WIN_FRENCH_IN + else -- adiacente è active + sSashProfile = WIN_SASH_INACTIVE + end + + elseif vSashTypes[j] == WIN_SASHTYPES.SLIDE_MOVABLE then + if vSashTypes[nOther] == WIN_SASHTYPES.SLIDE_MOVABLE then + sSashProfile = WIN_SLIDE_ACTIVE_IN + else + sSashProfile = WIN_SLIDE_ACTIVE + end + elseif vSashTypes[j] == WIN_SASHTYPES.SLIDE_FIXED then + sSashProfile = WIN_SLIDE_INACTIVE + elseif vSashTypes[j] == WIN_SASHTYPES.SLIDE_MOVABLE_BACK then + sSashProfile = WIN_SLIDE_INACTIVE + end + + local nProfileId = EgtGetFirstNameInGroup( nSashProfileGrp, sSashProfile) + local b3Profile = GetProfileLocalBox( nProfileId) + if bDaylight then + local dDim = EgtGetInfo( vSashChildren[j], WIN_PART_DIM, 'd') or EgtGetInfo( nProfileId, WIN_DIM_STD, 'd') + vCurrSplitDim[j] = dDim - b3Profile:getMax():getX() + else + vCurrSplitDim[j] = - b3Profile:getMax():getX() + end + end + + table.insert( tPartsDim, vCurrSplitDim) + end + + table.insert( tPartsDim, { vDim[2], 0}) + + return tPartsDim +end + +--------------------------------------------------------------------- +-- funzione che calcola gli offset da applicare ai base splits per posizionarli correttamente +local function CalcSplitPositionOffsets( nAreaId, nAreaInfoId, vSplitIds, nSplitType) + + local nSplitDir = EgtGetInfo( nAreaInfoId, WIN_SPLIT_DIR, 'i') + local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) + local nBaseOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) + + -- calcolo i contributi dei vari pezzi presenti + local tPartsDim + if nSplitType == WIN_SPLITTYPES.FRENCH then + local bDaylight = EgtGetInfo( nAreaInfoId, WIN_DAYLIGHT_MEASURE, 'b') or false + tPartsDim = CalcFrenchSplitContributions( nSplitDir, nOutlineLayerId, nBaseOutlineLayerId, vSplitIds, bDaylight) + else + tPartsDim = CalcStandardSplitContributions( nSplitDir, nOutlineLayerId, vSplitIds) + end + + -- ricavo la vera dimensione disponibile + local b3Box = EgtGetBBoxGlob( nOutlineLayerId, GDB_BB.STANDARD) + local dRealDim = EgtIf( nSplitDir == WIN_SPLITORIENTATION.VERTICAL, b3Box:getDimX(), b3Box:getDimY()) + for i = 1, #tPartsDim do + dRealDim = dRealDim - tPartsDim[i][1] - tPartsDim[i][2] + end + + -- calcolo le dimensioni assolute di tutte le sottoaree + local vSplitDimensions = CalcSplitDimensions( nAreaInfoId, dRealDim) + + -- le posizioni salvate negli split sono calcolate rispetto al box del base outline, le posizioni appena calcolate sono rispetto al box dell'outline + -- quindi calcolo la correzione da applicare + local b3BoxBase = EgtGetBBoxGlob( nBaseOutlineLayerId, GDB_BB.STANDARD) + local dCorrection = EgtIf( nSplitDir == WIN_SPLITORIENTATION.VERTICAL, ( b3Box:getMin():getX() - b3BoxBase:getMin():getX()), ( b3Box:getMin():getY() - b3BoxBase:getMin():getY())) + tPartsDim[1][2] = tPartsDim[1][2] + dCorrection + + -- calcolo gli offset + local vOffs = {} + local dPrevPos = 0 + for i = 1, #vSplitIds do + local dNewPos = dPrevPos + tPartsDim[i][2] + vSplitDimensions[i] + tPartsDim[i+1][1] + local dOldPos = EgtGetInfo( vSplitIds[i], WIN_SPLIT_POSITION, 'd') + vOffs[i] = dNewPos - dOldPos + local bInvert = EgtGetInfo( vSplitIds[i], WIN_INV_SPLIT, 'b') or false + if bInvert then + vOffs[i] = - vOffs[i] + end + dPrevPos = dNewPos + end + + return vOffs +end + +--------------------------------------------------------------------- +local function CalculateSplitOutline( nAreaId, vSplitIds, sName) + + -- recupero l'outline e creo composita del bordo + local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) + local vOutlineIds = EgtGetAllInGroup( nOutlineLayerId) + local nOutlineCompo = EgtCurveCompo( nAreaId, vOutlineIds, false) + for i = 1, #vOutlineIds do + EgtCurveCompoSetTempProp( nOutlineCompo, i - 1, vOutlineIds[i]) + end + + local nSplitType = EgtGetInfo( vSplitIds[1], WIN_SPLITTYPE, 'i') + + -- creo i pezzi associati ( per avere i profili corretti da usare per i conti del posizionamento) + if nSplitType ~= WIN_SPLITTYPES.FRENCH then + local vSplitDim = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vd') or {} + for i = 1, #vSplitIds do + CreateOutlinePart( vSplitIds[i], sName, vSplitDim[i]) + EgtSetInfo( vSplitIds[i], WIN_PART_DIM, vSplitDim[i]) + -- imposto le giunzioni + EgtSetInfo( vSplitIds[i], WIN_STARTJOINT, WIN_PART_JNT.SHORT) + EgtSetInfo( vSplitIds[i], WIN_ENDJOINT, WIN_PART_JNT.SHORT) + end + end + + -- posiziono correttamente gli split e li taglio con l'outline + local vOffs = CalcSplitPositionOffsets( nAreaId, nAreaId, vSplitIds, nSplitType) + for i = 1, #vSplitIds do + EgtOffsetCurve( vSplitIds[i], vOffs[i]) + TrimSplitWithOutline( vSplitIds[i], nOutlineCompo, vOutlineIds) + end + + if nSplitType ~= WIN_SPLITTYPES.FRENCH then + -- ricavo prev e next + GetSplitsPrevNextOutline( vSplitIds, vOutlineIds) + + -- creo l'outline delle aree figlie di tipo null + local vChildAreas = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*') + CalculateNullOutline( nOutlineCompo, vSplitIds, vChildAreas) + end + + EgtErase( nOutlineCompo) +end + +--------------------------------------------------------------------- +local function CalculateGridSplitOutline( nAreaId, vSplitIds, sName) + + local vAreas = EgtGetNameInGroup( nAreaId, WIN_AREA .. '*') + local vVirtualAreas = EgtGetNameInGroup( nAreaId, WIN_VIRTUAL_AREA) + + -- raggruppo gli split e le aree per ordine + local tabGrid = {} + for i = 1, #vSplitIds do + local nOrder = EgtGetInfo( vSplitIds[i], WIN_GRIDSPLIT_ORDER, 'i') + if tabGrid[nOrder] then + table.insert( tabGrid[nOrder], vSplitIds[i]) + else + tabGrid[nOrder] = { vSplitIds[i]} + end + end + + local tabAreas = {} + for i = 1, #vAreas do + local nOrder = EgtGetInfo( vAreas[i], WIN_GRIDSPLIT_ORDER, 'i') + if tabAreas[nOrder] then + table.insert( tabAreas[nOrder], vAreas[i]) + else + tabAreas[nOrder] = { vAreas[i]} + end + end + + -- creo i pezzi + local vDimMain = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vd') or {} + local vDimOther = EgtGetInfo( vVirtualAreas[1], WIN_PART_DIM, 'vd') or {} + for i = 0, #tabGrid do + for j = 1, #tabGrid[i] do + local dDim = EgtIf( i == 0, vDimMain[j], vDimOther[j]) + CreateOutlinePart( tabGrid[i][j], sName, dDim) + EgtSetInfo( tabGrid[i][j], WIN_PART_DIM, dDim) + -- imposto le giunzioni + EgtSetInfo( tabGrid[i][j], WIN_STARTJOINT, WIN_PART_JNT.SHORT) + EgtSetInfo( tabGrid[i][j], WIN_ENDJOINT, WIN_PART_JNT.SHORT) + end + end + + -- calcolo gli offset + local vOffsMain = CalcSplitPositionOffsets( nAreaId, nAreaId, tabGrid[0]) + local vOffsSecondary = CalcSplitPositionOffsets( nAreaId, vVirtualAreas[1], tabGrid[1]) + + for i = 0, #tabGrid do + -- recupero l'area di riferimento che racchiude gli split ( i.e. l'area dello split per split principali, area virtuale i-esima per split secondari) e ne costruisco il bordo + local nRefAreaId = EgtIf( i == 0, nAreaId, vVirtualAreas[i]) + local nOutlineLayerId = EgtGetFirstNameInGroup( nRefAreaId, WIN_OUTLINE) + local vOutlineIds = EgtGetAllInGroup( nOutlineLayerId) + local nOutlineCompo = EgtCurveCompo( nAreaId, vOutlineIds, false) + for i = 1, #vOutlineIds do + EgtCurveCompoSetTempProp( nOutlineCompo, i - 1, vOutlineIds[i]) + end + + -- posiziono correttamente e taglio con outline + local vOffs = EgtIf( i == 0, vOffsMain, vOffsSecondary) + for j = 1, #tabGrid[i] do + EgtOffsetCurve( tabGrid[i][j], vOffs[j]) + if not TrimSplitWithOutline( tabGrid[i][j], nOutlineCompo, vOutlineIds) then + -- se split fuoriesce dalla sottoarea lo elimino insieme al pezzo associato + local nPartId = EgtGetInfo( tabGrid[i][j], WIN_REF_PART, 'i') + EgtErase( nPartId) + EgtErase( tabGrid[i][j]) + tabGrid[i][j] = nil + end + end + + -- ricavo prev e next + GetSplitsPrevNextOutline( tabGrid[i], vOutlineIds) + -- creo gli outline delle aree figlie ( i.e. aree virtuali per split principale, sottoaree di ordine i-esimo per split secondari di ordine i-esimo) + CalculateNullOutline( nOutlineCompo, tabGrid[i], EgtIf( i == 0, vVirtualAreas, tabAreas[i])) + + EgtErase( nOutlineCompo) + end +end + + +------------------------------ SASH ------------------------------- +--------------------------------------------------------------------- -- funzione che disegna l'apertura dell'anta local function DrawOpening( nAreaId) @@ -1620,7 +2371,7 @@ local function DrawOpening( nAreaId) local dOffs = b3FrameProfile:getMin():getX() - dDeltaOffs EgtOffsetCurve( nCrv, dOffs) end - vCrvs = TrimOrderedCurves( vCrvs) + vCrvs = TrimOrderedCurves( vCrvs, true) local nGuideId = EgtCurveCompo( nOpeningLayId, vCrvs) local _, dParE = EgtCurveDomain( nGuideId) @@ -1756,373 +2507,173 @@ local function IdentifySashShape( nAreaId, nOutlineLayerId) end --------------------------------------------------------------------- --- funzione che corregge i profili del telaio individuati di tipo mixed dallo split -local function AdjustMixedFrames( vOutlines) - -- pezzi consecutivi coinvolti da cambio profilo devono avere : profilo di tipo mixed, stesse dimensioni, separazione con giunzione a bisettrice - if vOutlines == 1 then return end - - -- fisso come dimensione quella del primo pezzo - local dDimRef = EgtGetInfo( vOutlines[1], WIN_PART_DIM, 'd') - - for i = 1, #vOutlines do - local bMixed = EgtGetInfo( vOutlines[i], WIN_PRF_CHANGE, 'b') or false - local dDim = EgtGetInfo( vOutlines[i], WIN_PART_DIM, 'd') - -- se non era stato individuato correttamente come profilo mixed oppure la dimensione va modificata ricalcolo il profilo - if not bMixed or abs( dDim - dDimRef) > GEO.EPS_SMALL then - if not bMixed then - EgtSetInfo( vOutlines[i], WIN_PRF_CHANGE, true) - local sRealProfile = EgtIf( EgtGetName( vOutlines[i]) == WIN_BOTTOM, WIN_MIXED_BOTTOM, WIN_MIXED_TOP) - EgtSetInfo( vOutlines[i], WIN_PROFILETYPE, sRealProfile) - end - if abs( dDim - dDimRef) > GEO.EPS_SMALL then - EgtSetInfo( vOutlines[i], WIN_PART_DIM, dDimRef) - end - local nPartId = EgtGetInfo( vOutlines[i], WIN_REF_PART, 'i') - CreatePartProfile( nPartId, vOutlines[i], dDimRef) +local function CalculateSashOutline( nAreaId, nAreaLayerId, nOutlineLayerId) + + -- calcolo l'outline corrispondente al telaio + local nFrameArea = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*') + local nFrameOutlineLayer = EgtGetFirstNameInGroup( nFrameArea, WIN_OUTLINE) + local nFrameOutlineId = EgtGetFirstInGroup( nFrameOutlineLayer) + while nFrameOutlineId do + -- copio l'outline del telaio + local nOutlineId = EgtCopyGlob( nFrameOutlineId, nOutlineLayerId) + EgtSetInfo( nOutlineId, WIN_SOU_OUTLINE, nFrameOutlineId) + -- rimuovo info che non voglio trasferire sull'anta + EgtRemoveInfo( nOutlineId, WIN_PRF_CHANGE) + EgtRemoveInfo( nOutlineId, WIN_THRESHOLD) + EgtRemoveInfo( nOutlineId, WIN_PART_DIM) + + -- recupero il suo profilo per calcolare l'offset ( se pezzo contro vetro fisso non serve, sarà tagliato da uno split) + local nProfileId = GetOutlineProfileId( nFrameOutlineId) + local sKey = EgtIf( EgtGetName( nOutlineId) == WIN_BOTTOM, WIN_SASH_BOTTOM_OVERLAP, WIN_SASH_TOP_OVERLAP) + local dOverlap = EgtGetInfo( nProfileId, sKey, 'd') + if dOverlap then + local b3Profile = GetProfileLocalBox( nProfileId) + local dFillPerpOffset = b3Profile:getMin():getX() + dOverlap + EgtOffsetCurve( nOutlineId, dFillPerpOffset) end - -- imposto giunzione - if i ~= 1 then - EgtSetInfo( vOutlines[i], WIN_STARTJOINT, WIN_PART_JNT.ANGLED) - end - if i ~= #vOutlines then - EgtSetInfo( vOutlines[i], WIN_ENDJOINT, WIN_PART_JNT.ANGLED) - end + nFrameOutlineId = EgtGetNext( nFrameOutlineId) end -end + -- accorcio gli offset + local vCrvs = TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true) ---------------------------------------------------------------------- --- funzione che verifica gli outlines prev/next per lo split controllando l'interferenza tra i profili -local function TestSplitTrimOutlines( nOutlineId, vBaseTrimOutlines, tabOutlines, nMainProfile, b3Profile, nGrpTmp, bPrevOrNext) - local vTrimOutlines = {} - - -- 1) recupero le curve da testare - local vTestOutlines = {} - - -- a) curve individuate dalle intersezioni dei base outlines - for i = 1, #vBaseTrimOutlines do - vTestOutlines[i] = tabOutlines[vBaseTrimOutlines[i]] - end - - -- b) curve vicine a quelle individuate dalle intersezioni che interferiscono con l'outline ( guardando interferenza grossolana dei pezzi) - -- recupero le curve di bordo del pezzo di split - local nOutlineCopyId = EgtCopyGlob( nOutlineId, nGrpTmp) - if bPrevOrNext then - EgtTrimCurveEndAtParam( nOutlineCopyId, 0.5) - else - EgtTrimCurveStartAtParam( nOutlineCopyId, 0.5) - end - local nOutId = EgtOffsetCurveAdv( nOutlineCopyId, b3Profile:getMax():getX()) - local nInId = EgtOffsetCurveAdv( nOutlineCopyId, b3Profile:getMin():getX()) - - -- curve precedenti - local nTestCurve = EgtGetPrev( vBaseTrimOutlines[1]) or EgtGetLastInGroup( EgtGetParent( vBaseTrimOutlines[1])) - local bInters = true - while bInters and nTestCurve ~= vBaseTrimOutlines[#vBaseTrimOutlines] do - - local nRefOutline = abs( tabOutlines[nTestCurve]) - local nProfileId = GetOutlineProfileId( nRefOutline, true) - local b3Profile = GetProfileLocalBox( nProfileId) - local nRefSurf = EgtSurfFrFatCurve( nGrpTmp, nRefOutline, b3Profile:getMin():getX(), false) - - local nClassOut = EgtCurveWithRegionClassify( nOutId, nRefSurf) - if nClassOut == GDB_CRC.OUT then - local nClassIn = EgtCurveWithRegionClassify( nInId, nRefSurf) - -- se non c'è interferenza interrompo la ricerca - if nClassIn == GDB_CRC.OUT then - bInters = false - end - end - -- se interferenza lo aggiungo tra le curve da controllare - if bInters then - table.insert( vTestOutlines, 1, tabOutlines[nTestCurve]) - nTestCurve = EgtGetPrev( nTestCurve) or EgtGetLastInGroup( EgtGetParent( nTestCurve)) - end - end - - -- curve successive - nTestCurve = EgtGetNext( vBaseTrimOutlines[#vBaseTrimOutlines]) or EgtGetFirstInGroup( EgtGetParent( vBaseTrimOutlines[1])) - bInters = true - while bInters and nTestCurve ~= vBaseTrimOutlines[1] do - - local nRefOutline = abs( tabOutlines[nTestCurve]) - local nProfileId = GetOutlineProfileId( nRefOutline, true) - local b3Profile = GetProfileLocalBox( nProfileId) - local nRefSurf = EgtSurfFrFatCurve( nGrpTmp, nRefOutline, b3Profile:getMin():getX(), false) - - local nClassOut = EgtCurveWithRegionClassify( nOutId, nRefSurf) - if nClassOut == GDB_CRC.OUT then - local nClassIn = EgtCurveWithRegionClassify( nInId, nRefSurf) - if nClassIn == GDB_CRC.OUT then - bInters = false - end - end - if bInters then - table.insert( vTestOutlines, tabOutlines[nTestCurve]) - nTestCurve = EgtGetNext( nTestCurve) or EgtGetFirstInGroup( EgtGetParent( nTestCurve)) - end - end - - if #vTestOutlines == 1 then - return vTestOutlines - end - - -- 2) testo le curve controllando intersezione tra le superfici dei pezzi - -- creo il solido principale - local dExtraLen = b3Profile:getDimX() - local nMainSurf = CreateProfileSurf( nOutlineId, nMainProfile, WIN_SECTION, 4 * dExtraLen, nGrpTmp) - EgtCutSurfTmPlane( nMainSurf, EgtMP( nOutlineId), EgtIf( bPrevOrNext, 1, -1) * EgtSV( nOutlineId)) - - -- recupero profili per i conti - local vProfiles = {} - local vsCtrIn = {} - for i = 1, #vTestOutlines do - vProfiles[i] = GetOutlineProfileId( abs( vTestOutlines[i]), true) - vsCtrIn[i] = GetProfileCtrIn( abs( vTestOutlines[i]), nOutlineId, vProfiles[i]) - end - - -- testo le curve - for i = 1, #vTestOutlines do - -- creo la superficie di test limitandola con le sue vicine - local nTestSurf = CreateProfileSurf( abs( vTestOutlines[i]), vProfiles[i], vsCtrIn[i], 4 * dExtraLen, nGrpTmp) - if i > 1 then - if AreSameVectorApprox( EgtEV( abs( vTestOutlines[i-1])), EgtSV( abs( vTestOutlines[i]))) then - EgtCutSurfTmPlane( nTestSurf, EgtEP( abs( vTestOutlines[i-1])), - EgtEV( abs( vTestOutlines[i-1])), false) - else - local nTrimSurf = CreateProfileSurf( abs( vTestOutlines[i-1]), vProfiles[i-1], WIN_OFST .. vsCtrIn[i-1], 4 * dExtraLen, nGrpTmp) - EgtSurfTmCut( nTestSurf, nTrimSurf, true, false) - end - end - if i < #vTestOutlines then - if AreSameVectorApprox( EgtEV( abs( vTestOutlines[i])), EgtSV( abs( vTestOutlines[i+1]))) then - EgtCutSurfTmPlane( nTestSurf, EgtEP( abs( vTestOutlines[i])), EgtEV( abs( vTestOutlines[i])), false) - else - local nTrimSurf = CreateProfileSurf( abs( vTestOutlines[i+1]), vProfiles[i+1], WIN_OFST .. vsCtrIn[i+1], 4 * dExtraLen, nGrpTmp) - EgtSurfTmCut( nTestSurf, nTrimSurf, true, false) - end - end - -- calcolo intersezione con il solido : se c'è intersezione è una vera curva di trim, altrimenti non va considerata - local nId, _, nCrvCnt = EgtSurfTmSurfTmInters( nMainSurf, nTestSurf, nGrpTmp) - if nId and nCrvCnt > 0 then - table.insert( vTrimOutlines, vTestOutlines[i]) - end - end - - return vTrimOutlines -end - ---------------------------------------------------------------------- --- funzione che recupera gli outline precedenti e successivi -local function GetSplitPrevNextOutline( nSplitId) - - local nGrpTmp = EgtGroup( GDB_ID.ROOT) - local nMainProfile = GetOutlineProfileId( nSplitId) - local b3Profile = GetProfileLocalBox( nMainProfile) - - local vPrevBaseOutlineId = EgtGetInfo( nSplitId, WIN_SPLIT_STARTINTERS, 'vi') - local vNextBaseOutlineId = EgtGetInfo( nSplitId, WIN_SPLIT_ENDINTERS, 'vi') - - -- ad ogni base outline dell'area di bordo che racchiude lo split associo l'outline non virtuale corrispondente ( per rendere più solidi i conti successivi) - local tabOutlines = {} - local nBaseOutlineLayerId = EgtGetParent( vPrevBaseOutlineId[1]) - local vBaseOutlineIds = EgtGetAllInGroup( nBaseOutlineLayerId) - for i = 1, #vBaseOutlineIds do - local nBaseOutline = vBaseOutlineIds[i] - local nAreaType = WIN_AREATYPES.SPLIT - while not ( nAreaType == WIN_AREATYPES.FRAME or nAreaType == WIN_AREATYPES.SASH or EgtGetName( nBaseOutline) == WIN_SPLIT) do - nBaseOutline = EgtGetInfo( nBaseOutline, WIN_SOU, 'i') - local nAreaId = EgtGetParent( EgtGetParent( nBaseOutline)) - nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') - end - tabOutlines[vBaseOutlineIds[i]] = EgtGetInfo( nBaseOutline, WIN_COPY, 'i') - - -- verifico la coerenza dell'orientamento ( se la curva virtuale deriva da split) e la indico con il segno ( > 0 concorde, < 0 discorde e andrà invertita) - local nOutlineId = EgtGetInfo( vBaseOutlineIds[i], WIN_COPY, 'i') - local bInvert = EgtGetInfo( nOutlineId, WIN_INV_SPLIT, 'b') or false - if bInvert then - tabOutlines[vBaseOutlineIds[i]] = - tabOutlines[vBaseOutlineIds[i]] - end - end - - -- controllo validità delle curve trovate ed eventuali vicine verificando l'interferenza tra i profili - local vPrevOutlineId = TestSplitTrimOutlines( nSplitId, vPrevBaseOutlineId, tabOutlines, nMainProfile, b3Profile, nGrpTmp, true) - EgtSetInfo( nSplitId, WIN_PREV_OUTLINES, vPrevOutlineId) - local vNextOutlineId = TestSplitTrimOutlines( nSplitId, vNextBaseOutlineId, tabOutlines, nMainProfile, b3Profile, nGrpTmp, false) - EgtSetInfo( nSplitId, WIN_NEXT_OUTLINES, vNextOutlineId) - - -- se split di tipo mixed i pezzi che incontra deve essere di tipo mixed ( anche se avevo trovato una sola tipologia di figli), devono essere separati da giunzione - -- a bisettrice e devono avere le stesse dimensioni. Impongo queste condizioni eventualmente ricalcolando i profili - local bChangeProfile = EgtGetInfo( nSplitId, WIN_PRF_CHANGE, 'b') or false - if bChangeProfile then - AdjustMixedFrames( vPrevOutlineId) - AdjustMixedFrames( vNextOutlineId) - end - - EgtErase( nGrpTmp) -end - ---------------------------------------------------------------------- -local function GetPrevNextOutline( nOutlineLayerId) - - local vOutlines = EgtGetAllInGroup( nOutlineLayerId) - for i = 2, #vOutlines - 1 do - EgtSetInfo( vOutlines[i], WIN_PREV_OUTLINES, { vOutlines[i-1]}) - EgtSetInfo( vOutlines[i], WIN_NEXT_OUTLINES, { vOutlines[i+1]}) - end - -- gestione particolare per primo e ultimo - EgtSetInfo( vOutlines[1], WIN_PREV_OUTLINES, { vOutlines[#vOutlines]}) - EgtSetInfo( vOutlines[1], WIN_NEXT_OUTLINES, { vOutlines[2]}) - EgtSetInfo( vOutlines[#vOutlines], WIN_PREV_OUTLINES, { vOutlines[#vOutlines - 1]}) - EgtSetInfo( vOutlines[#vOutlines], WIN_NEXT_OUTLINES, { vOutlines[1]}) -end - ---------------------------------------------------------------------- -local function TrimSplitWithOutline( nSplitId) - -- estendo agli estremi ( TO DO : gestire caso di split non lineare) - EgtExtendCurveStartByLen( nSplitId, 50) - EgtExtendCurveEndByLen( nSplitId, 50) - -- lo taglio con outline - local nStartIntersId = EgtGetInfo( nSplitId, WIN_SPLIT_STARTINTERS, 'i') - local nOutlineId = EgtGetInfo( nStartIntersId, WIN_COPY, 'i') - local ptStartInters = EgtIP( nSplitId, nOutlineId, EgtSP( nSplitId)) - local dStartInters = EgtCurveParamAtPoint( nSplitId, ptStartInters) - EgtTrimCurveStartAtParam( nSplitId, dStartInters) - local nEndIntersId = EgtGetInfo( nSplitId, WIN_SPLIT_ENDINTERS, 'i') - nOutlineId = EgtGetInfo( nEndIntersId, WIN_COPY, 'i') - local ptEndInters = EgtIP( nSplitId, nOutlineId, EgtEP( nSplitId)) - local dEndInters = EgtCurveParamAtPoint( nSplitId, ptEndInters) - EgtTrimCurveEndAtParam( nSplitId, dEndInters) -end - ---------------------------------------------------------------------- --- funzione che calcola l'outline per aree virtuali ausiliarie di split a griglia -local function CalculateVirtualAreaOutline( nAreaId, dZmove) - - local nOutlineLayerId = EgtGroup( nAreaId) - EgtSetName( nOutlineLayerId, WIN_OUTLINE) - EgtSetStatus( nOutlineLayerId, GDB_ST.OFF) - - local nBaseOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) - local nBaseOutlineId = EgtGetFirstInGroup( nBaseOutlineLayerId) - while nBaseOutlineId do - local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') - local nOutlineId - - if EgtGetName( nSouId) == WIN_SPLIT then - -- se deriva da split lo copio e lo traslo - nOutlineId = EgtCopy( nSouId, nOutlineLayerId) - EgtMove( nOutlineId, Z_AX() * dZmove) - EgtSetName( nOutlineId, EgtGetName( nBaseOutlineId)) - -- salvo riferimento dello split da cui deriva - EgtSetInfo( nOutlineId, WIN_REF_SPLIT, nSouId) - -- verifico orientamento - local nCrvRef = EgtGetPrev( nBaseOutlineId) or EgtGetNext( nBaseOutlineId) - local _, _, nSide = EgtPointCurveDistSide( EgtMP( nCrvRef), nOutlineId, Z_AX()) - if nSide == 1 then - EgtInvertCurve( nOutlineId) - EgtSetInfo( nOutlineId, WIN_INV_SPLIT, true) - end - else - local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') or GDB_ID.NULL - nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) - end - - if nOutlineId then - -- sistemo le info - EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId) - EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId) - EgtRemoveInfo( nOutlineId, WIN_CHILD) - end - - nBaseOutlineId = EgtGetNext( nBaseOutlineId) - end - -- taglio tutti i contorni - TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1) -end - ---------------------------------------------------------------------- -local function CalculateSplitOutline( nAreaId, sName) - - -- copio il layer di base outline - local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) - local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId) - EgtSetName( nSplitLayerId, WIN_SPLIT) - EgtSetStatus( nSplitLayerId, GDB_ST.OFF) - - local vBaseSplitIds = EgtGetAllInGroup( nBaseSplitLayerId) - local vSplitIds = EgtGetAllInGroup( nSplitLayerId) - - -- se split interni ad anta ricavo quota in z dal suo profilo - local dZMove = 0 - local nSplitType = EgtGetInfo( vSplitIds[1], WIN_SPLITTYPE, 'i') - if nSplitType == WIN_SPLITTYPES.INSASH then - -- recupero area sash che lo contiene - local nSashAreaId = nAreaId - local nAreaType = EgtGetInfo( nSashAreaId, WIN_AREATYPE, 'i') - while nAreaType ~= WIN_AREATYPES.SASH do - nSashAreaId = EgtGetParent( nSashAreaId) - nAreaType = EgtGetInfo( nSashAreaId, WIN_AREATYPE, 'i') - end - -- recupero il profilo dell'anta da una curva dell'outline - local nSashBaseOutlineLayerId = EgtGetFirstNameInGroup( nSashAreaId, WIN_AREAOUTLINE) - local nSashBaseOutlineId = EgtGetFirstInGroup( nSashBaseOutlineLayerId) - local sSashProfile = EgtGetInfo( nSashBaseOutlineId, WIN_PROFILETYPE) - 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 - dZMove = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd') - end - - -- verifico se presenti aree ausiliarie per split a griglia - local vAuxAreas = EgtGetNameInGroup( nAreaId, WIN_VIRTUAL_AREA) or {} - for i = 1, #vAuxAreas do - CalculateVirtualAreaOutline( vAuxAreas[i], dZMove) - end - - -- sistemo gli outline degli split - local vSplitDim = EgtGetInfo( nAreaId, WIN_PART_DIM, 'vd') or {} - - for i = 1, #vSplitIds do - -- sistemo le info - EgtSetInfo( vBaseSplitIds[i], WIN_COPY, vSplitIds[i]) - EgtSetInfo( vSplitIds[i], WIN_COPY, vBaseSplitIds[i]) - -- taglio con outline - TrimSplitWithOutline( vSplitIds[i]) - -- aggiusto quota - EgtMove( vSplitIds[i], Z_AX() * dZMove) - - if nSplitType ~= WIN_SPLITTYPES.FRENCH then - EgtSetInfo( vSplitIds[i], WIN_PART_DIM, vSplitDim[i]) - -- imposto le giunzioni - EgtSetInfo( vSplitIds[i], WIN_STARTJOINT, WIN_PART_JNT.SHORT) - EgtSetInfo( vSplitIds[i], WIN_ENDJOINT, WIN_PART_JNT.SHORT) - -- creo il pezzo - CreateOutlinePart( vSplitIds[i], sName, vSplitDim[i]) - -- ricavo prev e next - GetSplitPrevNextOutline( vSplitIds[i]) - end - end - - if nSplitType == WIN_SPLITTYPES.FRENCH then - local nOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_OUTLINE) - IdentifySashShape( nAreaId, nOutlineLayerId) - end -end - ---------------------------------------------------------------------- -local function CalculateFillOutline( nAreaId, nAreaLayerId, nOutlineLayerId) - - -- recupero area parent di tipo telaio/anta che la contiene + -- 2) taglio con eventuali split local vSplitAreas = {} local nParentArea = EgtGetParent( nAreaId) - local nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i') - while nAreaType ~= WIN_AREATYPES.FRAME and nAreaType ~= WIN_AREATYPES.SASH do + while nParentArea ~= nFrameArea do + local nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i') if nAreaType == WIN_AREATYPES.SPLIT then table.insert( vSplitAreas, nParentArea) end nParentArea = EgtGetParent( nParentArea) + end + + if #vSplitAreas > 0 then + -- creo bordo complessivo dell'outline, salvando le info di SouOutline come temp prop della curva per non perderle + local vSouOutlines = {} + for i = 1, #vCrvs do + vSouOutlines[i] = EgtGetInfo( vCrvs[i], WIN_SOU_OUTLINE, 'i') + end + local nCompo = EgtCurveCompo( nOutlineLayerId, vCrvs) + for i = 0, #vCrvs - 1 do + EgtCurveCompoSetTempProp( nCompo, i, vSouOutlines[i+1]) + end + + -- recupero gli split coinvolti dalle ante + local vBaseOutlines = EgtGetAllInGroup( nAreaLayerId) + local tabSplits = {} + for i = 1, #vBaseOutlines do + -- verifico se deriva da split + local nSouId = EgtGetInfo( vBaseOutlines[i], WIN_SOU, 'i') + while nSouId and EgtGetName( nSouId) ~= WIN_SPLIT do + nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') + end + if nSouId then + tabSplits[nSouId] = vBaseOutlines[i] + end + end + + -- taglio con split + for i = #vSplitAreas, 1, -1 do + local nSplitBaseOutline = EgtGetFirstNameInGroup( vSplitAreas[i], WIN_BASESPLIT) + local vSplitBaseOutlines = EgtGetAllInGroup( nSplitBaseOutline) + for j = 1, #vSplitBaseOutlines do + -- verifico sia uno split coinvolto nell'area sash considerata + if tabSplits[vSplitBaseOutlines[j]] then + + -- a) creo la curva di outline corrispondente allo split + local nSplitOutline = EgtGetInfo( vSplitBaseOutlines[j], WIN_COPY, 'i') + local nOutlineId = EgtCopy( nSplitOutline, nOutlineLayerId) + -- rimuovo info che non voglio trasferire + EgtRemoveInfo( nOutlineId, WIN_PRF_CHANGE) + EgtRemoveInfo( nOutlineId, WIN_INV_SPLIT) + -- verifico orientamento + local nRefCrv = EgtGetPrev( tabSplits[vSplitBaseOutlines[j]]) or EgtGetNext( tabSplits[vSplitBaseOutlines[j]]) + local _, _, nSide = EgtPointCurveDistSide( EgtMP( nRefCrv), vSplitBaseOutlines[j], Z_AX()) + if nSide == 1 then + EgtInvertCurve( nOutlineId) + end + -- calcolo gli offset + local nProfileId = GetOutlineProfileId( nSplitOutline) + if nProfileId then + local b3Profile = GetProfileLocalBox( nProfileId) + local sKey = EgtIf( EgtGetName( tabSplits[vSplitBaseOutlines[j]]) == WIN_BOTTOM, WIN_SASH_BOTTOM_OVERLAP, WIN_SASH_TOP_OVERLAP) + local dOverlap = EgtGetInfo( nProfileId, sKey, 'd') + local dFillPerpOffset = abs( b3Profile:getMin():getX()) - dOverlap + EgtOffsetCurve( nOutlineId, - dFillPerpOffset) + else + -- è french split quindi non ha offset + end + + -- b) aggiorno la curva complessiva di outline con la curva appena calcolata + EgtExtendCurveStartByLen( nOutlineId, 1000) + EgtExtendCurveEndByLen( nOutlineId, 1000) + local ptS = EgtIP( nOutlineId, nCompo, EgtSP( nOutlineId)) + local ptE = EgtIP( nOutlineId, nCompo, EgtEP( nOutlineId)) + local dBorderParS = EgtCurveParamAtPoint( nCompo, ptS) + local dBorderParE = EgtCurveParamAtPoint( nCompo, ptE) + EgtTrimCurveStartEndAtParam( nCompo, dBorderParE, dBorderParS) + local dSplitParS = EgtCurveParamAtPoint( nOutlineId, ptS) + local dSplitParE = EgtCurveParamAtPoint( nOutlineId, ptE) + EgtTrimCurveStartEndAtParam( nOutlineId, dSplitParS, dSplitParE) + EgtAddCurveCompoCurve( nCompo, nOutlineId) + local _, dParEnd = EgtCurveDomain( nCompo) + EgtCurveCompoSetTempProp( nCompo, dParEnd - 1, EgtIf( nSide == 1, - nSplitOutline, nSplitOutline)) + end + end + end + + -- spezzo la curva di outline nelle sue sottocurve e riassegno le info + local vTempProps = EgtCurveCompoGetTempProp( nCompo) + local nCrv, nCnt = EgtExplodeCurveCompo( nCompo) + for i = 0, nCnt - 1 do + local nOutlineId = nCrv + i + EgtSetInfo( nOutlineId, WIN_SOU_OUTLINE, vTempProps[i+1]) + -- sistemo il nome + if EgtGetName( abs( vTempProps[i+1])) == WIN_SPLIT then + local nBaseSplit = EgtGetInfo( abs( vTempProps[i+1]), WIN_COPY, 'i') + EgtSetName( nOutlineId, EgtGetName( tabSplits[nBaseSplit])) + else + EgtSetName( nOutlineId, EgtGetName( abs( vTempProps[i+1]))) + end + end + + -- riordino in modo da avere il bottom come prima curva + for i = 0, nCnt - 1 do + if EgtGetName( nCrv + i) ~= WIN_BOTTOM then + EgtRelocateGlob( nCrv + i, nOutlineLayerId, GDB_IN.LAST_SON) + else + break + end + end + end + + -- calcolo i profili + local vOutlineCrvs = EgtGetAllInGroup( nOutlineLayerId) + CalcSashProfiles( vOutlineCrvs, nAreaId) + + -- spostamento in z : recupero la quota da un profilo dell'anta + local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) + local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH) + local sSashProfile = EgtGetInfo( vOutlineCrvs[1], WIN_PROFILETYPE) + local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile) + local dSashZOffset = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd') + EgtMove( vOutlineCrvs, Z_AX() * dSashZOffset) + + return vOutlineCrvs +end + + +------------------------------ FILL ------------------------------- +--------------------------------------------------------------------- +local function CalculateFillOutline( nAreaId, nOutlineLayerId) + + -- recupero area parent di tipo telaio/anta che la contiene + local nParentArea = EgtGetParent( nAreaId) + local nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i') + while nAreaType ~= WIN_AREATYPES.FRAME and nAreaType ~= WIN_AREATYPES.SASH do + nParentArea = EgtGetParent( nParentArea) nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i') end @@ -2133,7 +2684,7 @@ local function CalculateFillOutline( nAreaId, nAreaLayerId, nOutlineLayerId) while nParentOutlineId do -- copio la curva di outline del parent local nOutlineId = EgtCopy( nParentOutlineId, nOutlineLayerId) - EgtSetInfo( nOutlineId, WIN_REF_OUTLINE, nParentOutlineId) + EgtSetInfo( nOutlineId, WIN_SOU_OUTLINE, nParentOutlineId) -- recupero il suo profilo per calcolare l'offset perpendicolare local nParentProfileId = GetOutlineProfileId( nParentOutlineId, true) @@ -2154,241 +2705,178 @@ local function CalculateFillOutline( nAreaId, nAreaLayerId, nOutlineLayerId) nParentOutlineId = EgtGetNext( nParentOutlineId) end -- accorcio gli offset - local vCrvs = TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1) + local vCrvs = TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), true) -- applico spostamento verticale EgtMove( vCrvs, Z_AX() * dDeltaZ) + -- 2) taglio con split - if #vSplitAreas == 0 then + local nParentType = EgtGetInfo( EgtGetParent( nAreaId), WIN_AREATYPE, 'i') + if nParentType ~= WIN_AREATYPES.NULL then return end -- creo bordo complessivo dell'outline, salvando le info come temp prop della curva per non perderle - local vRefOutlines = {} + local vSouOutlines = {} for i = 1, #vCrvs do - vRefOutlines[i] = EgtGetInfo( vCrvs[i], WIN_REF_OUTLINE, 'i') + vSouOutlines[i] = EgtGetInfo( vCrvs[i], WIN_SOU_OUTLINE, 'i') end local nCompo = EgtCurveCompo( nOutlineLayerId, vCrvs) for i = 0, #vCrvs - 1 do - EgtCurveCompoSetTempProp( nCompo, i, vRefOutlines[i+1]) + EgtCurveCompoSetTempProp( nCompo, i, vSouOutlines[i+1]) end - -- recupero gli split coinvolti nell'area fill - local tabSplits = {} - local vBaseOutlines = EgtGetAllInGroup( nAreaLayerId) - for i = 1, #vBaseOutlines do - -- verifico se deriva da split - local nSouId = EgtGetInfo( vBaseOutlines[i], WIN_SOU, 'i') - while nSouId and EgtGetName( nSouId) ~= WIN_SPLIT do - nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') - end - if nSouId then - tabSplits[nSouId] = vBaseOutlines[i] + -- recupero gli split che definiscono l'area fill cercando gli split da cui derviano gli elementi dell'area null parent + local vSplitIds = {} + local nNullOutlineLayer = EgtGetFirstNameInGroup( EgtGetParent( nAreaId), WIN_OUTLINE) + local vNullOutlines = EgtGetAllInGroup( nNullOutlineLayer) + for i = 1, #vNullOutlines do + local nSouOutline = GetNonVirtualOutline( vNullOutlines[i]) + if EgtGetName( abs( nSouOutline)) == WIN_SPLIT then + table.insert( vSplitIds, nSouOutline) end end - -- taglio con split - for i = #vSplitAreas, 1, -1 do - local nSplitBaseOutline = EgtGetFirstNameInGroup( vSplitAreas[i], WIN_BASESPLIT) - local vSplitBaseOutlines = EgtGetAllInGroup( nSplitBaseOutline) - for j = 1, #vSplitBaseOutlines do - -- verifico sia uno split coinvolto nell'area fill considerata - if tabSplits[vSplitBaseOutlines[j]] then - - -- a) creo la curva di outline corrispondente allo split - local nSplitOutline = EgtGetInfo( vSplitBaseOutlines[j], WIN_COPY, 'i') - local nOutlineId = EgtCopy( nSplitOutline, nOutlineLayerId) - -- verifico orientamento - local nRefCrv = EgtGetPrev( tabSplits[vSplitBaseOutlines[j]]) or EgtGetNext( tabSplits[vSplitBaseOutlines[j]]) - local _, _, nSide = EgtPointCurveDistSide( EgtMP( nRefCrv), vSplitBaseOutlines[j], Z_AX()) - if nSide == 1 then - EgtInvertCurve( nOutlineId) - end - -- calcolo gli offset - local nParentProfileId = GetOutlineProfileId( nSplitOutline, true) - local b3FrameProfile = GetProfileLocalBox( nParentProfileId) - local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd') - local bMixedSplit = EgtGetInfo( nSplitOutline, WIN_PRF_CHANGE, 'b') or false - local dDimRef = EgtIf( bMixedSplit, b3FrameProfile:getMax():getX(), b3FrameProfile:getMin():getX()) - local dFillPerpOffset = abs( dDimRef) - dOverlap - EgtOffsetCurve( nOutlineId, - dFillPerpOffset) - -- movimento in z - local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd') - EgtMove( nOutlineId, Z_AX() * dFillZOffset) + -- li ordino per id crescente in modo da effettuare i tagli nell'ordine corretto + table.sort( vSplitIds, function ( a, b) return abs( a) < abs( b) end) - -- b) aggiorno la curva complessiva di outline con la curva appena calcolata - local ptS = EgtIP( nOutlineId, nCompo, EgtSP( nOutlineId)) - local ptE = EgtIP( nOutlineId, nCompo, EgtEP( nOutlineId)) - local dBorderParS = EgtCurveParamAtPoint( nCompo, ptS) - local dBorderParE = EgtCurveParamAtPoint( nCompo, ptE) - EgtTrimCurveStartEndAtParam( nCompo, dBorderParE, dBorderParS) - local dSplitParS = EgtCurveParamAtPoint( nOutlineId, ptS) - local dSplitParE = EgtCurveParamAtPoint( nOutlineId, ptE) - EgtTrimCurveStartEndAtParam( nOutlineId, dSplitParS, dSplitParE) - EgtAddCurveCompoCurve( nCompo, nOutlineId) - local _, dParEnd = EgtCurveDomain( nCompo) - EgtCurveCompoSetTempProp( nCompo, dParEnd - 1, EgtIf( nSide == 1, - nSplitOutline, nSplitOutline)) - end + for i = 1, #vSplitIds do + + -- creo la curva di outline corrispondente allo split + local nOutlineId = EgtCopy( abs( vSplitIds[i]), nOutlineLayerId) + if vSplitIds[i] < 0 then + EgtInvertCurve( nOutlineId) end + -- calcolo gli offset + local nParentProfileId = GetOutlineProfileId( abs( vSplitIds[i]), true) + local b3FrameProfile = GetProfileLocalBox( nParentProfileId) + local dOverlap = EgtGetInfo( nParentProfileId, WIN_FILLOVERLAP, 'd') + local bMixedSplit = EgtGetInfo( abs( vSplitIds[i]), WIN_PRF_CHANGE, 'b') or false + local dDimRef = EgtIf( bMixedSplit, b3FrameProfile:getMax():getX(), b3FrameProfile:getMin():getX()) + local dFillPerpOffset = abs( dDimRef) - dOverlap + EgtOffsetCurve( nOutlineId, - dFillPerpOffset) + -- movimento in z + local dFillZOffset = EgtGetInfo( nParentProfileId, WIN_FILLDELTA, 'd') + EgtMove( nOutlineId, Z_AX() * dFillZOffset) + + -- aggiorno la curva complessiva di outline con la curva appena calcolata + local ptS = EgtIP( nOutlineId, nCompo, EgtSP( nOutlineId)) + local ptE = EgtIP( nOutlineId, nCompo, EgtEP( nOutlineId)) + local dBorderParS = EgtCurveParamAtPoint( nCompo, ptS) + local dBorderParE = EgtCurveParamAtPoint( nCompo, ptE) + EgtTrimCurveStartEndAtParam( nCompo, dBorderParE, dBorderParS) + local dSplitParS = EgtCurveParamAtPoint( nOutlineId, ptS) + local dSplitParE = EgtCurveParamAtPoint( nOutlineId, ptE) + EgtTrimCurveStartEndAtParam( nOutlineId, dSplitParS, dSplitParE) + EgtAddCurveCompoCurve( nCompo, nOutlineId) + local _, dParEnd = EgtCurveDomain( nCompo) + EgtCurveCompoSetTempProp( nCompo, dParEnd - 1, vSplitIds[i]) end -- spezzo la curva di outline nelle sue sottocurve e riassegno le info local vTempProps = EgtCurveCompoGetTempProp( nCompo) local nCrv, nCnt = EgtExplodeCurveCompo( nCompo) for i = 0, nCnt - 1 do - EgtSetInfo( nCrv + i, WIN_REF_OUTLINE, vTempProps[i+1]) - if vTempProps[i+1] < 0 then - EgtSetInfo( nCrv + i, WIN_INV_SPLIT, true) - end + EgtSetInfo( nCrv + i, WIN_SOU_OUTLINE, vTempProps[i+1]) end end +--------------------------------------------------------------------- --------------------------------------------------------------------- -- funzione che calcola l'outline dal base outline e i pezzi associati local function CalculateOutlineFromAreaOutline( nAreaId) local nAreaType = EgtGetInfo( nAreaId, WIN_AREATYPE, 'i') - -- recupero il base outline e creo gruppo per outline - local nAreaOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) + local sName = CalcPartName( nAreaId, nAreaType) + + -- se area null il suo outline è già stato calcolato dalla sua area split parent + if nAreaType == WIN_AREATYPES.NULL then + return + end + + -- creo gruppo per outline local nOutlineLayerId = EgtGroup( nAreaId) EgtSetName( nOutlineLayerId, WIN_OUTLINE) EgtSetStatus( nOutlineLayerId, GDB_ST.OFF) - local sName = CalcPartName( nAreaId, nAreaType) -- FRAME if nAreaType == WIN_AREATYPES.FRAME then - local vBaseOutlines = EgtGetAllInGroup( nAreaOutlineLayerId) - local vOutlines = {} - for i = 1, #vBaseOutlines do - vOutlines[i] = EgtCopyGlob( vBaseOutlines[i], nOutlineLayerId) - EgtSetInfo( vBaseOutlines[i], WIN_COPY, vOutlines[i]) - EgtSetInfo( vOutlines[i], WIN_COPY, vBaseOutlines[i]) - end - GetPrevNextOutline( nOutlineLayerId) - -- sistemo le giunzioni - local vJoints = EgtGetInfo( nAreaId, WIN_JOINTS, 'vi') - GetOutlineJoints( vOutlines, vJoints) - -- creo i pezzi - CreatePartsFromOutlines( vOutlines, nAreaId, sName) - - -- SPLIT / NULL - elseif nAreaType == WIN_AREATYPES.SPLIT or nAreaType == WIN_AREATYPES.NULL then - - -- a) outline dell'area - local nBaseOutlineId = EgtGetFirstInGroup( nAreaOutlineLayerId) + -- l'outline è la copia del base outline + local nBaseOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) + local nBaseOutlineId = EgtGetFirstInGroup( nBaseOutlineLayerId) 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') or GDB_ID.NULL - local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) - - if nOutlineId then - -- se deriva da split devo aggiornare il nome, controllare l'orientamento e settare il riferimento - local sSouName = EgtGetName( nSouId) - if sSouName == WIN_SPLIT then - local sBaseName = EgtGetName( nBaseOutlineId) - EgtSetName( nOutlineId, sBaseName) - EgtSetInfo( nOutlineId, WIN_REF_SPLIT, nSouId) - -- verifico orientamento - local nCrvRef = EgtGetPrev( nBaseOutlineId) or EgtGetNext( nBaseOutlineId) - local _, _, nSide = EgtPointCurveDistSide( EgtMP( nCrvRef), nOutlineId, Z_AX()) - if nSide == 1 then - EgtInvertCurve( nOutlineId) - EgtSetInfo( nOutlineId, WIN_INV_SPLIT, true) - end - end - - -- sistemo le info - EgtSetInfo( nOutlineId, WIN_COPY, nBaseOutlineId) - EgtSetInfo( nBaseOutlineId, WIN_COPY, nOutlineId) - EgtRemoveInfo( nOutlineId, WIN_CHILD) - end - + EgtCopyGlob( nBaseOutlineId, nOutlineLayerId) nBaseOutlineId = EgtGetNext( nBaseOutlineId) end - -- taglio tutti i contorni - TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1) + local vOutlines = EgtGetAllInGroup( nOutlineLayerId) + GetPrevNextOutline( vOutlines, nOutlineLayerId) + -- creo i pezzi + CreatePartsFromOutlines( vOutlines, nAreaId, sName) + + + -- SPLIT + elseif nAreaType == WIN_AREATYPES.SPLIT then - -- b) split - if nAreaType == WIN_AREATYPES.SPLIT then - CalculateSplitOutline( nAreaId, sName) + -- l'outline è copia del parent outline + local nParentId = EgtGetParent( nAreaId) + local nParentOutlineId = EgtGetFirstNameInGroup( nParentId, WIN_OUTLINE) + local vParentOutlines = EgtGetAllInGroup( nParentOutlineId) + for i = 1, #vParentOutlines do + local nOutlineId = EgtCopyGlob( vParentOutlines[i], nOutlineLayerId) + EgtSetInfo( nOutlineId, WIN_SOU_OUTLINE, vParentOutlines[i]) end - - + + -- copio il layer di base split + local nBaseSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_BASESPLIT) + local nSplitLayerId = EgtCopy( nBaseSplitLayerId, nAreaId) + EgtSetName( nSplitLayerId, WIN_SPLIT) + EgtSetStatus( nSplitLayerId, GDB_ST.OFF) + local vBaseSplitIds = EgtGetAllInGroup( nBaseSplitLayerId) + local vSplitIds = EgtGetAllInGroup( nSplitLayerId) + for i = 1, #vSplitIds do + -- TODO verificare se possibile evitare questa associazione ( calcolo sash outline) + EgtSetInfo( vSplitIds[i], WIN_COPY, vBaseSplitIds[i]) + EgtSetInfo( vBaseSplitIds[i], WIN_COPY, vSplitIds[i]) + end + + -- se split interni ad anta ricavo quota in z dal suo profilo + local nSplitType = EgtGetInfo( vSplitIds[1], WIN_SPLITTYPE, 'i') + if nSplitType == WIN_SPLITTYPES.INSASH then + -- recupero area sash che lo contiene + local nSashAreaId = nAreaId + local nAreaType = EgtGetInfo( nSashAreaId, WIN_AREATYPE, 'i') + while nAreaType ~= WIN_AREATYPES.SASH do + nSashAreaId = EgtGetParent( nSashAreaId) + nAreaType = EgtGetInfo( nSashAreaId, WIN_AREATYPE, 'i') + end + -- recupero il profilo dell'anta da una curva dell'outline + local nSashOutlineLayerId = EgtGetFirstNameInGroup( nSashAreaId, WIN_OUTLINE) + local nSashOutlineId = EgtGetFirstInGroup( nSashOutlineLayerId) + local nSashProfileId = GetOutlineProfileId( nSashOutlineId) + -- calcolo movimento in z + local dZMove = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd') + EgtMove( vSplitIds, dZMove * Z_AX()) + end + + -- aggiusto gli outlines e calcolo l'outline delle sottoaree null generate + local bGrid = EgtGetInfo( nAreaId, WIN_GRID_SPLIT, 'b') or false + if bGrid then + CalculateGridSplitOutline( nAreaId, vSplitIds, sName) + else + CalculateSplitOutline( nAreaId, vSplitIds, sName) + end + + if nSplitType == WIN_SPLITTYPES.FRENCH then + IdentifySashShape( nAreaId, nOutlineLayerId) + end + + -- SASH elseif nAreaType == WIN_AREATYPES.SASH then - -- recupero se anta battente ricevente - local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL - -- recupero gruppo profili anta - local nProfileLayerId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) - local nSashProfileLayerId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_SASH) - - local vBaseOutlineIds = EgtGetAllInGroup( nAreaOutlineLayerId) - for i = 1, #vBaseOutlineIds do - -- recupero la curva di outline del base outline da cui deriva e la copio - local nSouId = EgtGetInfo( vBaseOutlineIds[i], WIN_SOU, 'i') - local nCopyId = EgtGetInfo( nSouId, WIN_COPY, 'i') or GDB_ID.NULL - local nOutlineId = EgtCopy( nCopyId, nOutlineLayerId) - - if nOutlineId then - -- recupero profilo e ricavo l'offset in z dell'anta ( può essere fatto sui profili teorici perchè non cambia con le dimensioni) - local sSashProfile = EgtGetInfo( vBaseOutlineIds[i], WIN_PROFILETYPE) - local nSashProfileId = EgtGetFirstNameInGroup( nSashProfileLayerId, sSashProfile) - local dSashZOffset = EgtGetInfo( nSashProfileId, WIN_DELTA, 'd') - EgtMove( nOutlineId, Z_AX() * dSashZOffset) - - -- sistemo le info - EgtRemoveInfo( nOutlineId, WIN_PRF_CHANGE) - EgtRemoveInfo( nOutlineId, WIN_REF_SPLIT) - EgtRemoveInfo( nOutlineId, WIN_INV_SPLIT) - EgtRemoveInfo( nOutlineId, WIN_THRESHOLD) - EgtRemoveInfo( nOutlineId, WIN_PART_DIM) - EgtSetInfo( vBaseOutlineIds[i], WIN_COPY, nOutlineId) - EgtSetInfo( nOutlineId, WIN_COPY, vBaseOutlineIds[i]) - EgtSetInfo( nOutlineId, WIN_PROFILETYPE, sSashProfile) - - -- verifico se outline è segmento battente o ricevente ( che quindi deriva da split di tipo french) - local bOnFrenchSplit = EgtGetInfo( vBaseOutlineIds[i], WIN_CRV_ON_FRENCH_SPLIT, 'b') or false - if not bOnFrenchSplit then - -- se outline non è segmento battente o ricevente necessita di offset - -- 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 nFrameOutlineId = EgtGetInfo( nFrameBaseOutlineId, WIN_COPY, 'i') - local nFrameProfileId = GetOutlineProfileId( nFrameOutlineId, false) - - -- calcolo offset perpendicolare - local b3FrameProfile = GetProfileLocalBox( nFrameProfileId) - local sOverlapInfo = EgtIf( EgtGetName( nOutlineId) == WIN_BOTTOM, WIN_SASH_BOTTOM_OVERLAP, WIN_SASH_TOP_OVERLAP) - local dOverlap = EgtGetInfo( nFrameProfileId, sOverlapInfo, 'd') - local dSashPerpOffset = abs( b3FrameProfile:getMin():getX()) - dOverlap - EgtOffsetCurve( nOutlineId, - dSashPerpOffset) - - else - -- se deriva da french split sistemo il nome - local sBaseName = EgtGetName( vBaseOutlineIds[i]) - EgtSetName( nOutlineId, sBaseName) - -- controllo l'orientamento - local nCrvRef = EgtGetPrev( vBaseOutlineIds[i]) or EgtGetNext( vBaseOutlineIds[i]) - local _, _, nSide = EgtPointCurveDistSide( EgtMP( nCrvRef), nOutlineId, Z_AX()) - if nSide == 1 then - EgtInvertCurve( nOutlineId) - end - end - end - end - - -- accorcio gli offset - local vOutlines = TrimOrderedCurves( EgtGetAllInGroup( nOutlineLayerId), 1) + local nBaseOutlineLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_AREAOUTLINE) + local vOutlines = CalculateSashOutline( nAreaId, nBaseOutlineLayerId, nOutlineLayerId) -- assegno prev e next - GetPrevNextOutline( nOutlineLayerId) - -- sistemo le giunzioni - local vJoints = EgtGetInfo( nAreaId, WIN_JOINTS, 'vi') - GetOutlineJoints( vOutlines, vJoints) + GetPrevNextOutline( vOutlines, nOutlineLayerId) -- creo i pezzi CreatePartsFromOutlines( vOutlines, nAreaId, sName) -- identifico la forma @@ -2399,7 +2887,7 @@ local function CalculateOutlineFromAreaOutline( nAreaId) -- FILL elseif nAreaType == WIN_AREATYPES.FILL then - CalculateFillOutline( nAreaId, nAreaOutlineLayerId, nOutlineLayerId) + CalculateFillOutline( nAreaId, nOutlineLayerId) -- creo il pezzo associato CreateFillPartFromArea( nAreaId, sName) end @@ -2435,8 +2923,7 @@ local function SetAreaProfiles( nAreaId) EgtSetInfo( nAreaId, WIN_AREA_PROFILES, vProfiles) elseif nAreaType == WIN_AREATYPES.SPLIT then - local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) - local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') + local nSplitType = EgtGetInfo( nAreaId, WIN_SPLITTYPE, 'i') if nSplitType ~= WIN_SPLITTYPES.FRENCH then -- recupero area parent per capire se dentro telaio o anta local nParentAreaId = EgtGetParent( nAreaId) @@ -2447,6 +2934,7 @@ local function SetAreaProfiles( nAreaId) end local sAreaName = EgtIf( nParentAreaType == WIN_AREATYPES.FRAME, WIN_FRAME, WIN_SASH) + local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) local vSplitIds = EgtGetAllInGroup( nSplitLayerId) local bGridSplit = EgtGetInfo( nAreaId, WIN_GRID_SPLIT, 'b') or false if bGridSplit then @@ -2982,7 +3470,7 @@ local function CreateGeoCurves( nOutlineId, vPrevOutlineId, vNextOutlineId, nSta table.insert( vCrvs, vIds[i]) end end - TrimOrderedCurves( vCrvs, 2, nAreaId) + TrimOrderedCurves( vCrvs, false, nAreaId) -- assegno spessore local dGeoH = b3CurrProfileFrame:getDimY() @@ -3664,8 +4152,7 @@ local function CalcProfilingProcessings( nPartId, nOutlineId) if nAreaType == WIN_AREATYPES.SASH then local nSashType = EgtGetInfo( nAreaId, WIN_SASHTYPE, 'i') if nSashType == WIN_SASHTYPES.INACTIVE or nSashType == WIN_SASHTYPES.INACTIVE_IN then - local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') - local bOnFrenchSplit = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b') + local bOnFrenchSplit = EgtGetInfo( nOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b') if bOnFrenchSplit then EgtSetInfo( nPartId, WIN_SASHTYPE, WIN_INACTIVE) end @@ -4730,10 +5217,10 @@ local function CalculateAreaDowels( nAreaId) end elseif nAreaType == WIN_AREATYPES.SPLIT then - local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) - local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL + local nSplitType = EgtGetInfo( nAreaId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL -- se split non è di tipo french ha un pezzo associato per il quale vanno calcolate le spine if nSplitType ~= WIN_SPLITTYPES.FRENCH then + local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) local vSplitIds = EgtGetAllInGroup( nSplitLayerId) for i = 1, #vSplitIds do -- start @@ -4763,8 +5250,7 @@ local function GetStripNearestToOutline( nProfileId, nOutlineId) local sStripName = WIN_STRIP -- gestione particolare del caso di profilo di split ( devo capire il lato corretto) if not EgtGetFirstNameInGroup( nProfileId, sStripName) then - local bInverted = EgtGetInfo( nOutlineId, WIN_INV_SPLIT, 'b') or false - if bInverted then + if nOutlineId < 0 then sStripName = WIN_STRIP .. '1' else sStripName = WIN_STRIP .. '2' @@ -4780,7 +5266,7 @@ local function GetStripNearestToOutline( nProfileId, nOutlineId) end --------------------------------------------------------------------- -local function CreateStripGuideLines( nOutlineId, nRefOutlineId, nStripId, nProfileId, nSolidLayerId) +local function CreateStripGuideLines( nOutlineId, nStripId, nProfileId, nSolidLayerId) -- restutuisco le curve ordinate in modo che la prima sia quella più esterna e la seconda quella più interna -- recupero il box dello strip nel frame del profilo @@ -4793,14 +5279,13 @@ local function CreateStripGuideLines( nOutlineId, nRefOutlineId, nStripId, nProf local dMinOffs = b3MainStrip:getMin():getX() - dDelta local dMaxOffs = b3MainStrip:getMax():getX() - dDelta - local nMinOffsetId = EgtCopy( nOutlineId, nSolidLayerId) + local nMinOffsetId = EgtCopy( abs( nOutlineId), nSolidLayerId) EgtOffsetCurve( nMinOffsetId, dMinOffs) - local nMaxOffsetId = EgtCopy( nOutlineId, nSolidLayerId) + local nMaxOffsetId = EgtCopy( abs( nOutlineId), nSolidLayerId) EgtOffsetCurve( nMaxOffsetId, dMaxOffs) -- verifico se le curve vanno invertite nel caso di split - local bInverted = EgtGetInfo( nRefOutlineId, WIN_INV_SPLIT, 'b') or false - if bInverted then + if nOutlineId < 0 then EgtInvertCurve( nMinOffsetId) EgtInvertCurve( nMaxOffsetId) return nMaxOffsetId, nMinOffsetId @@ -4873,21 +5358,21 @@ local function CalcAreaStrip( nGeoFillId) local tabStrip = {} for i = 1, #vGeoCrvs do - local nCrvId = abs( EgtGetInfo( vGeoCrvs[i], WIN_REF_OUTLINE, 'i')) - local nOutlineId = abs( EgtGetInfo( nCrvId, WIN_REF_OUTLINE, 'i')) - local nPartId = FindAssociatedPart( nOutlineId, true) + local nFillOutlineId = EgtGetInfo( vGeoCrvs[i], WIN_REF_OUTLINE, 'i') + local nOutlineId = EgtGetInfo( nFillOutlineId, WIN_SOU_OUTLINE, 'i') + local nPartId = FindAssociatedPart( abs( nOutlineId), true) -- recupero profilo local nProfileLayerId = EgtGetFirstNameInGroup( nPartId, WIN_PROFILE) local nProfileId = EgtGetFirstNameInGroup( nProfileLayerId, WIN_PRF_MAIN) - local nStripId = GetStripNearestToOutline( nProfileId, nCrvId) + local nStripId = GetStripNearestToOutline( nProfileId, nOutlineId) -- recupero layer per solido local nSolidLayerId = EgtGetFirstNameInGroup( nPartId, WIN_SOLID) -- estrusione del fermavetro : -- creazione della giuda - local nGuideId = EgtCurveCompo( nSolidLayerId, nOutlineId, false) + local nGuideId = EgtCurveCompo( nSolidLayerId, abs( nOutlineId), false) local sProfileType = EgtGetInfo( nProfileId, WIN_PROFILETYPE) if sProfileType == WIN_FILL_RAIL then local dOffs = EgtGetInfo( nProfileId, WIN_RAILOFFS, 'd') @@ -4920,7 +5405,7 @@ local function CalcAreaStrip( nGeoFillId) EgtErase( nGuideId) -- curve limite del fermavetro - local nOffs1, nOffs2 = CreateStripGuideLines( nOutlineId, nCrvId, nStripId, nProfileId, nGrp) + local nOffs1, nOffs2 = CreateStripGuideLines( nOutlineId, nStripId, nProfileId, nGrp) EgtSetInfo( nOffs1, WIN_REF_GEO, vGeoCrvs[i]) EgtSetInfo( nOffs2, WIN_REF_GEO, vGeoCrvs[i]) @@ -4930,8 +5415,8 @@ local function CalcAreaStrip( nGeoFillId) end -- taglio le curve limite dei fermavetri per individuare correttamente i pezzi con cui verranno tagliati - TrimOrderedCurves( EgtGetAllInGroup( nGrp1)) - TrimOrderedCurves( EgtGetAllInGroup( nGrp2)) + TrimOrderedCurves( EgtGetAllInGroup( nGrp1), true) + TrimOrderedCurves( EgtGetAllInGroup( nGrp2), true) -- associo le curve trimmate alle curve geo corrispondenti local nCrvId = EgtGetFirstInGroup( nGrp1) @@ -5106,15 +5591,7 @@ local function SplitArcByAlignment( nGeoIn, nGrp) -- recupero il pezzo del telaio corrispondente local nPartId = EgtGetParent( EgtGetParent( nGeoIn)) local nOutlineId = EgtGetInfo( nPartId, WIN_REF_OUTLINE, 'i') - local nSouId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') - local nAreaType = WIN_AREATYPES.NULL - while nSouId and nAreaType ~= WIN_AREATYPES.FRAME do - nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') or GDB_ID.NULL - local nParentArea = EgtGetParent( EgtGetParent( nSouId)) or GDB_ID.NULL - nAreaType = EgtGetInfo( nParentArea, WIN_AREATYPE, 'i') - end - if not nSouId then return end - local nFrameOutlineId = EgtGetInfo( nSouId, WIN_COPY, 'i') + local nFrameOutlineId = EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i') local nFramePartId = EgtGetInfo( nFrameOutlineId, WIN_REF_PART, 'i') -- recupero le parti in cui era stato diviso l'arco del telaio @@ -5320,7 +5797,7 @@ local function CalcLogs( nGrp, nGeoOut, dOverMatIn, dOverMatOut, dOverMatExt, dO -- taglio le curve nei loro punti di intersezione local vCrvs = { nLineTop, nLineRight, nLineBottom, nLineLeft} - vCrvs = TrimOrderedCurves( vCrvs) + vCrvs = TrimOrderedCurves( vCrvs, true) -- TO DO : controllo lunghezza minima -- local dLenTop = EgtCurveLength( nLineTop) @@ -5367,8 +5844,8 @@ local function CalcLogDowel( nOrigPartId, nCrvOut, bLeftOrRight, nProcLayerId, n end -- recupero i dati del dowel - local dDowelDiam = EgtGetInfo( nInfoGrp, WIN_DWL_DIAM, 'd') - local dDowelLen = EgtGetInfo( nInfoGrp, WIN_DWL_LOG_LEN, 'd') + local dDowelDiam = 5 -- EgtGetInfo( nInfoGrp, WIN_DWL_DIAM, 'd') + local dDowelLen = 10 -- EgtGetInfo( nInfoGrp, WIN_DWL_LOG_LEN, 'd') -- creo il dowel nel riferimento della sezione -- TO DO : recupero della sezione corretta nel caso di cambio profilo @@ -5404,7 +5881,7 @@ end local function CalcLogParts( nOrigPartId, bFinishedLogs) local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) - local nInfoGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_INFO_GRP) + -- local nInfoGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_INFO_GRP) -- recupero i gruppi dal pezzo ad arco local nProfileLayerId = EgtGetFirstNameInGroup( nOrigPartId, WIN_PROFILE) @@ -5521,14 +5998,14 @@ local function CalcLogParts( nOrigPartId, bFinishedLogs) local nLeftId = EgtLine( nProcLayerId, EgtUP( nLogCrv, 3), EgtSP( nLogCrv)) EgtSetName( nLeftId, WIN_LEFT) -- assegno le info di lavorazione - EgtSetInfo( nLeftId, WIN_PRC_NTOOLS, 1) - local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME) - EgtSetInfo( nLeftId, WIN_PRC_TOOL_NAME .. '_1', sToolName) - local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd') - -- TO DO : verificare valore OffsR - EgtSetInfo( nLeftId, WIN_PRC_OFFR .. '_1', dOffR) - local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_1', 'd') - EgtSetInfo( nLeftId, WIN_PRC_OFFL .. '_1', dOffL) + -- EgtSetInfo( nLeftId, WIN_PRC_NTOOLS, 1) + -- local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME) + -- EgtSetInfo( nLeftId, WIN_PRC_TOOL_NAME .. '_1', sToolName) + -- local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd') + -- -- TO DO : verificare valore OffsR + -- EgtSetInfo( nLeftId, WIN_PRC_OFFR .. '_1', dOffR) + -- local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_1', 'd') + -- EgtSetInfo( nLeftId, WIN_PRC_OFFL .. '_1', dOffL) end -- profilo right @@ -5541,14 +6018,14 @@ local function CalcLogParts( nOrigPartId, bFinishedLogs) local nRightId = EgtLine( nProcLayerId, EgtUP( nLogCrv, 1), EgtUP( nLogCrv, 2)) EgtSetName( nRightId, WIN_RIGHT) -- assegno info di lavorazione - EgtSetInfo( nRightId, WIN_PRC_NTOOLS, 1) - local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME) - EgtSetInfo( nRightId, WIN_PRC_TOOL_NAME .. '_1', sToolName) - local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd') - -- TO DO : verificare valore OffsR - EgtSetInfo( nRightId, WIN_PRC_OFFR .. '_1', dOffR) - local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_2', 'd') - EgtSetInfo( nRightId, WIN_PRC_OFFL .. '_1', dOffL) + -- EgtSetInfo( nRightId, WIN_PRC_NTOOLS, 1) + -- local sToolName = EgtGetInfo( nInfoGrp, WIN_PRC_TOOL_NAME) + -- EgtSetInfo( nRightId, WIN_PRC_TOOL_NAME .. '_1', sToolName) + -- local dOffR = EgtGetInfo( nInfoGrp, WIN_PRC_OFFR, 'd') + -- -- TO DO : verificare valore OffsR + -- EgtSetInfo( nRightId, WIN_PRC_OFFR .. '_1', dOffR) + -- local dOffL = EgtGetInfo( nInfoGrp, WIN_PRC_OFFL .. '_2', 'd') + -- EgtSetInfo( nRightId, WIN_PRC_OFFL .. '_1', dOffL) end -- dowels per incastro dei tronchetti @@ -5738,8 +6215,8 @@ local function DrawHingesStd( nOutlineId, nSolidLayerId) local dDimV = 70 local dFilletRad = 5 - local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') - local dDelta = ( EgtSP( nOutlineId) - EgtSP( nBaseOutlineId)) * Z_AX() + local nFrameOutlineId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i')) + local dDelta = ( EgtSP( nOutlineId) - EgtSP( nFrameOutlineId)) * Z_AX() if dDelta < GEO.EPS_SMALL then return end @@ -5830,8 +6307,8 @@ local function DrawHingesPreview( nOutlineId, nLayerId) local dDimL = 80 local dDimW = 20 - local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') - local dDelta = ( EgtSP( nOutlineId) - EgtSP( nBaseOutlineId)) * Z_AX() + local nFrameOutlineId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i')) + local dDelta = ( EgtSP( nOutlineId) - EgtSP( nFrameOutlineId)) * Z_AX() if dDelta < GEO.EPS_SMALL then return end @@ -5952,8 +6429,8 @@ local function DrawHandlePreview( nOutlineId, sHandleSide, dHandleH, nLayerId, b local nParentAreaId = EgtGetParent( EgtGetParent( nOutlineId)) local nSashType = EgtGetInfo( nParentAreaId, WIN_SASHTYPE, 'i') or WIN_SASHTYPES.NULL if nSashType == WIN_SASHTYPES.NULL then - local nBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') - local dDelta = ( EgtSP( nOutlineId) - EgtSP( nBaseOutlineId)) * Z_AX() + local nFrameOutlineId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i')) + local dDelta = ( EgtSP( nOutlineId) - EgtSP( nFrameOutlineId)) * Z_AX() if dDelta < GEO.EPS_SMALL then dSide = dSide + 9 end @@ -6111,8 +6588,7 @@ local function DrawSashHardware( nAreaId, nRefAreaId, nLayerId, bPreview) if nSashType == WIN_SASHTYPES.INACTIVE or nSashType == WIN_SASHTYPES.INACTIVE_OUT or nSashType == WIN_SASHTYPES.ACTIVE or nSashType == WIN_SASHTYPES.ACTIVE_OUT then -- le cerniere vanno messe sul lato che poggia sul telaio - local nBaseOutlineId = EgtGetInfo( nLeftId, WIN_COPY, 'i') - local bLeftInactive = EgtGetInfo( nBaseOutlineId, WIN_CRV_ON_FRENCH_SPLIT, 'b') or false + local bLeftInactive = EgtGetInfo( nLeftId, WIN_CRV_ON_FRENCH_SPLIT, 'b') or false DrawHinges( EgtIf( bLeftInactive, nRightId, nLeftId), nLayerId, bPreview) elseif nSashType == WIN_SASHTYPES.NULL then @@ -6181,60 +6657,48 @@ local function SearchSash( nAreaId, SashList) EgtSetInfo( nOutlineCopyId, WIN_GAPDELTAZ .. 2, b3Profile:getDimY()) nOutlineId = EgtGetNext( nOutlineId) end - vOutlineCopy = TrimOrderedCurves( vOutlineCopy) + vOutlineCopy = TrimOrderedCurves( vOutlineCopy, true) -- costruisco i riferimenti local tFrame = {} - for nIndex = 1, #vOutlineCopy do + for i = 1, #vOutlineCopy do -- 1) Riferimenti ANTA - local ptOrig = EgtEP( vOutlineCopy[nIndex]) - local sOrigName = string.char( string.byte( 'A') + #vOutlineCopy - nIndex) - local vtDir = EgtEV( vOutlineCopy[nIndex]) + local ptOrig = EgtEP( vOutlineCopy[i]) + local sOrigName = string.char( string.byte( 'A') + #vOutlineCopy - i) + local vtDir = EgtEV( vOutlineCopy[i]) local nFA1Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig, - vtDir, vtDir ^ Z_AX(), Z_AX())) EgtSetName( nFA1Id, sOrigName .. '.FA1') local vtIn = Vector3d( vtDir) vtIn:rotate( Z_AX(), -90) - local dGapDeltaZ = EgtGetInfo( vOutlineCopy[nIndex], WIN_GAPDELTAZ, 'd') + local dGapDeltaZ = EgtGetInfo( vOutlineCopy[i], WIN_GAPDELTAZ, 'd') local nFA2Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig - dGapDeltaZ * Z_AX(), - vtDir, vtDir ^ vtIn, vtIn)) EgtSetName( nFA2Id, sOrigName .. '.FA2') - local dGapDeltaZ2 = EgtGetInfo( vOutlineCopy[nIndex], WIN_GAPDELTAZ .. 2, 'd') + local dGapDeltaZ2 = EgtGetInfo( vOutlineCopy[i], WIN_GAPDELTAZ .. 2, 'd') local nFA3Id = EgtFrame( nHdwSashLayerId, Frame3d( ptOrig - dGapDeltaZ2 * Z_AX(), - vtDir, vtDir ^ -Z_AX(), -Z_AX())) EgtSetName( nFA3Id, sOrigName .. '.FA3') -- 2) Riferimenti TELAIO - -- ricavo elemento su cui poggia ( è il primo parent con un profilo associato. Potrebbe essere uno split in sottoarea del telaio o potrebbe non - -- esistere nel caso di french split) - local nOrigOutlineId = EgtGetInfo( vOutlineCopy[nIndex], 'ORIG', 'i') - local nBaseOutlineId = EgtGetInfo( nOrigOutlineId, WIN_COPY, 'i') - local nSouId = EgtGetInfo( nBaseOutlineId, WIN_SOU, 'i') - local sProfileFrame = EgtGetInfo( nSouId, WIN_PROFILETYPE) - while nSouId and not sProfileFrame do - nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') - sProfileFrame = EgtGetInfo( nSouId or GDB_ID.NULL, WIN_PROFILETYPE) - end - - if nSouId then + -- ricavo elemento su cui poggia. Deve essere un elemento reale, quindi se fosse french split lo ignoro + local bFrenchSplit = EgtGetInfo( vOutlineCopy[i], WIN_CRV_ON_FRENCH_SPLIT, 'b') + if not bFrenchSplit then + local nSouId = EgtGetInfo( vOutlineCopy[i], WIN_SOU_OUTLINE, 'i') -- ricavo aria lato telaio - local nFrameOutlineId = EgtGetInfo( nSouId, WIN_COPY, 'i') - local nFrameProfileId = GetOutlineProfileId( nFrameOutlineId) + local nFrameProfileId = GetOutlineProfileId( abs( nSouId)) local dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA, 'd') - -- se deriva da split verifico il lato - if EgtGetName( nSouId) == WIN_SPLIT then - local bSameDir = AreSameVectorApprox( EgtSV( nSouId), EgtSV( nBaseOutlineId)) + if not dGapDeltaOut then -- recupero informazione dal lato corretto ( split orizzontale) - if not dGapDeltaOut then - if bSameDir then - dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '2', 'd') - else - dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '1', 'd') - end - end - -- verifico il segno dell'offset - if not bSameDir then - dGapDeltaOut = - dGapDeltaOut + if nSouId > 0 then + dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '2', 'd') + else + dGapDeltaOut = EgtGetInfo( nFrameProfileId, WIN_GAPDELTA .. '1', 'd') end end - local nOutlineOutId = EgtCopy( nSouId, nOutlineOffsetLayerId) + -- verifico il segno dell'offset + if nSouId < 0 then + dGapDeltaOut = - dGapDeltaOut + end + + local nOutlineOutId = EgtCopy( abs( nSouId), nOutlineOffsetLayerId) EgtOffsetCurve( nOutlineOutId, - dGapDeltaOut) -- recupero origine come proiezione sul telaio dell'origine dell'anta local _, ptOrigFr = EgtPointCurveDist( ptOrig, nOutlineOutId) @@ -6290,7 +6754,7 @@ end --------------------------------------------------------------------- -- funzione che calcola le lavorazioni dell'hardware -local function CalcHdwMachining( tMachining, SashList) +local function CalcHdwMachining( tMachining, SashList) local nFrameAreaId = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_AREA .. '*') local nHdwFrameLayerId = EgtGetFirstNameInGroup( nFrameAreaId, WIN_HDW_FRAME) for i = 1, #tMachining do @@ -6314,14 +6778,7 @@ local function CalcHdwMachining( tMachining, SashList) local nPartId = GDB_ID.NULL local frHdw if sPart == 'TELAIO' then - local nSashBaseOutlineId = EgtGetInfo( nOutlineId, WIN_COPY, 'i') - local nSouId = EgtGetInfo( nSashBaseOutlineId, WIN_SOU, 'i') - local sSouProfile = EgtGetInfo( nSouId, WIN_PROFILETYPE) - while nSouId and not sSouProfile do - nSouId = EgtGetInfo( nSouId, WIN_SOU, 'i') - sSouProfile = EgtGetInfo( nSouId or GDB_ID.NULL, WIN_PROFILETYPE) - end - local nFrameOutlineId = EgtGetInfo( nSouId, WIN_COPY, 'i') + local nFrameOutlineId = abs( EgtGetInfo( nOutlineId, WIN_SOU_OUTLINE, 'i')) nPartId = EgtGetInfo( nFrameOutlineId, WIN_REF_PART, 'i') local nHdwFrameId = EgtGetLastNameInGroup( nHdwFrameLayerId, nSashIndex .. '.' .. sSashPart .. '.' .. sSide) frHdw = EgtFR( nHdwFrameId) @@ -6719,8 +7176,7 @@ local function DrawHardware( nAreaId, nAuxLayerId) return elseif nAreaType == WIN_AREATYPES.SPLIT then - local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) or GDB_ID.NULL - local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL + local nSplitType = EgtGetInfo( nAreaId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL if nSplitType == WIN_SPLITTYPES.FRENCH then local sHdwFavourite = EgtGetInfo( nAreaId, WIN_HDW_FAVOURITE) if sHdwFavourite and sHdwFavourite ~= WIN_HDW_NULL then @@ -6789,8 +7245,10 @@ local function CalcThreshold( nOutlineId, nAreaId) end -- se slide window ci sono parti extra da estrudere in corrispondenza delle ante fisse + -- ( slide window ha una struttura di aree standard e forma rettangolare) local bSlideWindow = EgtGetInfo( nAreaId, WIN_SLIDE_WINDOW, 'b') or false if bSlideWindow then + -- 1) soglia extra per parte mobile local nGuideId = EgtCopyGlob( nOutlineId, nAuxGrp) -- taglio la curva guida con i pezzi di telaio vicini @@ -6799,7 +7257,7 @@ local function CalcThreshold( nOutlineId, nAreaId) local nNextCrv = EgtGetNext( nOutlineId) local dParE = GetTrimParamByGeo( nGuideId, nNextCrv, WIN_GEO_IN) EgtTrimCurveStartEndAtParam( nGuideId, dParS, dParE) - + local vMovableSections = EgtGetNameInGroup( nProfileId, WIN_MOVABLE .. WIN_SECTION) for i = 1, #vMovableSections do local nStmExtra = CreateProfileSurfById( nGuideId, nProfileId, vMovableSections[i], 0, nAuxGrp) @@ -6814,21 +7272,19 @@ local function CalcThreshold( nOutlineId, nAreaId) local vExtraSections = EgtGetNameInGroup( nProfileId, WIN_FIXED .. WIN_SECTION) if #vExtraSections > 0 then -- cerco tutte le sottoante fisse - local vChildren = EgtGetInfo( nOutlineId, WIN_SASH_CHILDREN, 'vi') - for i = 1, #vChildren do - local nSashAreaId = EgtGetParent( EgtGetParent( vChildren[i])) - local nSashType = EgtGetInfo( nSashAreaId, WIN_SASHTYPE, 'i') + local nSplitArea = EgtGetFirstNameInGroup( nAreaId, WIN_AREA .. '*') + local vSashAreas = EgtGetNameInGroup( nSplitArea, WIN_AREA .. '*') + for i = 1, #vSashAreas do + local nSashType = EgtGetInfo( vSashAreas[i], WIN_SASHTYPE, 'i') if nSashType == WIN_SASHTYPES.SLIDE_FIXED then - local nGuideId = EgtCopyGlob( vChildren[i], nAuxGrp) - EgtExtendCurveStartByLen( nGuideId, 1000) - EgtExtendCurveEndByLen( nGuideId, 1000) + local nGuideId = EgtCopyGlob( nOutlineId, nAuxGrp) -- trim della guida con il geo dei pezzi vicini - local nOutlineId = EgtGetInfo( vChildren[i], WIN_COPY, 'i') - local nPrevCrv = EgtGetInfo( nOutlineId, WIN_PREV_OUTLINES, 'i') - local dParS = GetTrimParamByGeo( nGuideId, nPrevCrv, WIN_GEO_OUT) - local nNextCrv = EgtGetInfo( nOutlineId, WIN_NEXT_OUTLINES, 'i') - local dParE = GetTrimParamByGeo( nGuideId, nNextCrv, WIN_GEO_OUT) + local nOutlineLayerId = EgtGetFirstNameInGroup( vSashAreas[i], WIN_OUTLINE) + local nLeftCrv = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_LEFT) + local dParS = GetTrimParamByGeo( nGuideId, nLeftCrv, WIN_GEO_OUT) + local nRightCrv = EgtGetFirstNameInGroup( nOutlineLayerId, WIN_RIGHT) + local dParE = GetTrimParamByGeo( nGuideId, nRightCrv, WIN_GEO_OUT) EgtTrimCurveStartEndAtParam( nGuideId, dParS, dParE) for j = 1, #vExtraSections do @@ -6887,10 +7343,10 @@ local function CalcWaterdrip( nPartId, nOutlineId, nAreaId, bDraw) while vStack[i] do local nAreaType = EgtGetInfo( vStack[i], WIN_AREATYPE, 'i') if nAreaType == WIN_AREATYPES.SPLIT then - local nSplitId = EgtGetFirstNameInGroup( vStack[i], WIN_SPLIT) - local nSplitType = EgtGetInfo( nSplitId, WIN_SPLITTYPE, 'i') + local nSplitType = EgtGetInfo( vStack[i], WIN_SPLITTYPE, 'i') if nSplitType ~= WIN_SPLITTYPES.FRENCH then - local vCurrSplits = EgtGetAllInGroup( nSplitId) + local nSplitLayerId = EgtGetFirstNameInGroup( vStack[i], WIN_SPLIT) + local vCurrSplits = EgtGetAllInGroup( nSplitLayerId) for j = 1, #vCurrSplits do -- verifico se lo split poggia sulla curva bottom local dDist1 = EgtPointCurveDist( EgtSP( vCurrSplits[j]), nOutlineId) @@ -7018,7 +7474,7 @@ local function CalcGaskets( nAreaId, bDraw) if #vCrvs > 0 then -- taglio le curve - TrimOrderedCurves( vCrvs) + TrimOrderedCurves( vCrvs, true) -- aggiorno lunghezza for i = 1, #vCrvs do @@ -7458,8 +7914,7 @@ local function CalcHardwarePreview( nAreaId, nPreviewGrp) return elseif nAreaType == WIN_AREATYPES.SPLIT then - local nSplitLayerId = EgtGetFirstNameInGroup( nAreaId, WIN_SPLIT) or GDB_ID.NULL - local nSplitType = EgtGetInfo( nSplitLayerId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL + local nSplitType = EgtGetInfo( nAreaId, WIN_SPLITTYPE, 'i') or WIN_SPLITTYPES.NULL if nSplitType == WIN_SPLITTYPES.FRENCH then local sHdwFavourite = EgtGetInfo( nAreaId, WIN_HDW_FAVOURITE) if sHdwFavourite and sHdwFavourite ~= WIN_HDW_NULL then diff --git a/Designing/WinLib/WinCreate.lua b/Designing/WinLib/WinCreate.lua index e4d692a..1a025cf 100644 --- a/Designing/WinLib/WinCreate.lua +++ b/Designing/WinLib/WinCreate.lua @@ -277,7 +277,7 @@ end ---------------------------------------------------------------------------------- -- funzione che aggiunge un gruppo di ante -function WinCreate.AddSashGroup( nParentAreaId, vMeasureTypes, vDimensions, vJoints, vPartsDim, vSashTypes, vOpeningTypes, nAreaNbr, vSashNbrs) +function WinCreate.AddSashGroup( nParentAreaId, vMeasureTypes, vDimensions, bDayLight, vJoints, vPartsDim, vSashTypes, vOpeningTypes, nAreaNbr, vSashNbrs) -- se già presente sottoarea errore if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then @@ -285,7 +285,7 @@ function WinCreate.AddSashGroup( nParentAreaId, vMeasureTypes, vDimensions, vJoi end -- creo gli split di tipo french - local vAreas = WinCreate.AddSplits( nParentAreaId, WIN_SPLITORIENTATION.VERTICAL, vMeasureTypes, vDimensions, {}, true, nAreaNbr) + local vAreas = WinCreate.AddSplits( nParentAreaId, WIN_SPLITORIENTATION.VERTICAL, vMeasureTypes, vDimensions, {}, true, bDayLight, nAreaNbr) -- trasformo le aree risultanti ( che sono null) nelle aree dell'anta settando le info opportune for i = 1, #vAreas do EgtSetName( vAreas[i], EgtGetName( vAreas[i]) .. '(' .. WIN_SASH .. ')') @@ -356,9 +356,8 @@ end ---------------------------------------------------------------------------------- -- funzione che taglia lo split con il bordo della regione -local function AdjustSplitCurve( nSplitId, nCompo, vOutlineCrvs, nOutlineLayerId) +local function AdjustSplitCurve( nSplitId, nCompo) - -- trimmo lo split a filo con l'outline EgtExtendCurveStartByLen( nSplitId, 10) EgtExtendCurveEndByLen( nSplitId, 10) local ptS = EgtIP( nSplitId, nCompo, EgtSP( nSplitId)) @@ -367,37 +366,6 @@ local function AdjustSplitCurve( nSplitId, nCompo, vOutlineCrvs, nOutlineLayerId local dParE = EgtCurveParamAtPoint( nSplitId, ptE) EgtTrimCurveStartEndAtParam( nSplitId, dParS, dParE) - -- recupero le curve con cui avviene l'intersezione e le salvo come info - -- start - local dParCrvS = EgtCurveParamAtPoint( nCompo, ptS) - if abs( dParCrvS - ceil( dParCrvS)) < GEO.EPS_ZERO then - local nCrv = vOutlineCrvs[ ceil( dParCrvS) + 1] - local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId) - EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, { nOther, nCrv}) - elseif abs( dParCrvS - floor( dParCrvS)) < GEO.EPS_ZERO then - local nCrv = vOutlineCrvs[ floor( dParCrvS) + 1] - local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId) - EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, { nOther, nCrv}) - else - -- se il parametro non è intero allora l'intersezione coinvolge una sola curva - local nCrv = vOutlineCrvs[ floor( dParCrvS) + 1] - EgtSetInfo( nSplitId, WIN_SPLIT_STARTINTERS, { nCrv}) - end - - -- end - local dParCrvE = EgtCurveParamAtPoint( nCompo, ptE) - if abs( dParCrvE - ceil( dParCrvE)) < GEO.EPS_ZERO then - local nCrv = vOutlineCrvs[ ceil( dParCrvE) + 1] - local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId) - EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, { nOther, nCrv}) - elseif abs( dParCrvE - floor( dParCrvE)) < GEO.EPS_ZERO then - local nCrv = vOutlineCrvs[ floor( dParCrvE) + 1] - local nOther = EgtGetPrev( nCrv) or EgtGetLastInGroup( nOutlineLayerId) - EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, { nOther, nCrv}) - else - local nCrv = vOutlineCrvs[ floor( dParCrvE) + 1] - EgtSetInfo( nSplitId, WIN_SPLIT_ENDINTERS, { nCrv}) - end end ---------------------------------------------------------------------------------- @@ -414,17 +382,12 @@ local function GetBorderRegions( nSplitId, nCompo, nAreaId) -- aggiungo la curva di split al bordo per chiuderlo orientandola opportunamente local nSplitId1 = EgtCopyGlob( nSplitId, nAreaId) - if AreSamePointApprox( EgtSP( nSplitId1), EgtSP( nCrv1)) then - EgtInvertCurve( nSplitId1) - end EgtAddCurveCompoCurve( nCrv1, nSplitId1) local _, dParE1 = EgtCurveDomain( nCrv1) EgtCurveCompoSetTempProp( nCrv1, dParE1 - 1, nSplitId) local nSplitId2 = EgtCopyGlob( nSplitId, nAreaId) - if AreSamePointApprox( EgtSP( nSplitId2), EgtSP( nCrv2)) then - EgtInvertCurve( nSplitId2) - end + EgtInvertCurve( nSplitId2) EgtAddCurveCompoCurve( nCrv2, nSplitId2) local _, dParE2 = EgtCurveDomain( nCrv2) EgtCurveCompoSetTempProp( nCrv2, dParE2 - 1, nSplitId) @@ -452,7 +415,7 @@ local function CreateAreasFromSplits( nAreaId, vSplitCrvs) for i = 1, #vSplitCrvs do -- aggiusto lo split per averlo a filo con l'outline - AdjustSplitCurve( vSplitCrvs[i], nCompo, vOutlineCrvs, nOutlineLayerId) + AdjustSplitCurve( vSplitCrvs[i], nCompo) -- calcolo i bordi delle due regioni definite dallo split local nCrv1, nCrv2 = GetBorderRegions( vSplitCrvs[i], nCompoRef, nGrpTmp) @@ -507,7 +470,7 @@ end ---------------------------------------------------------------------------------- -- funzione che calcola le dimensioni assolute delle divisioni -local function CalcSplitDimensions( vMeasureTypes, vValues, dDim) +local function CalcSplitDimensions( vMeasureTypes, vValues, dDim, dDimMax) local vDimensions = {} -- calcolo le dimensioni di tutti gli split assoluti e percentuali e calcolo i valori di riferimento per eventuali split proporzionali @@ -539,46 +502,47 @@ local function CalcSplitDimensions( vMeasureTypes, vValues, dDim) end end + -- se dimensione massima diversa da quella di calcolo ( e.g. sottoaree di griglia) scalo le dimensioni delle aree sulla dimensione massima per fare in modo che gli split non scompaiano + if dDimMax < dDim - GEO.EPS_SMALL then + for i = 1, #vDimensions do + vDimensions[i] = vDimensions[i] * dDimMax / dDim + end + end + return vDimensions end ---------------------------------------------------------------------------------- -local function CalcSplitCurves( nLayerId, b3OutlineLayer, b3Limit, nSplitType, vMeasureTypes, vValues) +local function CalcSplitCurves( nLayerId, b3OutlineLayer, dDimMax, nSplitType, vMeasureTypes, vValues) -- calcolo le dimensioni assolute di tutti gli split - local vDimensions = CalcSplitDimensions( vMeasureTypes, vValues, EgtIf( nSplitType == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY())) - + local dDim = EgtIf( nSplitType == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY()) + if not dDimMax then + dDimMax = dDim + end + local vDimensions = CalcSplitDimensions( vMeasureTypes, vValues, dDim, dDimMax) + local vSplitCurves = {} local dPosition = 0 for i = 1, #vDimensions do -- calcolo la posizione cumulata dPosition = dPosition + vDimensions[i] - - local nSplitCrv - if nSplitType == WIN_SPLITORIENTATION.VERTICAL then - -- aree ordinate da sx a dx - local dCurrPosition = dPosition - -- creo la linea se rientra nella regione limite - local dX = b3OutlineLayer:getMin():getX() + dCurrPosition - if dX > b3Limit:getMin():getX() + GEO.EPS_SMALL and dX < b3Limit:getMax():getX() - GEO.EPS_SMALL then - nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + X_AX() * dCurrPosition, Y_AX(), b3OutlineLayer:getDimY()) + -- creo la curva se rientra nelle dimensione limite + if dPosition < dDimMax - GEO.EPS_SMALL then + local nSplitCrv + if nSplitType == WIN_SPLITORIENTATION.VERTICAL then + -- aree ordinate da sx a dx + nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + X_AX() * dPosition, Y_AX(), b3OutlineLayer:getDimY()) + elseif nSplitType == WIN_SPLITORIENTATION.HORIZONTAL then + -- aree ordinate dal basso all'alto + nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + Y_AX() * dPosition, X_AX(), b3OutlineLayer:getDimX()) + EgtInvertCurve( nSplitCrv) end - - elseif nSplitType == WIN_SPLITORIENTATION.HORIZONTAL then - -- aree ordinate dall'alto al basso - local dCurrPosition = b3OutlineLayer:getDimY() - dPosition - -- creo la linea se rientra nella regione limite - local dY = b3OutlineLayer:getMin():getY() + dCurrPosition - if dY > b3Limit:getMin():getY() + GEO.EPS_SMALL and dY < b3Limit:getMax():getY() - GEO.EPS_SMALL then - nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + Y_AX() * dCurrPosition, X_AX(), b3OutlineLayer:getDimX()) - end - end - - if nSplitCrv then + EgtSetName( nSplitCrv, WIN_SPLIT) table.insert( vSplitCurves, nSplitCrv) EgtSetInfo( nSplitCrv, WIN_SPLIT_POSITION, dPosition) - end + end end return vSplitCurves @@ -586,7 +550,7 @@ end ---------------------------------------------------------------------------------- -- funzione che crea tagli split multipli -function WinCreate.AddSplits( nParentAreaId, nSplitType, vMeasureTypes, vValues, vPartsDim, bFrench, nAreaNbr) +function WinCreate.AddSplits( nParentAreaId, nSplitType, vMeasureTypes, vValues, vPartsDim, bFrench, bDaylight, nAreaNbr) -- se area ha già sottoarea errore if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then @@ -605,21 +569,21 @@ function WinCreate.AddSplits( nParentAreaId, nSplitType, vMeasureTypes, vValues, EgtSetInfo( nAreaId, WIN_SPLIT_DIR, nSplitType) EgtSetInfo( nAreaId, WIN_MEASURE_TYPE, vMeasureTypes) EgtSetInfo( nAreaId, WIN_MEASURE_VALUE, vValues) - EgtSetInfo( nAreaId, WIN_SPLIT_REF_DIM, EgtIf( nSplitType == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY())) EgtSetInfo( nAreaId, WIN_PART_DIM, vPartsDim) - + if bFrench then + EgtSetInfo( nAreaId, WIN_SPLITTYPE, WIN_SPLITTYPES.FRENCH) + EgtSetInfo( nAreaId, WIN_DAYLIGHT_MEASURE, bDaylight) + end + -- copio il contorno dall'area parent CopyParentOutline( nAreaId, nParentAreaId) -- creo layer per split local nSplitLayerId = EgtGroup( nAreaId) EgtSetName( nSplitLayerId, WIN_BASESPLIT) - -- verifico se va impostato il tipo french - if bFrench then - EgtSetInfo( nSplitLayerId, WIN_SPLITTYPE, WIN_SPLITTYPES.FRENCH) - end + -- creo le curve di split - local vSplitCurves = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, b3OutlineLayer, nSplitType, vMeasureTypes, vValues) + local vSplitCurves = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, nil, nSplitType, vMeasureTypes, vValues) if #vSplitCurves == 0 then -- se non ci sono curve valide cancello tutto ed esco EgtErase( nAreaId) @@ -633,7 +597,7 @@ end ---------------------------------------------------------------------------------- -- funzione che crea tagli split grid -function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues, vHorizMeasureTypes, vHorizValues, bStartVertical, vPartsDim, nAreaNbr) +function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues, vHorizMeasureTypes, vHorizValues, bStartVertical, vVertDim, vHorizDim, nAreaNbr) local AreaResult = {} @@ -649,7 +613,6 @@ function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues, EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.SPLIT) EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr) EgtSetInfo( nAreaId, WIN_GRID_SPLIT, true) - EgtSetInfo( nAreaId, WIN_PART_DIM, vPartsDim) -- copio il contorno dall'area parent e setto opportune corrispondenze sou/child local nOutlineLayerId = CopyParentOutline( nAreaId, nParentAreaId) @@ -659,57 +622,75 @@ function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues, local nSplitLayerId = EgtGroup( nAreaId) EgtSetName( nSplitLayerId, WIN_BASESPLIT) - -- stabilisco direzione principale e secondaria - local vMainTypes, vOtherTypes, vMainValues, vOtherValues, nMainSplitOrientation, nOtherSplitOrientation + -- stabilisco dati per direzione principale e secondaria + local vMainTypes, vOtherTypes, vMainValues, vOtherValues, nMainSplitOrientation, nOtherSplitOrientation, vMainDim, vOtherDim if bStartVertical then vMainTypes = vVertMeasureTypes vMainValues = vVertValues nMainSplitOrientation = WIN_SPLITORIENTATION.VERTICAL + vMainDim = vVertDim vOtherTypes = vHorizMeasureTypes vOtherValues = vHorizValues nOtherSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL + vOtherDim = vHorizDim else vMainTypes = vHorizMeasureTypes vMainValues = vHorizValues nMainSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL + vMainDim = vHorizDim vOtherTypes = vVertMeasureTypes vOtherValues = vVertValues nOtherSplitOrientation = WIN_SPLITORIENTATION.VERTICAL + vOtherDim = vVertDim end -- salvo i dati dello split principale nell'area principale, i dati dello split secondario verranno salvati nelle aree virtuali EgtSetInfo( nAreaId, WIN_SPLIT_DIR, nMainSplitOrientation) EgtSetInfo( nAreaId, WIN_MEASURE_TYPE, vMainTypes) EgtSetInfo( nAreaId, WIN_MEASURE_VALUE, vMainValues) - EgtSetInfo( nAreaId, WIN_SPLIT_REF_DIM, EgtIf( nMainSplitOrientation == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY())) + EgtSetInfo( nAreaId, WIN_PART_DIM, vMainDim) -- calcolo la suddivisione nella direzione principale - local vMainSplit = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, b3OutlineLayer, nMainSplitOrientation, vMainTypes, vMainValues) + local vMainSplit = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, nil, nMainSplitOrientation, vMainTypes, vMainValues) for i = 1, #vMainSplit do EgtSetInfo( vMainSplit[i], WIN_GRIDSPLIT_ORDER, 0) end local vMainAreas = CreateAreasFromSplits( nAreaId, vMainSplit) - -- per ogni area della direzione principale calcolo la suddivisione nella direzione secondaria + -- calcolo gli split nella direzione secondaria. Per non far sparire split nelle sottoregioni più piccole tengo come misura di riferimento per scalare tutte le dimensioni quella + -- della sottoregione più piccola + local dMinDim = GEO.INFINITO for i = 1, #vMainAreas do - -- recupero outline per calcolare il limite delle curve di split local nAreaOutlineLayerId = EgtGetFirstNameInGroup( vMainAreas[i], WIN_AREAOUTLINE) - local b3Limit = EgtGetBBox( nAreaOutlineLayerId, GDB_BB.STANDARD) - - -- calcolo gli split nella direzione secondaria - local vOtherSplit = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, b3Limit, nOtherSplitOrientation, vOtherTypes, vOtherValues) - if #vOtherSplit > 0 then - for j = 1, #vOtherSplit do - EgtSetInfo( vOtherSplit[j], WIN_GRIDSPLIT_ORDER, tostring( i)) - end - -- calcolo le aree generate dagli split secondari - local vNewAreas = CreateAreasFromSplits( vMainAreas[i], vOtherSplit) - AreaResult = EgtJoinTables( AreaResult, vNewAreas) + local b3Curr = EgtGetBBox( nAreaOutlineLayerId, GDB_BB.STANDARD) + local dDim = EgtIf( nOtherSplitOrientation == WIN_SPLITORIENTATION.VERTICAL, b3Curr:getDimX(), b3Curr:getDimY()) + if dDim < dMinDim - GEO.EPS_SMALL then + dMinDim = dDim end end + local vOtherSplitOrig = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, dMinDim, nOtherSplitOrientation, vOtherTypes, vOtherValues) + + for i = 1, #vMainAreas do + + -- copio gli split della direzione secondaria + local vOtherSplit = {} + for j = 1, #vOtherSplitOrig do + vOtherSplit[j] = EgtCopyGlob( vOtherSplitOrig[j], nSplitLayerId) + EgtSetInfo( vOtherSplit[j], WIN_GRIDSPLIT_ORDER, i) + end + + -- calcolo le aree generate dagli split secondari + local vNewAreas = CreateAreasFromSplits( vMainAreas[i], vOtherSplit) + for j = 1, #vNewAreas do + EgtSetInfo( vNewAreas[j], WIN_GRIDSPLIT_ORDER, i) + end + AreaResult = EgtJoinTables( AreaResult, vNewAreas) + end + + EgtErase( vOtherSplitOrig) -- sposto le aree secondarie nell'area di split e le rinomino - for i = 1, #AreaResult do + for i = 1, #AreaResult do EgtRelocateGlob( AreaResult[i], nAreaId) EgtSetName( AreaResult[i], WIN_AREA .. EgtNumToString( i)) end @@ -720,7 +701,7 @@ function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues, EgtSetInfo( vMainAreas[i], WIN_SPLIT_DIR, nOtherSplitOrientation) EgtSetInfo( vMainAreas[i], WIN_MEASURE_TYPE, vOtherTypes) EgtSetInfo( vMainAreas[i], WIN_MEASURE_VALUE, vOtherValues) - EgtSetInfo( vMainAreas[i], WIN_SPLIT_REF_DIM, EgtIf( nOtherSplitOrientation == WIN_SPLITORIENTATION.VERTICAL, b3OutlineLayer:getDimX(), b3OutlineLayer:getDimY())) + EgtSetInfo( vMainAreas[i], WIN_PART_DIM, vOtherDim) end return AreaResult diff --git a/Designing/WinLib/WinManageProject.lua b/Designing/WinLib/WinManageProject.lua index 565c757..f41351a 100644 --- a/Designing/WinLib/WinManageProject.lua +++ b/Designing/WinLib/WinManageProject.lua @@ -47,19 +47,6 @@ local function GetDimensions( tDimensions) return vDims end ---------------------------------------------------------------------- -local function GetSplitDimensions( tDimensions) - local vDims = {} - for i = 1, #tDimensions do - local nIndex = tDimensions[i][JWD_INDEX] - local nArea = tDimensions[i][JWD_SPLIT_AREA] - if not vDims[nArea] then - vDims[nArea] = {} - end - vDims[nArea][nIndex] = tDimensions[i][JWD_VALUE] - end - return vDims -end --------------------------------------------------------------------- local function GetFrameShape( sShape) @@ -237,9 +224,10 @@ local function ConvertTableToGeometry( AreaTable, nParentId) -- recupero dati local tSashes = AreaTable[JWD_SASH_LIST] local nBottomRailNbr = 0 - local vElementDim = GetDimensions( AreaTable[JWD_BR_ELEMENT_DIMENSION]) + local vElementDim = {} if AreaTable[JWD_BOTTOMRAIL] then nBottomRailNbr = AreaTable[JWD_BOTTOMRAIL_QTY] + vElementDim = GetDimensions( AreaTable[JWD_BR_ELEMENT_DIMENSION]) end -- lettura opzioni ferramenta @@ -297,9 +285,10 @@ local function ConvertTableToGeometry( AreaTable, nParentId) vPartsDim[i] = GetDimensions( tSashes[i][JWD_ELEMENT_DIMENSION]) end local vSashTypes, sHandleSide = GetSashTypes( tSashes, vOpeningTypes) + local bDaylight = AreaTable[JWD_MEASURE_DAYLIGHT] -- aggiungo il gruppo di ante - local vAreas = WinCreate.AddSashGroup( nParentId, vMeasureType, vDimensions, vJoints, vPartsDim, vSashTypes, vOpeningTypes, nAreaNbr, vSashNbrs) + local vAreas = WinCreate.AddSashGroup( nParentId, vMeasureType, vDimensions, bDaylight, vJoints, vPartsDim, vSashTypes, vOpeningTypes, nAreaNbr, vSashNbrs) -- aggiungo le ante for i = 1, #vAreas do -- bottomrail @@ -325,7 +314,7 @@ local function ConvertTableToGeometry( AreaTable, nParentId) elseif AreaTable[JWD_AREA_TYPE] == 'SPLIT' then local vVertDimensions = {} local vVertMeasureType = {} - local vVertElementDimension = GetSplitDimensions(AreaTable[JWD_ELEMENT_VERT_DIMENSION]) + local vVertElementDimension = GetDimensions( AreaTable[JWD_ELEMENT_VERT_DIMENSION]) local vSplitVertDimensions = AreaTable[JWD_SPLIT_VERT_POS] for i = 1, #vSplitVertDimensions do vVertMeasureType[i] = GetMeasureType( vSplitVertDimensions[i][JWD_MEASURE_TYPE]) @@ -333,7 +322,7 @@ local function ConvertTableToGeometry( AreaTable, nParentId) end local vHorizDimensions = {} local vHorizMeasureType = {} - local vHorizElementDimension = GetSplitDimensions(AreaTable[JWD_ELEMENT_HORIZ_DIMENSION]) + local vHorizElementDimension = GetDimensions( AreaTable[JWD_ELEMENT_HORIZ_DIMENSION]) local vSplitHorizDimensions = AreaTable[JWD_SPLIT_HORIZ_POS] for i = 1, #vSplitHorizDimensions do vHorizMeasureType[i] = GetMeasureType( vSplitHorizDimensions[i][JWD_MEASURE_TYPE]) @@ -341,23 +330,12 @@ local function ConvertTableToGeometry( AreaTable, nParentId) end local vSplitAreas if AreaTable[JWD_SPLIT_TYPE] == 'GRID' then - local vElementDimension = {} - if AreaTable[JWD_SPLIT_START_VERT] then - vElementDimension = vVertElementDimension[0] - for i = 1, #vHorizElementDimension do - EgtJoinTables( vElementDimension, vHorizElementDimension[i]) - end - else - vElementDimension = vHorizElementDimension[0] - for i = 1, #vVertElementDimension do - EgtJoinTables( vElementDimension, vVertElementDimension[i]) - end - end - vSplitAreas = WinCreate.AddGridSplits( nParentId, vVertMeasureType, vVertDimensions, vHorizMeasureType, vHorizDimensions, AreaTable[JWD_SPLIT_START_VERT], vElementDimension, nAreaNbr) + vSplitAreas = WinCreate.AddGridSplits( nParentId, vVertMeasureType, vVertDimensions, vHorizMeasureType, vHorizDimensions, AreaTable[JWD_SPLIT_START_VERT], + vVertElementDimension, vHorizElementDimension, nAreaNbr) elseif AreaTable[JWD_SPLIT_TYPE] == 'VERTICAL' then - vSplitAreas = WinCreate.AddSplits( nParentId, WIN_SPLITORIENTATION.VERTICAL, vVertMeasureType, vVertDimensions, vVertElementDimension[0], false, nAreaNbr) + vSplitAreas = WinCreate.AddSplits( nParentId, WIN_SPLITORIENTATION.VERTICAL, vVertMeasureType, vVertDimensions, vVertElementDimension[0], false, true, nAreaNbr) else - vSplitAreas = WinCreate.AddSplits( nParentId, WIN_SPLITORIENTATION.HORIZONTAL, vHorizMeasureType, vHorizDimensions, vHorizElementDimension[0], false, nAreaNbr) + vSplitAreas = WinCreate.AddSplits( nParentId, WIN_SPLITORIENTATION.HORIZONTAL, vHorizMeasureType, vHorizDimensions, vHorizElementDimension[0], false, true, nAreaNbr) end for i = 1, #vSplitAreas do ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][i], vSplitAreas[i]) diff --git a/Designing/WinProject.lua b/Designing/WinProject.lua index 870c165..bcce315 100644 --- a/Designing/WinProject.lua +++ b/Designing/WinProject.lua @@ -512,8 +512,7 @@ local function WinGetAreaProfiles() table.insert( tabProfiles, { GroupId = vAreaNbrs[i], EntId = 1, Profiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES, 'vs')}) elseif nAreaType == WIN_AREATYPES.SPLIT then - local nSplitLayId = EgtGetFirstNameInGroup( vAreaIds[i], WIN_SPLIT) - local nSplitType = EgtGetInfo( nSplitLayId, WIN_SPLITTYPE, 'i') + local nSplitType = EgtGetInfo( vAreaIds[i], WIN_SPLITTYPE, 'i') -- se french split devo recuperare le ante che definisce if nSplitType == WIN_SPLITTYPES.FRENCH then local vSashes = EgtGetNameInGroup( vAreaIds[i], WIN_AREA .. '*')