Egalware/egwwindowlua
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: Egalware/egwwindowlua:CreateMachGroups
Branches Tags
Egalware/egwwindowlua:main Egalware/egwwindowlua:CreateMachGroups Egalware/egwwindowlua:develop Egalware/egwwindowlua:CAM_Auto
Egalware/egwwindowlua:AutoSave_2024/10/01 Egalware/egwwindowlua:AutoSave_2024/03/08 Egalware/egwwindowlua:AutoSave_2024/02/02
...
pull from: Egalware/egwwindowlua:main
Branches Tags
Egalware/egwwindowlua:main Egalware/egwwindowlua:CreateMachGroups Egalware/egwwindowlua:develop Egalware/egwwindowlua:CAM_Auto
Egalware/egwwindowlua:AutoSave_2024/10/01 Egalware/egwwindowlua:AutoSave_2024/03/08 Egalware/egwwindowlua:AutoSave_2024/02/02

17 Commits
CreateMachGroups ... main

Author SHA1 Message Date
Annamaria Sassi 0fdeaaf619 CAMAuto : 
correzione per evitare doppio spostamento pezzo nel grezzo.
 2026-05-06 09:09:14 +02:00
SaraP 65e0b550c6 DataWindow : 
- cambio profilo su split
- sistemata identificazione dei cambi profilo dopo gli spostamenti degli outlines degli split per misura luce
- preview con pezzi dello stesso colore.
 2026-04-23 15:39:35 +02:00
Annamaria Sassi e05890f9a8 DataWindow : 
- correzione numero area.
 2026-04-14 14:39:06 +02:00
SaraP 52cc15686e DataWindow : 
- lettura inglesina da jwd.
 2026-04-13 11:01:29 +02:00
SaraP 52853e953c DataWindow 
- inglesine.
 2026-04-07 09:53:11 +02:00
SaraP f8eab3581c DataWindow : 
- gestione dei pezzi di ante troppo piccoli che scompaiono
- correzione nel calcolo outline sash e fill nel caso di cambio profilo
- migliorie nel calcolo solidi e lavorazioni.
 2026-04-01 09:19:23 +02:00
Annamaria Sassi 1ff7a583fa DataWindow : 
- corretto passaggio dimensione elementi per split.
 2026-02-23 14:39:18 +01:00
Annamaria Sassi ff953deaff CAMAuto : 
- Raggruppate funzioni riguardati i pezzi in PartData.
 2026-02-20 09:55:15 +01:00
andrea.villa e623f2d789 Nuova versione BatchProcess: 
- gestione WIN.FLAG ( per ora valori ammessi 0, 1 e 2)
- Cancellato funzioni non più utilizzate
- Aggiunta nuove funzioni scrittura file di log
- Aggiunta stima tempi
 2026-02-19 09:33:25 +01:00
Emmanuele Sassi f793af4d44 - aggiunto passaggio dati da script web 
- modificato process che non crea più il grezzo ma utilizza quello presente
 2026-02-17 10:43:28 +01:00
Annamaria Sassi 12b5794e49 - Aggiunto caricamento librerie in CreateMachGroups 
- Piccola correzione in WinLib
 2026-02-12 18:34:41 +01:00
Annamaria Sassi f2b05d3fd7 DataWindow : 
- modifica a WinGetAreaProfiles per cambiare valore di default EntId per split non a griglia.
 2026-02-12 12:18:03 +01:00
SaraP 5f8a44aecc DataWindow : 
- modifica a GetProfileData per overlap ante battenti/riceventi.
 2026-02-11 09:40:07 +01:00
SaraP 315a6159fe DataWindow : 
- aggiornato il main per ultime modifiche.
 2026-02-10 17:04:53 +01:00
Annamaria Sassi c5ce236cf7 DataWindow : 
- correzione creazione split.
 2026-02-10 16:03:51 +01:00
SaraP ad8eec53e0 DataWindow : 
- dimensioni degli split date come luce o esterno anta
- aree split orizzontali ordinate dal basso all'alto ( e non più dall'alto al basso)
- dimensioni dei pezzi di split a griglia differenziate per direzioni e non per pezzi.
 2026-02-09 12:52:24 +01:00
andrea.villa 3c04c2ae7b Merge branch 'CreateMachGroups' 2026-02-06 11:29:01 +01:00
13 changed files with 5044 additions and 3199 deletions
Expand all files Collapse all files
CAMAuto/BatchProcessWin.lua
+202 -257
View File
@@ -1,33 +1,60 @@
-- BatchProcessNew.lua by Egalware s.r.l. 2025/04/24
-- BatchProcessNew.lua by Egalware s.r.l. 2026/02/09
-- Applicazione lavorazioni, simulazione, generazione e stima
-- Intestazioni
require( 'EgtBase')
_ENV = EgtProtectGlobal()
EgtEnableDebug( false)
-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-- TODO DA CANCELLARE!!!! quando verrà passato automaticamente da programma
local WIN = {}
WIN.BASEDIR = 'C:\\EgtData\\Window\\CAMAuto'
WIN.FILE = 'C:\\Temp\\Window.nge'
--local WIN = {}
--WIN.BASEDIR = 'C:\\EgtData\\Window\\CAMAuto'
--WIN.FILE = 'C:\\Temp\\TestSerramenti\\4.bwe'
--WIN.MACHINE = 'Saomad-Just3500'
--WIN.FLAG = 2
-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-- Imposto direttorio libreria specializzata per serramenti
EgtAddToPackagePath( WIN.BASEDIR .. '\\LuaLibs\\?.lua')
-- Imposto direttorio strategie. N.B. Le strategie dovranno essere caricate con il nome del direttorio padre
EgtAddToPackagePath( WIN.BASEDIR .. '\\Strategies\\?.lua')
local sTxtLogFile = EgtChangePathExtension( WIN.FILE, '.txt')
-- carico il progetto
EgtOpenFile( WIN.FILE)
-- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
local nMachGroupId = EgtGetFirstMachGroup()
if not nMachGroupId then
EgtOutLog( 'Errore! Nessun gruppo di lavorazione presente!')
return
end
EgtSetCurrMachGroup( nMachGroupId)
-- controlli preliminari
local sMachDir = EgtGetCurrMachineDir()
local sMachine = WIN.MACHINE
EgtResetCurrMachGroup()
if not sMachDir then
EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Serramenti', 'ERROR')
WIN.ERR = 11
WIN.MSG = 'Errore nel caricamento della macchina corrente'
WriteErrToLogFile( WIN.ERR, WIN.MSG)
return
end
if not EgtExistsFile( sMachDir .. '\\Window\\WinData.lua') then
EgtOutBox( 'La macchina corrente non è configurata per lavorare serramenti', 'Lavora Serramenti', 'ERROR')
WIN.ERR = 11
WIN.MSG = 'La macchina corrente non è configurata per lavorare serramenti'
WriteErrToLogFile( WIN.ERR, WIN.MSG)
return
end
if not EgtSetCurrMachine( sMachine) then
WIN.ERR = 11
WIN.MSG = 'Error selecting machine : ' .. sMachine
WriteErrToLogFile( WIN.ERR, WIN.MSG)
return
end
local sTxtLogFile = EgtChangePathExtension( WIN.FILE, '.txt')
-- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie
EgtRemoveBaseMachineDirFromPackagePath()
@@ -44,6 +71,9 @@ _G.package.loaded.FeatureData = nil
_G.package.loaded.MachiningLib = nil
local WinExec = require( 'WinExec')
local WinLib = require( 'WinLib')
local JSON = require( 'JSON')
local PartData = require( 'PartData')
-- Carico i dati globali
local WinData = require( 'WinData')
@@ -51,9 +81,6 @@ local WinData = require( 'WinData')
-- Variabili globali
PARTS = {} -- tabella contenente tutte le informazioni di ogni pezzo
-- Colore del grezzo
local ColA = Color3d( 255, 165, 0, 30)
-------------------------------------------------------------------------------------------------------------
local function GetDataConfig()
-- recupero utensili dal magazzino
@@ -63,6 +90,25 @@ local function GetDataConfig()
return true
end
-------------------------------------------------------------------------------------------------------------
-- scrittura JSON risultati
-- TODO da migliorare/completare
local function WriteResultToJson( RESULT)
local sData = JSON:encode_pretty( RESULT)
-- Salvataggio e visualizzazione tabella
local sOutFile = EgtChangePathExtension( WIN.FILE, '.json')
local DestFh = io.open( sOutFile, 'w+')
if not DestFh then
EgtOutBox( 'Error opening ' .. sOutFile, 'TestJson', 'ERROR')
return false
end
DestFh:write( sData)
DestFh:close()
return true
end
-------------------------------------------------------------------------------------------------------------
local function WriteErrToLogFile( nErr, sMsg, nRot, idCut, idTask)
local hFile = io.open( sTxtLogFile, 'a')
@@ -74,200 +120,49 @@ local function WriteErrToLogFile( nErr, sMsg, nRot, idCut, idTask)
hFile:close()
end
local function WriteTimeToLogFile( dTime)
local hFile = io.open( sTxtLogFile, 'a')
hFile:write( 'TIME=' .. EgtNumToString( dTime) .. '\n')
hFile:close()
end
-------------------------------------------------------------------------------------------------------------
-- *** Recupero i pezzi da processare ***
-------------------------------------------------------------------------------------------------------------
local function MyProcessInputData()
-- Recupero le travi selezionate
local nId = EgtGetFirstInGroup( GDB_ID.ROOT)
local nId = EgtGetFirstPart()
while nId do
-- Per capire se è un pezzo controllo una nota, servirebbe info dedicata, oppure essere sicuri che vengano passati solo pezzi
if EgtGetInfo( nId, 'OFFY_1', 'd') then
-- TODO caricare il file di costanti
-- si processano solo BOTTOMRAIL (WIN_PART_TYPES.BOTTOMRAIL = 2) o STANDARD (WIN_PART_TYPES.STD = 3)
if EgtGetInfo( nId, 'PART_TYPE', 'd') == 2 or EgtGetInfo( nId, 'PART_TYPE', 'd') == 3 then
table.insert( PARTS, { id = nId, sName = ( EgtGetName( nId) or ( 'Id=' .. tonumber( nId)))})
-- TODO RIMUOVERE! Bisogna sempre prendere tuttti i pezzi all'interno del file. Devono arrivare solo i pezzi da mettere nella macchinata
if #PARTS == 2 then
break
end
end
nId = EgtGetNext( nId)
end
if #PARTS == 0 then
EgtOutBox( 'Non ci sono pezzi', 'Lavora Pezzi', 'ERROR')
return false
else
-- recupero tutte le dimensioni necessarie
local sOut = ''
for i = 1, #PARTS do
PARTS[i].b3Raw = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'GeoRaw') or GDB_ID.NULL, GDB_BB.STANDARD)
PARTS[i].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Geo') or GDB_ID.NULL, GDB_BB.STANDARD)
local idFrame = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( PARTS[i].id, 'GeoRaw'), 'AuxFrame')
PARTS[i].frame = EgtFR( idFrame)
sOut = sOut .. PARTS[i].sName .. ', '
end
sOut = sOut:sub( 1, -3)
EgtOutLog( 'Pezzi selezionati : ' .. sOut, 1)
end
PartData.GetDimensionPart( PARTS)
EgtDeselectAll()
return true
end
-------------------------------------------------------------------------------------------------------------
local function GetDispOffsetFromNotes( nPieceIndex)
local bAllOffsetsAreOk = false
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetX = 0 -- dovrà essere calcolato in base alle lavorazioni
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFY_1', 'd')
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFZ_1', 'd')
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetX = 0 -- dovrà essere calcolato in base alle lavorazioni
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFY_2', 'd')
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFZ_2', 'd')
-- controllo se tutti gli offset siano settati
if PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY and PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ and
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY and PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ then
bAllOffsetsAreOk = true
end
return bAllOffsetsAreOk
end
-------------------------------------------------------------------------------------------------------------
local function GetDispOffsetFromInput( nPieceIndex)
-- assegno alle stringhe i valori letti, in modo che vengano proposti quelli nel dialogo
local sOffYPh1 = EgtIf( PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY, tostring( PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY), tostring( PARTS[nPieceIndex].dPartWidth / 2))
local sOffZPh1 = EgtIf( PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ, tostring( PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ), '0')
local sOffYPh2 = EgtIf( PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY, tostring( PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY), tostring( PARTS[nPieceIndex].dPartWidth / 2))
local sOffZPh2 = EgtIf( PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ, tostring( PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ), '0')
local vInp = EgtDialogBox( 'Dati di disposizione pezzo: ' .. PARTS[nPieceIndex].sName,
{'Sporgenza laterale FASE1', sOffYPh1}, {'Posizione Z FASE1', sOffZPh1},
{'Sporgenza laterale FASE2', sOffYPh2}, {'Posizione Z FASE2', sOffZPh2})
if not vInp or #vInp == 0 then
return false
end
-- salvo input nei valori che utilizzerò dopo
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY = tonumber( vInp[1])
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ = tonumber( vInp[2])
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY = tonumber( vInp[3])
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ = tonumber( vInp[4])
return true
end
---------------------------------------------------------------------
-- Crea il grezzo che verrà messo in macchina
---------------------------------------------------------------------
local function AddOverMaterialToRaw( PARTS)
for i = 1, #PARTS do
-- prima di aggiungere sovramateriale al grezzo, calcolo dimensioni del finito
local b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Geo') or GDB_ID.NULL, GDB_BB.STANDARD)
PARTS[i].b3Part = b3Part
PARTS[i].dPartLength = PARTS[i].b3Part:getDimX()
PARTS[i].dPartWidth = PARTS[i].b3Part:getDimY()
PARTS[i].dPartHeight = PARTS[i].b3Part:getDimZ()
-- recupero sovramateriale
PARTS[i].RawOffset = {}
-- recupero info sovramateriale
PARTS[i].RawOffset.dOverMatIn = EgtGetInfo( PARTS[i].id, 'OVERMAT_IN', 'd') or 5
PARTS[i].RawOffset.dOverMatOut = EgtGetInfo( PARTS[i].id, 'OVERMAT_OUT', 'd') or 5
PARTS[i].RawOffset.dOverMatLeft = EgtGetInfo( PARTS[i].id, 'OVERMAT_LEFT', 'd') or 5
PARTS[i].RawOffset.dOverMatRight = EgtGetInfo( PARTS[i].id, 'OVERMAT_RIGHT', 'd') or 5
PARTS[i].dRawLength = PARTS[i].RawOffset.dOverMatLeft + PARTS[i].dPartLength + PARTS[i].RawOffset.dOverMatRight
PARTS[i].dRawWidth = PARTS[i].RawOffset.dOverMatOut + PARTS[i].dPartWidth + PARTS[i].RawOffset.dOverMatIn
PARTS[i].dRawHeight = PARTS[i].dPartHeight
EgtModifyRawPartSize( PARTS[i].idRaw, PARTS[i].dRawLength, PARTS[i].dRawWidth, PARTS[i].dPartHeight)
local vtMove = Vector3d( PARTS[i].RawOffset.dOverMatLeft, PARTS[i].RawOffset.dOverMatOut, 0)
EgtMovePartInRawPart( PARTS[i].id, vtMove)
-- TODO da controllare, se ruotato di 180° bisognerebbe prendere dOverMatIn. Lo stesso per la X
PARTS[i].OffsetPartToRaw = {}
PARTS[i].OffsetPartToRaw.X = PARTS[i].RawOffset.dOverMatLeft
PARTS[i].OffsetPartToRaw.Y = PARTS[i].RawOffset.dOverMatOut
end
end
---------------------------------------------------------------------
-- Crea il grezzo che verrà messo in macchina
---------------------------------------------------------------------
local function CreateRaws( PARTS)
for i = 1, #PARTS do
-- si crea un grezzo "finto" (un cubo da 100mm) nell'origine del pezzo, verrà poi dimensionato uan volta adeguato con i vari sovramateriali
PARTS[i].idRaw = EgtAddRawPart( PARTS[i].frame:getOrigin(), 100, 100, 100, ColA)
EgtAddPartToRawPart( PARTS[i].id, ORIG(), PARTS[i].idRaw)
end
end
---------------------------------------------------------------------
-- Allinea i pezzi in base a come devono essere disposti sulla tavola
---------------------------------------------------------------------
-- TODO in questa fase bisogna già sapere qual è la prima fase e posizionare il pezzo di conseguenza
-- TODO (bassa priorità) adesso allinea sempre in X, ma bisognerebbe farlo in base ad un parametro in WINDATA che dice come si dispongono in macchina
local function AlignRawsToTable( PARTS)
for i = 1, #PARTS do
-- allineo il pezzo all'interno del grezzo
local dRotX, dRotY, dRotZ = GetFixedAxesRotABCFromFrame( PARTS[i].frame)
-- se devo ruotare
if abs( dRotZ) > GEO.EPS_ANG_SMALL then
EgtRotatePartInRawPart( PARTS[i].id, Z_AX(), -dRotZ)
end
-- sposto punto in basso a sinistra del pezzo sul punto in basso a sinistra del grezzo
local b3Part = EgtGetBBoxGlob( PARTS[i].id, GDB_BB.ONLY_VISIBLE)
local dPartPosX = b3Part:getMin():getX()
local dPartPosY = b3Part:getMin():getY()
local dPartPosZ = b3Part:getMin():getZ()
local b3Raw = EgtGetRawPartBBox( PARTS[i].idRaw)
local dRawPosX = b3Raw:getMin():getX()
local dRawPosY = b3Raw:getMin():getY()
local dRawPosZ = b3Raw:getMin():getZ()
local vtMove = Vector3d( dRawPosX - dPartPosX, dRawPosY - dPartPosY, dRawPosZ - dPartPosZ)
EgtMovePartInRawPart( PARTS[i].id, vtMove)
end
return true
end
-------------------------------------------------------------------------------------------------------------
-- *** Funzione per trovare nome MachGroup ***
-------------------------------------------------------------------------------------------------------------
local function NewMachGroupName()
local nMachGroupId = EgtGetFirstMachGroup()
if not nMachGroupId then return '1' end
local nMaxMachGroup = 0
while nMachGroupId do
local sMachGroupName = EgtGetMachGroupName( nMachGroupId)
local nMachGroupName = tonumber( sMachGroupName)
if nMachGroupName > nMaxMachGroup then
nMaxMachGroup = nMachGroupName
end
nMachGroupId = EgtGetNextMachGroup( nMachGroupId)
end
return tostring( nMaxMachGroup + 1)
end
-------------------------------------------------------------------------------------------------------------
-- *** Inserimento delle travi nel grezzo ***
-- *** Inserimento dei pezzi nel grezzo ***
-------------------------------------------------------------------------------------------------------------
local function MyProcessPieces()
-- creo macchinata
local MachGroupName = NewMachGroupName()
local nMachGroup = EgtAddMachGroup( MachGroupName)
-- recupero macchinata (è sempre la prima e ce n'è solo una)
local nMachGroup = EgtGetFirstMachGroup()
EgtSetCurrMachGroup( nMachGroup)
-- si crea il grezzo
CreateRaws( PARTS)
-- allineo i pezzi come orientamento richiesto dalla macchina
AlignRawsToTable( PARTS)
for i = 1, #PARTS do
PARTS[i].idRaw = EgtGetRawPartFromPart( PARTS[i].id)
end
-- aggiungo sovramateriale ai grezzi
AddOverMaterialToRaw( PARTS)
PartData.AddOverMaterialToRaw( PARTS)
-- recupero offset per posizionamento
for i = 1, #PARTS do
@@ -275,24 +170,21 @@ local function MyProcessPieces()
PARTS[i].DispOffsets.Phase1 = {}
PARTS[i].DispOffsets.Phase2 = {}
local bInsertedAllOffs = GetDispOffsetFromNotes( i)
-- se non sono settati nelle note, li chiedo
if not bInsertedAllOffs then
bInsertedAllOffs = GetDispOffsetFromInput( i)
end
local bInsertedAllOffs = PartData.GetDispOffsetFromNotes( PARTS, i)
-- se non sono stati inseriti o c'è stato un errore esco subito
if not bInsertedAllOffs then
EgtOutBox( 'Errore offset non trovati', 'BatchProcessWin', 'ERROR', 'OK')
return false
end
end
-- si dispongono i pezzi sulla tavola
local bDispOk, sErr = WinData.ExecDisposition( PARTS)
local bDispOk, sErr = WinData.AdjustDisposition( PARTS)
if not bDispOk then
if not sErr then
sErr = 'Errore non gestito in WinData.ExecDisposition'
sErr = 'Errore non gestito in WinData.AdjustDisposition'
end
EgtOutBox( sErr, 'ProcessWin', 'ERROR', 'OK')
EgtOutBox( sErr, 'BatchProcessWin', 'ERROR', 'OK')
return false
end
@@ -305,91 +197,126 @@ local function MyProcessPieces()
return true
end
-------------------------------------------------------------------------------------------------------------
-- *** Inserimento delle lavorazioni ***
-------------------------------------------------------------------------------------------------------------
local function MyProcessFeatures()
local bOk = WinExec.ProcessFeatures( PARTS)
return true
end
-------------------------------------------------------------------------------------------------------------
-- *** Esecuzione ***
-------------------------------------------------------------------------------------------------------------
-- WIN.FLAG :
-- 0 = generazione e stima, esegue solo un aggiornamento (eventuale) delle lavorazioni
-- 1 = da processare completamente, applicazione lavorazioni, simulazione, generazione e stima
-- 2 = da processare in preverifica, applicazione lavorazioni e stima
-- script principale
-- In generale va completamente riprocessato
local bToProcess = true
local bToRecalc = false
local bCheckNoSim = false
local sFlag = ''
if WIN.FLAG == 0 then
sFlag = 'CHECK+GENERATE'
-- se il progetto deve essere completamente riprocessato
if WIN.FLAG == 1 then
bToProcess = true
-- se deve essere fatta la preverifica, senza simulazione
elseif WIN.FLAG == 2 then
bToProcess = true
bCheckNoSim = true
-- altrimenti solo aggiornato (se necessario)
else
sFlag = 'FLAG='..tostring( WIN.FLAG)
bToProcess = false
end
local sLog = 'BatchProcess : ' .. WIN.FILE .. ', ' .. ( WIN.MACHINE or EgtGetCurrMachineName()) .. ', ' .. sFlag
local sLog = 'BatchProcess : ' .. WIN.FILE .. ', ' .. ( WIN.MACHINE or EgtGetCurrMachineName()) .. ', ' .. 'FLAG='..tostring( WIN.FLAG)
EgtOutLog( sLog)
-- Se da elaborare
EgtOutLog( ' +++ Processing Parts >>>')
-- se bisogna processare
if bToProcess then
-- Se da elaborare
EgtOutLog( ' +++ Processing Parts >>>')
-- nascondo geometrie varie
local vAuxId = { EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Profile'), EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Area*'), EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Aux')}
EgtSetStatus( vAuxId, GDB_ST.OFF)
-- nascondo geometrie varie
local vAuxId = { EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Profile'), EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Area*'), EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Aux')}
EgtSetStatus( vAuxId, GDB_ST.OFF)
if not MyProcessInputData() then return end
if not MyProcessInputData() then return end
if not MyProcessPieces() then return end
if not MyProcessPieces() then return end
if not GetDataConfig() then return end
if not GetDataConfig() then return end
-- Abilito Vmill
EgtSetInfo( EgtGetCurrMachGroup(), 'Vm', '1')
-- Abilito Vmill
EgtSetInfo( EgtGetCurrMachGroup(), 'Vm', '1')
if not MyProcessFeatures() then return end
WinExec.ProcessFeatures( PARTS)
-- Imposto Nome file CN
local _, sName, _ = EgtSplitPath( WIN.FILE)
EgtSetInfo( EgtGetCurrMachGroup(), 'NcName', sName .. '.cnc')
-- Imposto Nome file CN
local _, sName, _ = EgtSplitPath( WIN.FILE)
EgtSetInfo( EgtGetCurrMachGroup(), 'NcName', sName .. '.cnc')
-- Salvo il progetto
EgtSaveFile( WIN.FILE)
-- Salvo il progetto
EgtSaveFile( WIN.FILE)
-- *** Eseguo simulazione con verifica collisione in cieco ***
local bSimOk, nErr, sErr = EgtSimulate()
if not bSimOk then
if nErr == MCH_SHE.INIT then
WIN.ERR = 19
WIN.MSG = 'Error starting simulation'
elseif nErr == MCH_SHE.COLLISION then
WIN.ERR = 22
WIN.MSG = 'Head-part collision'
elseif nErr == MCH_SHE.OUTSTROKE then
WIN.ERR = 23
WIN.MSG = 'Axis outstroke ' .. sErr
elseif nErr == MCH_SHE.SPECIAL then
WIN.ERR = 24
WIN.MSG = 'Special error ' .. sErr
else
WIN.ERR = 25
WIN.MSG = 'General failure (contact supplier)'
-- altrimenti è solo da ricalcolare (eventualmente)
else
-- se cambiata configurazione macchina da ultima elaborazione, devo aggiornare
if EgtCompareFilesLastWriteTime( WIN.FILE, sMachDir .. '\\Tools\\Tools.data') == -1 or
EgtCompareFilesLastWriteTime( WIN.FILE, sMachDir .. '\\' .. sMachine ..'.mlde') == -1 then
bToRecalc = true
end
WIN.ROT = 0
WIN.CUTID = 0
WIN.TASKID = 0
local vItem = EgtSplitString( sErr, ';') or {}
for i = 1, #vItem do
vItem[i] = EgtTrim( vItem[i] or '')
EgtOutLog( ' +++ Loading Project already processed >>>')
-- Passo in modalità lavora
EgtSetCurrMachGroup( EgtGetLastMachGroup())
-- Se necessario eseguo aggiornamento con setup corrente e ricalcolo delle lavorazioni
if bToRecalc then
EgtOutLog( ' +++ Recalculating all dispositions and machinings >>>')
EgtImportSetup()
EgtApplyAllMachinings()
-- Salvo il progetto
EgtSaveFile( WIN.FILE)
end
end
-- se è da riprocessare o da ricalcolare, si lancia simulazione e calcolo stima tempi
if bToProcess or bToRecalc then
-- simulazione e generazione eseguiti se non è la pre-verifica per stima tempi
if not bCheckNoSim then
-- *** Eseguo simulazione con verifica collisione in cieco ***
local bSimOk, nErr, sErr = EgtSimulate()
if not bSimOk then
if nErr == MCH_SHE.INIT then
WIN.ERR = 19
WIN.MSG = 'Error starting simulation'
elseif nErr == MCH_SHE.COLLISION then
WIN.ERR = 22
WIN.MSG = 'Head-part collision'
elseif nErr == MCH_SHE.OUTSTROKE then
WIN.ERR = 23
WIN.MSG = 'Axis outstroke ' .. sErr
elseif nErr == MCH_SHE.SPECIAL then
WIN.ERR = 24
WIN.MSG = 'Special error ' .. sErr
else
WIN.ERR = 25
WIN.MSG = 'General failure (contact supplier)'
end
WIN.ROT = 0
WIN.CUTID = 0
WIN.TASKID = 0
local vItem = EgtSplitString( sErr, ';') or {}
for i = 1, #vItem do
vItem[i] = EgtTrim( vItem[i] or '')
if string.find( vItem[i], 'CUTID', 1, true) then
WIN.CUTID = EgtGetVal( vItem[i], 'CUTID', 'i') or 0
elseif string.find( vItem[i], 'TASKID', 1, true) then
WIN.TASKID = EgtGetVal( vItem[i], 'TASKID', 'i') or 0
end
end
WriteErrToLogFile( WIN.ERR, WIN.MSG, WIN.ROT, WIN.CUTID, WIN.TASKID)
-- TODO gestire collisione su feature specifica!!!!!!!!!!!!!!!!!!!!!!!!!!!!
WinExec.AddApplyResultToGlobalList( WIN.ERR, WIN.CUTID, WIN.MSG)
WIN.RESULT = WinLib.TableCopyDeep( RESULT)
WriteResultToJson( RESULT)
return
end
end
WriteErrToLogFile( WIN.ERR, WIN.MSG, WIN.ROT, WIN.CUTID, WIN.TASKID)
-- TODO gestire collisione su feature specifica!!!!!!!!!!!!!!!!!!!!!!!!!!!!
BeamExec.AddApplyResultToGlobalList( WIN.ERR, WIN.CUTID, WIN.MSG)
WIN.RESULT = WinLib.TableCopyDeep( RESULT)
WriteResultToJson( RESULT)
return
end
-- *** Genero programma CN *** ( se richiesto)
@@ -402,8 +329,26 @@ end
-- *** Eseguo stima tempi ***
EgtOutLog( ' +++ Estimating T&L >>>')
if not EgtEstimate( '', 'EgtCAM5 - ' .. WIN.FILE) then
-- TODO gestire errori in stima
WIN.ERR = 21
WIN.MSG = 'Error estimating production time : ' .. WIN.FILE
WriteErrToLogFile( WIN.ERR, WIN.MSG)
WinExec.AddApplyResultToGlobalList( WIN.ERR, 0, WIN.MSG)
WIN.RESULT = WinLib.TableCopyDeep( RESULT)
WriteResultToJson( RESULT)
return
end
local Ttot = EgtGetInfo( EgtGetCurrMachGroup(), 'Ttot', 'd')
local sTime = 'Total Time = ' .. EgtNumToString( Ttot, 1)
EgtOutLog( sTime)
-- Scrittura tempo totale stimato di lavorazione
WriteTimeToLogFile( Ttot)
RESULT[#RESULT+1] = { dTime = Ttot, sType = 'Time'}
-- Riporto risultati in tabella globale WIN
WIN.RESULT = WinLib.TableCopyDeep( RESULT)
-- Scrittura json risultati
WriteResultToJson( RESULT)
EgtOutLog( ' +++ BatchProcess completed')
CAMAuto/CreateMachGroups.lua
+29 -71
View File
@@ -1,7 +1,5 @@
-- Process.lua by Egalware s.r.l. 2024/06/13
-- Gestione calcolo disposizione e lavorazioni per serramenti
-- Si opera sulla macchina corrente
-- 2024/06/13 PRIMA VERSIONE
-- CreateMachGroups.lua by Egalware s.r.l. 2026/02/09
-- Creazione dei MachGroup del file già aperto
-- Intestazioni
@@ -9,8 +7,27 @@ require( 'EgtBase')
_ENV = EgtProtectGlobal()
EgtEnableDebug( false)
-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-- TODO DA CANCELLARE!!!! quando verrà passato automaticamente da programma
--local WIN = {}
--WIN.MACHINELIST = {}
--WIN.MACHINELIST[1] = 'Saomad-Just3500'
--WIN.OPT_TYPE = 'WINDOW'
-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
--Libero eventuali librerie rimaste caricate
_G.package.loaded.WinData = nil
_G.package.loaded.WinLib = nil
-- Verifico che la macchina corrente sia abilitata per la lavorazione delle finestre
if not WIN.MACHINELIST or #WIN.MACHINELIST == 0 or #WIN.MACHINELIST[1] == 0 then
EgtOutLog( 'Errore! Macchina non impostata!')
return
end
if not EgtSetCurrMachine( WIN.MACHINELIST[1]) then
EgtOutLog( 'Errore! Macchina impostata non trovata!')
return
end
local sMachDir = EgtGetCurrMachineDir()
if not sMachDir then
EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Serramenti', 'ERROR')
@@ -29,6 +46,9 @@ EgtAddToPackagePath( sMachDir .. '\\Window\\?.lua')
EgtOutLog( '*** Window Process Start ***', 1)
-- Carico le librerie
EgtAddToPackagePath( EgtGetSourceDir() .. 'LuaLibs\\?.lua')
local WinLib = require( 'WinLib')
local PartData = require( 'PartData')
-- Carico i dati globali
local WinData = require( 'WinData')
@@ -40,37 +60,11 @@ GROUPS = {}
-- Colore del grezzo
local ColA = Color3d( 255, 165, 0, 30)
-- TODO DA RIMUOVERE, il parametro deve essere passato
local WIN = {}
WIN.OPT_TYPE = 'PIECE'
-------------------------------------------------------------------------------------------------------------
-- *** Recupero offset applicato al profilo ***
-------------------------------------------------------------------------------------------------------------
local function GetDispOffsetFromNotes( nPieceIndex)
local bAllOffsetsAreOk = false
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetX = 0 -- dovrà essere calcolato in base alle lavorazioni
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFY_1', 'd')
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFZ_1', 'd')
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetX = 0 -- dovrà essere calcolato in base alle lavorazioni
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFY_2', 'd')
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFZ_2', 'd')
-- controllo se tutti gli offset siano settati
if PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY and PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ and
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY and PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ then
bAllOffsetsAreOk = true
end
return bAllOffsetsAreOk
end
-------------------------------------------------------------------------------------------------------------
-- *** Recupero i pezzi da processare ***
-------------------------------------------------------------------------------------------------------------
local function GetInfoPieces()
-- Recupero le travi selezionate
-- Recupero i pezzi delle finestre
local nId = EgtGetFirstPart()
while nId do
-- TODO caricare il file di costanti
@@ -96,7 +90,7 @@ local function GetInfoPieces()
PARTS[i].DispOffsets.Phase1 = {}
PARTS[i].DispOffsets.Phase2 = {}
local bInsertedAllOffs = GetDispOffsetFromNotes( i)
local bInsertedAllOffs = PartData.GetDispOffsetFromNotes( PARTS, i)
-- recupero info profili
PARTS[i].SemiProfiles = {}
@@ -117,6 +111,7 @@ local function GetInfoPieces()
-- se non sono stati inseriti o c'è stato un errore esco subito
if not bInsertedAllOffs then
EgtOutBox( 'Errore offset non trovati', 'BatchProcessWin', 'ERROR', 'OK')
return false
end
@@ -131,43 +126,6 @@ local function GetInfoPieces()
return true
end
---------------------------------------------------------------------
-- Aggiunge al grezzo i sovramateriali pre-impostati
---------------------------------------------------------------------
local function AddOverMaterialToRaw( PiecesInMachGroup)
for i = 1, #PiecesInMachGroup do
-- prima di aggiungere sovramateriale al grezzo, calcolo dimensioni del finito
local b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PiecesInMachGroup[i].id, 'Geo') or GDB_ID.NULL, GDB_BB.STANDARD)
PiecesInMachGroup[i].b3Part = b3Part
PiecesInMachGroup[i].dPartLength = PiecesInMachGroup[i].b3Part:getDimX()
PiecesInMachGroup[i].dPartWidth = PiecesInMachGroup[i].b3Part:getDimY()
PiecesInMachGroup[i].dPartHeight = PiecesInMachGroup[i].b3Part:getDimZ()
-- recupero sovramateriale
PiecesInMachGroup[i].RawOffset = {}
-- recupero info sovramateriale
PiecesInMachGroup[i].RawOffset.dOverMatIn = EgtGetInfo( PiecesInMachGroup[i].id, 'OVERMAT_IN', 'd') or 5
PiecesInMachGroup[i].RawOffset.dOverMatOut = EgtGetInfo( PiecesInMachGroup[i].id, 'OVERMAT_OUT', 'd') or 5
PiecesInMachGroup[i].RawOffset.dOverMatLeft = EgtGetInfo( PiecesInMachGroup[i].id, 'OVERMAT_LEFT', 'd') or 5
PiecesInMachGroup[i].RawOffset.dOverMatRight = EgtGetInfo( PiecesInMachGroup[i].id, 'OVERMAT_RIGHT', 'd') or 5
PiecesInMachGroup[i].dRawLength = PiecesInMachGroup[i].RawOffset.dOverMatLeft + PiecesInMachGroup[i].dPartLength + PiecesInMachGroup[i].RawOffset.dOverMatRight
PiecesInMachGroup[i].dRawWidth = PiecesInMachGroup[i].RawOffset.dOverMatOut + PiecesInMachGroup[i].dPartWidth + PiecesInMachGroup[i].RawOffset.dOverMatIn
PiecesInMachGroup[i].dRawHeight = PiecesInMachGroup[i].dPartHeight
EgtModifyRawPartSize( PiecesInMachGroup[i].idRaw, PiecesInMachGroup[i].dRawLength, PiecesInMachGroup[i].dRawWidth, PiecesInMachGroup[i].dPartHeight)
local vtMove = Vector3d( PiecesInMachGroup[i].RawOffset.dOverMatLeft, PiecesInMachGroup[i].RawOffset.dOverMatOut, 0)
EgtMovePartInRawPart( PiecesInMachGroup[i].id, vtMove)
-- TODO da controllare, se ruotato di 180° bisognerebbe prendere dOverMatIn. Lo stesso per la X
PiecesInMachGroup[i].OffsetPartToRaw = {}
PiecesInMachGroup[i].OffsetPartToRaw.X = PiecesInMachGroup[i].RawOffset.dOverMatLeft
PiecesInMachGroup[i].OffsetPartToRaw.Y = PiecesInMachGroup[i].RawOffset.dOverMatOut
end
end
---------------------------------------------------------------------
-- Crea il grezzo che verrà messo in macchina
---------------------------------------------------------------------
@@ -335,7 +293,7 @@ local function CreateMachGroups()
AlignRawsToTable( GROUPS[j])
-- aggiungo sovramateriale ai grezzi
AddOverMaterialToRaw( GROUPS[j])
PartData.AddOverMaterialToRaw( GROUPS[j])
-- si dispongono i pezzi sulla tavola
local bDispOk, sErr = WinData.ExecDisposition( GROUPS[j])
CAMAuto/LuaLibs/PartData.lua
+92
View File
@@ -0,0 +1,92 @@
-- PartData.lua by Egalware s.r.l. 2026/02/19
-- Libreria globale per Serramenti
-- Tabella per definizione modulo
local PartData = {}
-- Include
require( 'EgtBase')
local WinData = require( 'WinData')
EgtOutLog( ' PartData started', 1)
-------------------------------------------------------------------------------------------------------------
-- Recupero offset applicato al profilo
function PartData.GetDispOffsetFromNotes( PARTS, nPieceIndex)
local bAllOffsetsAreOk = false
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetX = 0 -- dovrà essere calcolato in base alle lavorazioni
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFY_1', 'd')
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFZ_1', 'd')
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetX = 0 -- dovrà essere calcolato in base alle lavorazioni
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFY_2', 'd')
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFZ_2', 'd')
-- controllo se tutti gli offset siano settati
if PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY and PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ and
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY and PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ then
bAllOffsetsAreOk = true
end
return bAllOffsetsAreOk
end
---------------------------------------------------------------------
-- Crea il grezzo che verrà messo in macchina
function PartData.AddOverMaterialToRaw( PARTS)
for i = 1, #PARTS do
-- prima di aggiungere sovramateriale al grezzo, calcolo dimensioni del finito
local b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Geo') or GDB_ID.NULL, GDB_BB.STANDARD)
PARTS[i].b3Part = b3Part
PARTS[i].dPartLength = PARTS[i].b3Part:getDimX()
PARTS[i].dPartWidth = PARTS[i].b3Part:getDimY()
PARTS[i].dPartHeight = PARTS[i].b3Part:getDimZ()
-- recupero sovramateriale
PARTS[i].RawOffset = {}
-- recupero info sovramateriale
PARTS[i].RawOffset.dOverMatIn = EgtGetInfo( PARTS[i].id, 'OVERMAT_IN', 'd') or 5
PARTS[i].RawOffset.dOverMatOut = EgtGetInfo( PARTS[i].id, 'OVERMAT_OUT', 'd') or 5
PARTS[i].RawOffset.dOverMatLeft = EgtGetInfo( PARTS[i].id, 'OVERMAT_LEFT', 'd') or 5
PARTS[i].RawOffset.dOverMatRight = EgtGetInfo( PARTS[i].id, 'OVERMAT_RIGHT', 'd') or 5
PARTS[i].dRawLength = PARTS[i].RawOffset.dOverMatLeft + PARTS[i].dPartLength + PARTS[i].RawOffset.dOverMatRight
PARTS[i].dRawWidth = PARTS[i].RawOffset.dOverMatOut + PARTS[i].dPartWidth + PARTS[i].RawOffset.dOverMatIn
PARTS[i].dRawHeight = PARTS[i].dPartHeight
EgtModifyRawPartSize( PARTS[i].idRaw, PARTS[i].dRawLength, PARTS[i].dRawWidth, PARTS[i].dPartHeight)
--local vtMove = Vector3d( PARTS[i].RawOffset.dOverMatLeft, PARTS[i].RawOffset.dOverMatOut, 0)
--EgtMovePartInRawPart( PARTS[i].id, vtMove)
-- TODO da controllare, se ruotato di 180° bisognerebbe prendere dOverMatIn. Lo stesso per la X
PARTS[i].OffsetPartToRaw = {}
PARTS[i].OffsetPartToRaw.X = PARTS[i].RawOffset.dOverMatLeft
PARTS[i].OffsetPartToRaw.Y = PARTS[i].RawOffset.dOverMatOut
end
end
---------------------------------------------------------------------
-- Recupera le dimensioni dei pezzi
function PartData.GetDimensionPart( PARTS)
if #PARTS == 0 then
EgtOutBox( 'Non ci sono pezzi', 'Lavora Pezzi', 'ERROR')
return false
else
-- recupero tutte le dimensioni necessarie
local sOut = ''
for i = 1, #PARTS do
PARTS[i].b3Raw = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'GeoRaw') or GDB_ID.NULL, GDB_BB.STANDARD)
PARTS[i].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Geo') or GDB_ID.NULL, GDB_BB.STANDARD)
local idFrame = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( PARTS[i].id, 'GeoRaw'), 'AuxFrame')
PARTS[i].frame = EgtFR( idFrame)
sOut = sOut .. PARTS[i].sName .. ', '
end
sOut = sOut:sub( 1, -3)
EgtOutLog( 'Pezzi selezionati : ' .. sOut, 1)
end
end
-------------------------------------------------------------------------------------------------------------
return PartData
CAMAuto/LuaLibs/WinExec.lua
+16 -2
View File
@@ -33,8 +33,9 @@ EgtMdbSave()
-------------------------------------------------------------------------------------------------------------
-- *** variabili globali ***
-------------------------------------------------------------------------------------------------------------
TOOLS = nil
MACHININGS = nil
TOOLS = {}
MACHININGS = {}
RESULT = {} -- tabella contenente il risultato, feature per feature, dell'applicazione della strategia scelta e il resoconto dell'analisi fatta
-------------------------------------------------------------------------------------------------------------
-- *** COSTANTI *** TODO -> DA SPOSTARE IN WINDATA???
@@ -192,6 +193,17 @@ function WinExec.GetToolsFromDB()
end
-------------------------------------------------------------------------------------------------------------
function WinExec.AddApplyResultToGlobalList( nErr, idCut, sMsg)
RESULT[#RESULT+1] = {
sType = 'Part',
idCut = idCut,
idTask = 0,
nErr = nErr,
sMsg = sMsg
}
end
-------------------------------------------------------------------------------------------------------------
-- *** Inserimento delle lavorazioni nelle travi ***
-------------------------------------------------------------------------------------------------------------
@@ -218,6 +230,8 @@ local function CollectFeatures( vProc, Part, nIndexPart)
Proc.sType = sType
Proc.b3Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD)
Proc.nPhase = EgtGetInfo( ProcId, 'PHASE', 'i') or nil
Proc.idCut = EgtGetInfo( EgtGetParent( EgtGetParent( ProcId)), 'CUTID', 'i') or 0
Proc.idTask = EgtGetInfo( ProcId, 'TASKID', 'i') or 0
-- se esiste la geometria
if Proc.b3Box and not Proc.b3Box:isEmpty() then
CAMAuto/LuaLibs/WinLib.lua
+1 -1
View File
@@ -162,7 +162,7 @@ function WinLib.TableCopyDeep( OriginalTable)
elseif isVector3d( value) then
CopiedTable[ key] = Vector3d( value)
else
CopiedTable[ key] = BeamLib.TableCopyDeep( value)
CopiedTable[ key] = WinLib.TableCopyDeep( value)
end
else
CopiedTable[ key] = value
CAMAuto/ProcessWin.lua
+9 -79
View File
@@ -18,7 +18,7 @@ EgtAddToPackagePath( WIN.BASEDIR .. '\\LuaLibs\\?.lua')
-- Imposto direttorio strategie. N.B. Le strategie dovranno essere caricate con il nome del direttorio padre
EgtAddToPackagePath( WIN.BASEDIR .. '\\Strategies\\?.lua')
-- Verifico che la macchina corrente sia abilitata per la lavorazione delle Travi
-- Verifico che la macchina corrente sia abilitata per la lavorazione delle finestre
local sMachDir = EgtGetCurrMachineDir()
if not sMachDir then
EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Serramenti', 'ERROR')
@@ -44,6 +44,7 @@ _G.package.loaded.FeatureData = nil
_G.package.loaded.MachiningLib = nil
local WinExec = require( 'WinExec')
local PartData = require( 'PartData')
-- Carico i dati globali
local WinData = require( 'WinData')
@@ -58,7 +59,7 @@ local ColA = Color3d( 255, 165, 0, 30)
-- *** Recupero i pezzi da processare ***
-------------------------------------------------------------------------------------------------------------
local function MyProcessInputData()
-- Recupero le travi selezionate
-- Recupero i pezzi selezionati
local nId = EgtGetFirstSelectedObj()
while nId do
local nPartId = EgtGetParent( EgtGetParent( nId or GDB_ID.NULL) or GDB_ID.NULL)
@@ -76,23 +77,9 @@ local function MyProcessInputData()
end
nId = EgtGetNextSelectedObj()
end
if #PARTS == 0 then
EgtOutBox( 'Non sono state selezionati pezzi', 'Lavora Pezzi', 'ERROR')
return false
else
-- recupero tutte le dimensioni necessarie
local sOut = ''
for i = 1, #PARTS do
PARTS[i].b3Raw = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'GeoRaw') or GDB_ID.NULL, GDB_BB.STANDARD)
PARTS[i].b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Geo') or GDB_ID.NULL, GDB_BB.STANDARD)
local idFrame = EgtGetFirstNameInGroup( EgtGetFirstNameInGroup( PARTS[i].id, 'GeoRaw'), 'AuxFrame')
PARTS[i].frame = EgtFR( idFrame)
sOut = sOut .. PARTS[i].sName .. ', '
end
sOut = sOut:sub( 1, -3)
EgtOutLog( 'Pezzi selezionati : ' .. sOut, 1)
end
PartData.GetDimensionPart( PARTS)
EgtDeselectAll()
return true
@@ -107,26 +94,6 @@ local function GetDataConfig()
return true
end
-------------------------------------------------------------------------------------------------------------
local function GetDispOffsetFromNotes( nPieceIndex)
local bAllOffsetsAreOk = false
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetX = 0 -- dovrà essere calcolato in base alle lavorazioni
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFY_1', 'd')
PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFZ_1', 'd')
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetX = 0 -- dovrà essere calcolato in base alle lavorazioni
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFY_2', 'd')
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ = EgtGetInfo( PARTS[nPieceIndex].id, 'OFFZ_2', 'd')
-- controllo se tutti gli offset siano settati
if PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetY and PARTS[nPieceIndex].DispOffsets.Phase1.dOffsetZ and
PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetY and PARTS[nPieceIndex].DispOffsets.Phase2.dOffsetZ then
bAllOffsetsAreOk = true
end
return bAllOffsetsAreOk
end
-------------------------------------------------------------------------------------------------------------
local function GetDispOffsetFromInput( nPieceIndex)
-- assegno alle stringhe i valori letti, in modo che vengano proposti quelli nel dialogo
@@ -151,43 +118,6 @@ local function GetDispOffsetFromInput( nPieceIndex)
return true
end
---------------------------------------------------------------------
-- Crea il grezzo che verrà messo in macchina
---------------------------------------------------------------------
local function AddOverMaterialToRaw( PARTS)
for i = 1, #PARTS do
-- prima di aggiungere sovramateriale al grezzo, calcolo dimensioni del finito
local b3Part = EgtGetBBoxGlob( EgtGetFirstNameInGroup( PARTS[i].id, 'Geo') or GDB_ID.NULL, GDB_BB.STANDARD)
PARTS[i].b3Part = b3Part
PARTS[i].dPartLength = PARTS[i].b3Part:getDimX()
PARTS[i].dPartWidth = PARTS[i].b3Part:getDimY()
PARTS[i].dPartHeight = PARTS[i].b3Part:getDimZ()
-- recupero sovramateriale
PARTS[i].RawOffset = {}
-- recupero info sovramateriale
PARTS[i].RawOffset.dOverMatIn = EgtGetInfo( PARTS[i].id, 'OVERMAT_IN', 'd') or 5
PARTS[i].RawOffset.dOverMatOut = EgtGetInfo( PARTS[i].id, 'OVERMAT_OUT', 'd') or 5
PARTS[i].RawOffset.dOverMatLeft = EgtGetInfo( PARTS[i].id, 'OVERMAT_LEFT', 'd') or 5
PARTS[i].RawOffset.dOverMatRight = EgtGetInfo( PARTS[i].id, 'OVERMAT_RIGHT', 'd') or 5
PARTS[i].dRawLength = PARTS[i].RawOffset.dOverMatLeft + PARTS[i].dPartLength + PARTS[i].RawOffset.dOverMatRight
PARTS[i].dRawWidth = PARTS[i].RawOffset.dOverMatOut + PARTS[i].dPartWidth + PARTS[i].RawOffset.dOverMatIn
PARTS[i].dRawHeight = PARTS[i].dPartHeight
EgtModifyRawPartSize( PARTS[i].idRaw, PARTS[i].dRawLength, PARTS[i].dRawWidth, PARTS[i].dPartHeight)
local vtMove = Vector3d( PARTS[i].RawOffset.dOverMatLeft, PARTS[i].RawOffset.dOverMatOut, 0)
EgtMovePartInRawPart( PARTS[i].id, vtMove)
-- TODO da controllare, se ruotato di 180° bisognerebbe prendere dOverMatIn. Lo stesso per la X
PARTS[i].OffsetPartToRaw = {}
PARTS[i].OffsetPartToRaw.X = PARTS[i].RawOffset.dOverMatLeft
PARTS[i].OffsetPartToRaw.Y = PARTS[i].RawOffset.dOverMatOut
end
end
---------------------------------------------------------------------
-- Crea il grezzo che verrà messo in macchina
---------------------------------------------------------------------
@@ -246,7 +176,7 @@ local nMachGroupId = EgtGetFirstMachGroup()
end
-------------------------------------------------------------------------------------------------------------
-- *** Inserimento delle travi nel grezzo ***
-- *** Inserimento dei pezzi nel grezzo ***
-------------------------------------------------------------------------------------------------------------
local function MyProcessPieces()
@@ -261,7 +191,7 @@ local function MyProcessPieces()
AlignRawsToTable( PARTS)
-- aggiungo sovramateriale ai grezzi
AddOverMaterialToRaw( PARTS)
PartData.AddOverMaterialToRaw( PARTS)
-- recupero offset per posizionamento
for i = 1, #PARTS do
@@ -269,7 +199,7 @@ local function MyProcessPieces()
PARTS[i].DispOffsets.Phase1 = {}
PARTS[i].DispOffsets.Phase2 = {}
local bInsertedAllOffs = GetDispOffsetFromNotes( i)
local bInsertedAllOffs = PartData.GetDispOffsetFromNotes( PARTS, i)
-- se non sono settati nelle note, li chiedo
if not bInsertedAllOffs then
bInsertedAllOffs = GetDispOffsetFromInput( i)
Designing/Main.lua
+174 -92
View File
@@ -52,6 +52,7 @@ local dSashDim = 78
local vFrameDims = { dFrameDim, dFrameDim, dFrameDim, dFrameDim}
local vSashDims = { dSashDim, dSashDim, dSashDim, dSashDim}
local bDaylight = true -- true = dimensione luce / false = dimensione esterno anta
local sProfilePath = 'C:\\EgtData\\EgtWindowMaker\\Profiles\\Profilo78.nge'
-- local sProfilePath = 'C:\\EgtData\\EgtWindowMaker\\Profiles\\ProfiloSaomad.nge'
@@ -67,7 +68,7 @@ WinCreate.ImportProfile( sProfilePath)
-- creo telaio
local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, WindowHeight}, vFrameJoints, vFrameDims)
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, WindowHeight}, vFrameJoints, vFrameDims)
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER_SIDE, { WindowWidth, WindowHeight, WindowHeight + 800}, vFrameJoints, vFrameDims)
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.CHAMFER_SIDE, { WindowWidth, WindowHeight + 500, WindowHeight}, vFrameJoints, vFrameDims)
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.ROUND_ARC, { WindowWidth, WindowHeight}, vFrameJoints, vFrameDims)
@@ -81,44 +82,44 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
------------------------ Aggiunta split a griglia ------------------------
-- WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE}, { 150, 300, 150, 300},
-- WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE}, { 150, 300, 150, 900},
-- { WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE}, { 500, 600, 850}, false)
-- WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 25}, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 30}, false)
-- WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 75}, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 30, 20}, false)
-- WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL}, { 1, 4, 1, 2, 1},
-- { WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL}, { 1, 2, 1, 2, 1}, false)
-- WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.ABSOLUTE}, { 2, 1, 200},
-- { WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PROPORTIONAL}, { 1, 50, 1})
-- { WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PROPORTIONAL}, { 1, 50, 1}, false)
------------------------ Cambi profilo ------------------------
-- vetro / anta
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 120})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 120})
-- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- local nSashId = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_RIGHT)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- vetro / anta in orizzontale
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 120})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 120})
-- local nSashId = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- anta / vetro
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50})
-- local nSashId = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- vetro / anta / vetro
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333}, { 90, 120})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.3333, 33.3333, 33.3333}, { 90, 120})
-- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- local nSashId = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[3], WIN_FILLTYPES.GLASS)
-- vetro / anta / anta
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33, 33})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33, 33, 34})
-- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- local nSashId1 = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims)
-- local nSashId2 = WinCreate.AddSash( vAreas[3], vSashJoints, vSashDims)
@@ -126,17 +127,18 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddFill( nSashId2, WIN_FILLTYPES.GLASS)
-- anta battente / anta ricevente / vetro
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 66}, { 90})
-- local vSashes = WinCreate.AddSashGroup( vAreas[1], { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 66, 34}, { 90})
-- local vSashes = WinCreate.AddSashGroup( vAreas[1], { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- vetro / anta / vetro / anta (1)
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50})
-- local vAreas2 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50})
-- local vAreas3 = WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50})
-- local vAreas2 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50})
-- local vAreas3 = WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50})
-- WinCreate.AddFill( vAreas2[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas3[1], WIN_FILLTYPES.GLASS)
-- local nSashId1 = WinCreate.AddSash( vAreas2[2], vSashJoints)
@@ -145,7 +147,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddFill( nSashId2, WIN_FILLTYPES.GLASS)
-- vetro / anta / vetro / anta (2)
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25}, { 90, 120, 90})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE},
-- { 25, 25, 25, 25}, { 90, 120, 90})
-- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- local nSashId1 = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSashId1, WIN_FILLTYPES.GLASS)
@@ -154,7 +157,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddFill( nSashId2, WIN_FILLTYPES.GLASS)
-- vetro / vetro / anta / anta
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25}, { 90, 90, 90})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE},
-- { 25, 25, 25, 25}, { 90, 90, 90})
-- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- local nSashId1 = WinCreate.AddSash( vAreas[3], vSashJoints, vSashDims)
@@ -163,24 +167,24 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddFill( nSashId2, WIN_FILLTYPES.GLASS)
-- anta / vetro con split
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 90})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 90})
-- local nSashId = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- local vAreas2 = WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 60})
-- local vAreas2 = WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 60})
-- WinCreate.AddFill( vAreas2[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas2[2], WIN_FILLTYPES.GLASS)
-- anta con split / vetro
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 90})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 90})
-- local nSashId = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims)
-- local vAreasSash = WinCreate.AddSplits( nSashId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 80})
-- local vAreasSash = WinCreate.AddSplits( nSashId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 80})
-- WinCreate.AddFill( vAreasSash[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreasSash[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- ante ( divise da split orizzontale) / vetro
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 90})
-- local vAreas2 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 30}, { 95})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 90})
-- local vAreas2 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 30, 70}, { 95})
-- local nSashId1 = WinCreate.AddSash( vAreas2[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSashId1, WIN_FILLTYPES.GLASS)
-- local nSashId2 = WinCreate.AddSash( vAreas2[2], vSashJoints, vSashDims)
@@ -197,15 +201,17 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddThreshold( nFrameId, 'Threshold')
-- anta mobile a sx
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims},
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight, { vSashJoints, vSashJoints}, { vSashDims, vSashDims},
-- { WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_FIXED}, { WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.FIXED})
-- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS)
-- local nFill1 = WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS)
-- local nFill2 = WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS)
-- -- WinCreate.AddSplits( nFill1, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, nil, false, false, WIN_MUNTINFILL_SIDES.BOTH)
-- -- WinCreate.AddSplits( nFill2, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, nil, false, false, WIN_MUNTINFILL_SIDES.BOTH)
-- local nSashGrpId = EgtGetParent( vSash[1])
-- WinCreate.AddHardware( nSashGrpId, '000592', 'Sx')
-- anta mobile a dx
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims},
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight, { vSashJoints, vSashJoints}, { vSashDims, vSashDims},
-- { WIN_SASHTYPES.SLIDE_FIXED, WIN_SASHTYPES.SLIDE_MOVABLE}, { WIN_OPENING_TYPES.FIXED, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT})
-- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS)
@@ -213,7 +219,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSashGrpId, '000592', 'Dx')
-- 2 ante mobili, sx davanti
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims},
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight, { vSashJoints, vSashJoints}, { vSashDims, vSashDims},
-- { WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE_BACK}, { WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT})
-- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS)
@@ -221,7 +227,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSashGrpId, '000593', 'Sx')
-- 2 ante mobili, dx davanti
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims},
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight, { vSashJoints, vSashJoints}, { vSashDims, vSashDims},
-- { WIN_SASHTYPES.SLIDE_MOVABLE_BACK, WIN_SASHTYPES.SLIDE_MOVABLE}, { WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT})
-- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS)
@@ -231,7 +237,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- 4 ante, le centrali sono mobili
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { 4500, 2100}, vFrameJoints, vFrameDims)
-- -- WinCreate.AddThreshold( nFrameId, 'Threshold')
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25},
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25, 25}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.SLIDE_FIXED, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_FIXED},
-- { WIN_OPENING_TYPES.FIXED, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT, WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.FIXED})
@@ -245,14 +251,22 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- 4 ante mobili
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { 4500, 2100}, vFrameJoints, vFrameDims)
-- -- WinCreate.AddThreshold( nFrameId, 'Threshold')
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25},
-- local vSash = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25, 25}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.SLIDE_MOVABLE_BACK, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_MOVABLE_BACK},
-- { WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT, WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.COPLANARSLIDE_LEFT})
-- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[3], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[4], WIN_FILLTYPES.GLASS)
-- local nFill1 = WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS)
-- local nFill2 = WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS)
-- local nFill3 = WinCreate.AddFill( vSash[3], WIN_FILLTYPES.GLASS)
-- local nFill4 = WinCreate.AddFill( vSash[4], WIN_FILLTYPES.GLASS)
-- -- WinCreate.AddGridSplits( nFill1, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- -- { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, true, nil, nil, WIN_MUNTINFILL_SIDES.BOTH)
-- -- WinCreate.AddGridSplits( nFill2, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- -- { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, true, nil, nil, WIN_MUNTINFILL_SIDES.BOTH)
-- -- WinCreate.AddGridSplits( nFill3, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- -- { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, true, nil, nil, WIN_MUNTINFILL_SIDES.BOTH)
-- -- WinCreate.AddGridSplits( nFill4, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- -- { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, true, nil, nil, WIN_MUNTINFILL_SIDES.BOTH)
-- local nSashGrpId = EgtGetParent( vSash[1])
-- WinCreate.AddHardware( nSashGrpId, '000595', 'Dx')
@@ -266,16 +280,16 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- divisione orizzontale / verticale
-- WinCreate.AddBottomRail( nFrameId, 2)
-- -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 70}, { 60})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 70}, { 60})
-- -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 70, 30}, { 60})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 70, 30}, { 60})
-- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- divisione verticale ed orizzontale (1)
-- WinCreate.AddBottomRail( nFrameId, 1, { 60})
-- local vAreas1 = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 100})
-- local vAreas2 = WinCreate.AddSplits( vAreas1[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 60})
-- local vAreas3 = WinCreate.AddSplits( vAreas1[2], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 60})
-- local vAreas1 = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 100})
-- local vAreas2 = WinCreate.AddSplits( vAreas1[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 60})
-- local vAreas3 = WinCreate.AddSplits( vAreas1[2], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 60})
-- WinCreate.AddFill( vAreas2[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas2[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas3[1], WIN_FILLTYPES.GLASS)
@@ -283,7 +297,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- divisione verticale ed orizzontale (2)
-- WinCreate.AddBottomRail( nFrameId, 1)
-- local vAreas = WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 50}, { WIN_MEASURE.PERCENTAGE}, { 50}, true, { 100, 60, 60})
-- local vAreas = WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- true, { 100}, { 60})
-- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[3], WIN_FILLTYPES.GLASS)
@@ -301,16 +316,16 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- divisione orizzontale / verticale
-- local nSashId = WinCreate.AddSash( nFrameId, vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddBottomRail( nSashId, 1, { 100})
-- -- local vAreas = WinCreate.AddSplits( nSashId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50})
-- local vAreas = WinCreate.AddSplits( nSashId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50})
-- -- local vAreas = WinCreate.AddSplits( nSashId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50})
-- local vAreas = WinCreate.AddSplits( nSashId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50})
-- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- divisione verticale e orizzontale
-- local nSashId = WinCreate.AddSash( nFrameId, vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- local vAreas1 = WinCreate.AddSplits( nSashId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 100})
-- local vAreas2 = WinCreate.AddSplits( vAreas1[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 60})
-- local vAreas3 = WinCreate.AddSplits( vAreas1[2], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 60})
-- local vAreas1 = WinCreate.AddSplits( nSashId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 100})
-- local vAreas2 = WinCreate.AddSplits( vAreas1[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 60})
-- local vAreas3 = WinCreate.AddSplits( vAreas1[2], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 60})
-- WinCreate.AddFill( vAreas2[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas2[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas3[1], WIN_FILLTYPES.GLASS)
@@ -321,23 +336,23 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
------------------------ Finestre con più ante singole ------------------------
-- due ante divisione verticale
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 120})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 120})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_RIGHT)
-- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS)
-- due ante divisione orizzontale
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 120})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 120})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTONLY_TOP)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTONLY_TOP)
-- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS)
-- tre ante
-- -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE}, { WindowWidth / 3, WindowWidth / 3}, { 95, 95})
-- -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE, WIN_MEASURE.ABSOLUTE}, { 500, 200, 800}, { 95, 95})
-- -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL}, { 1, 1, 1}, { 95, 95})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333}, { 95, 95})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, { 95, 95})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims)
@@ -345,10 +360,10 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- local nSash3Id = WinCreate.AddSash( vAreas[3], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSash3Id, WIN_FILLTYPES.GLASS)
-- tre ante una sopra e due sotto
-- local vAreas1 = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 115})
-- local vAreas2 = WinCreate.AddSplits( vAreas1[2], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 95})
-- local nSash1Id = WinCreate.AddSash( vAreas1[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.FIXED)
-- tre ante : una sopra e due sotto
-- local vAreas1 = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 115})
-- local vAreas2 = WinCreate.AddSplits( vAreas1[1], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 95})
-- local nSash1Id = WinCreate.AddSash( vAreas1[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.FIXED)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas2[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS)
@@ -356,9 +371,9 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddFill( nSash3Id, WIN_FILLTYPES.GLASS)
-- sei ante (1)
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 105})
-- local vAreas1 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333}, { 95, 95})
-- local vAreas2 = WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333}, { 95, 95})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 105})
-- local vAreas1 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, { 95, 95})
-- local vAreas2 = WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, { 95, 95})
-- local nSash1Id = WinCreate.AddSash( vAreas1[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas1[2], vSashJoints, vSashDims)
@@ -373,7 +388,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddFill( nSash6Id, WIN_FILLTYPES.GLASS)
-- sei ante (2)
-- local vAreas = WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333}, { WIN_MEASURE.PERCENTAGE}, { 50}, false, { 120, 100, 85, 100, 85})
-- local vAreas = WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333},
-- { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, false, { 100, 85}, { 120})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims)
@@ -392,13 +408,15 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
------------------------ Finestre con ante battenti e riceventi ------------------------
-- battente / ricevente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- battente / ricevente / ricevente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333}, { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.INACTIVE_OUT},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
@@ -406,7 +424,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS)
-- battente / battente / ricevente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333}, { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.ACTIVE_OUT, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
@@ -414,7 +433,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS)
-- battente / battente / ricevente / ricevente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL}, { 1, 1, 1, 1},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL, WIN_MEASURE.PROPORTIONAL}, { 1, 1, 1, 1}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.ACTIVE_OUT, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.INACTIVE_OUT},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
@@ -428,69 +447,123 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
------------------------ Finestre con ante singole e ante battenti/riceventi ------------------------
-- tre ante : singola / ricevente / battente
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 33}, { 115})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33, 67}, { 115})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local vSashes = WinCreate.AddSashGroup( vAreas[2], { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE},
-- local vSashes = WinCreate.AddSashGroup( vAreas[2], { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- tre ante ( singola / ricevente/ battente) con split nelle ante
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 33}, { 95})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33, 67}, { 95})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- local vAreasSash1 = WinCreate.AddSplits( nSash1Id, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.ABSOLUTE}, { WindowHeight * 3 / 5}, { 60})
-- local vAreasSash1 = WinCreate.AddSplits( nSash1Id, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.ABSOLUTE, WIN_MEASURE.PROPORTIONAL}, { WindowHeight / 5, 1}, { 60})
-- WinCreate.AddFill( vAreasSash1[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreasSash1[2], WIN_FILLTYPES.GLASS)
-- local vSashes2 = WinCreate.AddSashGroup( vAreas[2], { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE},
-- local vSashes2 = WinCreate.AddSashGroup( vAreas[2], { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- local vAreasSash2 = WinCreate.AddSplits( vSashes2[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.ABSOLUTE}, { WindowHeight * 3 / 5}, { 60})
-- local vAreasSash2 = WinCreate.AddSplits( vSashes2[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.ABSOLUTE, WIN_MEASURE.PROPORTIONAL}, { WindowHeight / 5, 1}, { 60})
-- WinCreate.AddFill( vAreasSash2[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreasSash2[2], WIN_FILLTYPES.GLASS)
-- local vAreasSash3 = WinCreate.AddSplits( vSashes2[2], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.ABSOLUTE}, { WindowHeight * 3 / 5}, { 60})
-- local vAreasSash3 = WinCreate.AddSplits( vSashes2[2], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.ABSOLUTE, WIN_MEASURE.PROPORTIONAL}, { WindowHeight / 5, 1}, { 60})
-- WinCreate.AddFill( vAreasSash3[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreasSash3[2], WIN_FILLTYPES.GLASS)
-- 3 ante : sopra battente / ricevente, sotto singola
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 70}, { 105})
-- local nSash0Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.FIXED)
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 30, 70}, { 105})
-- local nSash0Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.FIXED)
-- WinCreate.AddFill( nSash0Id, WIN_FILLTYPES.GLASS)
-- local vSashes = WinCreate.AddSashGroup( vAreas[1], { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- local vSashes = WinCreate.AddSashGroup( vAreas[2], { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- 4 ante : sopra anta singola e sotto singola ( con split) / battente / ricevente
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 30}, { 95})
-- local vAreas1 = WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 30}, { 95})
-- local nSash0Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTONLY_TOP)
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 70, 30}, { 95})
-- local vAreas1 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 30, 70}, { 95})
-- local nSash0Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTONLY_TOP)
-- WinCreate.AddFill( nSash0Id, WIN_FILLTYPES.GLASS)
-- local nSash1Id = WinCreate.AddSash( vAreas1[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- local vSashAreas = WinCreate.AddSplits( nSash1Id, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 60}, { 60})
-- local vSashAreas = WinCreate.AddSplits( nSash1Id, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 60, 40}, { 60})
-- WinCreate.AddFill( vSashAreas[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashAreas[2], WIN_FILLTYPES.GLASS)
-- local vSashes = WinCreate.AddSashGroup( vAreas1[2], { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- local vSashes = WinCreate.AddSashGroup( vAreas1[2], { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- sei ante : divisione orizzontale e per ogni divisione anta singola / battente/ ricevente
-- local vAreas = WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 33}, { WIN_MEASURE.PERCENTAGE}, { 50}, false, { 115, 95, 95})
-- local vAreas = WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33, 67}, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, false, { 95}, { 115})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims,WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[3], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS)
-- local vSashes1 = WinCreate.AddSashGroup( vAreas[2], { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- local vSashes1 = WinCreate.AddSashGroup( vAreas[2], { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes1[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes1[2], WIN_FILLTYPES.GLASS)
-- local vSashes2 = WinCreate.AddSashGroup( vAreas[4], { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- local vSashes2 = WinCreate.AddSashGroup( vAreas[4], { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes2[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes2[2], WIN_FILLTYPES.GLASS)
------------------------ Inglesine ------------------------
-- vetro fisso con inglesina interna
-- WinCreate.AddBottomRail( nFrameId, 2, { 90, 78})
-- local nFill = WinCreate.AddFill( nFrameId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddSplits( nFill, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.3333, 33.3333, 33.33333},
-- nil, false, false, WIN_MUNTINFILL_SIDES.IN)
-- vetro fisso con inglesine a griglia (1)
-- WinCreate.AddBottomRail( nFrameId, 2)
-- local nFill = WinCreate.AddFill( nFrameId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddGridSplits( nFill, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, true, { 50}, { 30, 30}, WIN_MUNTINFILL_SIDES.BOTH)
-- vetro fisso con inglesine a griglia (2)
-- WinCreate.AddBottomRail( nFrameId, 2)
-- local nFill = WinCreate.AddFill( nFrameId, WIN_FILLTYPES.GLASS)
-- local vAreas = WinCreate.AddSplits( nFill, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, nil, false, false, 3)
-- WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.3333, 33.3333, 33.3333},
-- nil, false, false, WIN_MUNTINFILL_SIDES.BOTH)
-- WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.3333, 33.3333, 33.3333},
-- nil, false, false, WIN_MUNTINFILL_SIDES.BOTH)
-- 4 vetri fissi con inglesine
-- local vAreas = WinCreate.AddGridSplits( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, true)
-- local nFill1 = WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddGridSplits( nFill1, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, false, nil, nil, WIN_MUNTINFILL_SIDES.BOTH)
-- local nFill2 = WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddSplits( nFill2, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.3333, 33.3333, 33.33333},
-- { 40, 50}, false, false, WIN_MUNTINFILL_SIDES.IN)
-- local nFill3 = WinCreate.AddFill( vAreas[3], WIN_FILLTYPES.GLASS)
-- WinCreate.AddGridSplits( nFill3, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50},
-- true, nil, nil, WIN_MUNTINFILL_SIDES.BOTH)
-- local nFill4 = WinCreate.AddFill( vAreas[4], WIN_FILLTYPES.GLASS)
-- WinCreate.AddSplits( nFill4, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.3333, 33.3333, 33.33333},
-- nil, false, false, WIN_MUNTINFILL_SIDES.OUT)
-- anta con inglesine
-- local nSash = WinCreate.AddSash( nFrameId, vSashJoints, vSashDims)
-- local nFill = WinCreate.AddFill( nSash, WIN_FILLTYPES.GLASS)
-- WinCreate.AddSplits( nFill, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE},
-- { 33.3333, 33.3333, 33.33333}, nil, false, false, WIN_MUNTINFILL_SIDES.BOTH)
------------------------ Ferramenta ------------------------
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { 1500, 2100}, vFrameJoints, vFrameDims)
@@ -509,7 +582,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- -- WinCreate.AddHardware( nSashId, '000604', 'Sx') -- trapezio
-- 2 ante singole
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 95})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 95})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_RIGHT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
@@ -524,7 +597,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- -- WinCreate.AddHardware( nSash2Id, '000604', 'Dx')
-- 2 ante singole con apertura sul montante
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 120})
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 120})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
@@ -533,11 +606,12 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSash2Id, '000558', 'Sx')
-- 3 ante : sotto singola, sopra battente / ricevente
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 60}, { 95})
-- local nSash1Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 60, 40}, { 95})
-- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- WinCreate.AddHardware( nSash1Id, '000558', 'Sx')
-- local vSashes = WinCreate.AddSashGroup( vAreas[1], { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- local vSashes = WinCreate.AddSashGroup( vAreas[2], { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
@@ -545,7 +619,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSashGrpId, '000559', 'Sx')
-- 2 ante : battente / ricevente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
@@ -555,7 +630,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- -- WinCreate.AddHardware( nSashGrpId, '000599', 'Sx') -- arco ribassato
-- 2 ante : ricevente / battente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, bDaylight,
-- { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
@@ -563,7 +639,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSashGrpId, '000559', 'Dx')
-- 3 ante : battente / battente / ricevente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33, 33}, { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.ACTIVE_OUT, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.INACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
@@ -573,7 +650,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSashGrpId, '000564', 'Sx')
-- 3 ante : ricevente / battente / battente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33, 33}, { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.INACTIVE, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.ACTIVE_OUT},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
@@ -583,7 +661,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSashGrpId, '000564', 'Dx')
-- 3 ante : battente / ricevente / ricevente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33, 33}, { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.33333, 33.33333, 33.3333}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.INACTIVE_OUT},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
@@ -593,7 +672,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSashGrpId, '000565', 'Sx')
-- 3 ante : ricevente / ricevente / battente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33, 33}, { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 33.333, 33.333, 33.333}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.INACTIVE_OUT, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.ACTIVE},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
@@ -603,7 +683,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSashGrpId, '000565', 'Dx')
-- 4 ante : battente / battente / ricevente / ricevente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25, 25}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.ACTIVE_OUT, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.INACTIVE_OUT},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
@@ -615,7 +695,7 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddHardware( nSashGrpId, '000575', 'Sx')
-- 4 ante : ricevente / ricevente / battente / battente
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25},
-- local vSashes = WinCreate.AddSashGroup( nFrameId, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 25, 25, 25, 25}, bDaylight,
-- { vSashJoints, vSashJoints, vSashJoints, vSashJoints}, { vSashDims, vSashDims, vSashDims, vSashDims},
-- { WIN_SASHTYPES.INACTIVE_OUT, WIN_SASHTYPES.INACTIVE_IN, WIN_SASHTYPES.ACTIVE_IN, WIN_SASHTYPES.ACTIVE_OUT},
-- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
@@ -631,6 +711,8 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddHardware( nSashId, '000573', 'Sx')
-----------------------------------------------------------------------------------
-- imposto se calcolare solidi/preview o meno
Designing/WinConst.lua
+41 -19
View File
@@ -59,6 +59,7 @@ WIN_MEASURE = {
}
-- tipologia di figli
WIN_CHILDREN_TYPE = 'ChildrenType'
WIN_CHILDREN_TYPES = {
NULL = 0,
SASH = 1,
@@ -100,13 +101,23 @@ WIN_AREATYPES = {
WIN_SPLITTYPE = 'SplitType'
WIN_SPLITTYPES = {
NULL = 0,
MULLION = 1, -- montante nel telaio che separa due ante
FRENCH = 2, -- per ante battente / ricevente
MIXED = 3, -- cambio profilo
INSASH = 4, -- divisione nell'anta
INFRAME = 5, -- divisione nel telaio che separa due vetri fissi
MULLION = 1, -- montante nel telaio che separa due ante
FRENCH = 2, -- per ante battente / ricevente
MIXED = 3, -- cambio profilo
MUNTIN_SASH = 4, -- divisione nell'anta che separa due vetri
MUNTIN_FRAME = 5, -- divisione nel telaio che separa due vetri fissi
MUNTIN_FILL = 6 -- inglesina incollata sul vetro
}
WIN_MUNTINFILL_SIDE = 'MuntinFillSide'
WIN_MUNTINFILL_SIDES = {
NULL = 0,
IN = 1, -- inglesina solo interna
OUT = 2, -- inglesina solo esterna
BOTH = 3, -- inglesina interna ed esterna
}
-- tipi di riempimento interno
WIN_FILLTYPE = 'FillType'
WIN_FILLTYPES = {
@@ -177,38 +188,41 @@ WIN_TOP = 'Top'
WIN_LEFT = 'Left'
-- info varie su aree e curve
WIN_SLIDE_WINDOW = 'SlideWindow'
WIN_MIXED_WINDOW = 'ProfileChangeWindow'
WIN_PART_DIM = 'PartDim'
WIN_SOU = 'SOU'
WIN_CHILD = 'CHILD'
WIN_COPY = 'COPY'
WIN_SASH_CHILDREN = 'SashChildren'
WIN_FILL_CHILDREN = 'FillChildren'
WIN_SOU_OUTLINE = 'SouOutline'
WIN_CHILD_OUTLINE = 'ChildOutline'
WIN_CHILD_VIRTUAL_OUTLINE = 'ChildVirtualOutline'
WIN_CHILD_PRFCHANGE_SPLIT = 'ChildPrfChangeSplit'
WIN_REF_OUTLINE = 'OutlineRef'
WIN_REF_MUNTIN = 'MuntinRef'
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'
WIN_SPLIT_ENDINTERS = 'SplitEndInters'
WIN_SASH_CHILDREN = 'SashChildren'
WIN_FILL_CHILDREN = 'FillChildren'
WIN_THRESHOLD_PROFILE = 'ThresholdProfile'
WIN_SLIDE_WINDOW = 'SlideWindow'
WIN_SASH_NBR = 'SashNbr'
WIN_AREA_NBR = 'AreaNbr'
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'
WIN_EXTRA_CRV = 'Extra'
WIN_SPECIAL_CRV = 'Special'
-- PROFILI
WIN_PROFILE = 'Profile'
WIN_PROFILEPATH = 'ProfilePath'
WIN_INFO_GRP = 'Info'
-- nomi dei profili
WIN_SASH_TOP = 'Sash_Top'
@@ -236,6 +250,9 @@ WIN_FRENCH_IN = 'French_In'
WIN_FRENCH_OUT = 'French_Out'
WIN_SASH_SPLIT = 'Sash_Split'
WIN_FILL_SPLIT_OUT = 'Fill_Split_Out'
WIN_FILL_SPLIT_IN = 'Fill_Split_In'
WIN_SLIDE = 'Slide'
WIN_MOVABLE = 'Movable'
WIN_SLIDE_MOVABLEBACK = 'Slide_MovableBack'
@@ -335,10 +352,6 @@ WIN_PROFILETYPE = 'ProfileType'
-- GIUNZIONI
WIN_JOINTS = 'Joints'
WIN_JOINT_BL = 'JointBL'
WIN_JOINT_BR = 'JointBR'
WIN_JOINT_TL = 'JointTL'
WIN_JOINT_TR = 'JointTR'
WIN_STARTJOINT = 'StartJoint'
WIN_ENDJOINT = 'EndJoint'
@@ -382,10 +395,19 @@ WIN_REF_PRC = 'PrcRef'
-- CAMBIO PROFILO
WIN_PRF_CHANGE = 'ProfileChange'
WIN_PRF_CHANGE_TYPES = { -- binario
NULL = 0,
OUT = 1, -- cambio profilo sul lato esterno
IN = 2, -- cambio profilo sul lato interno
START = 4, -- cambio profilo sull'estremo iniziale
END = 8, -- cambio profilo sull'estremo finale
}
WIN_MIXED_CURVES = 'ProfileChangeCurves'
WIN_MIXED_MILLING = 'ProfileChangeMilling'
WIN_MIXED_SPLIT_REF = 'MixedSplitRef'
WIN_MIXED_SASHFILL = 'MixedSashFill'
WIN_FILL_ON_SPLIT_RIGHT = 'FillOnSplitRight'
WIN_MIXED_START_CHILDREN = 'StartChildrenType'
WIN_MIXED_END_CHILDREN = 'EndChildrenType'
-- SOLIDI
Designing/WinJWDConst.lua
+2
View File
@@ -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'
@@ -51,6 +52,7 @@ JWD_SPLIT_HORIZ_POS = 'SplitHorizList'
JWD_SPLIT_AREA = 'Area'
JWD_ELEMENT_VERT_DIMENSION = 'ElementDimVertList'
JWD_ELEMENT_HORIZ_DIMENSION = 'ElementDimHorizList'
JWD_MUNTIN_SIDE = 'Side'
JWD_FILL_TYPE = 'FillType'
Designing/WinLib/WinCalculate.lua
+4320 -2513
View File
File diff suppressed because it is too large Load Diff
Designing/WinLib/WinCreate.lua
+90 -105
View File
@@ -35,7 +35,6 @@ local function CopyParentOutline( nAreaId, nParentAreaId)
-- copio le curve di outline del parent e setto le corrispondenze sou/child
for i = 1, #vParentCrvs do
local nOutlineId = EgtCopy( vParentCrvs[i], nOutlineLayerId)
EgtSetInfo( nOutlineId, WIN_SOU, vParentCrvs[i])
EgtSetInfo( vParentCrvs[i], WIN_CHILD, nOutlineId)
end
return nOutlineLayerId
@@ -277,7 +276,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 +284,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, nil, nAreaNbr)
-- trasformo le aree risultanti ( che sono null) nelle aree dell'anta settando le info opportune
for i = 1, #vAreas do
EgtSetName( vAreas[i], EgtGetName( vAreas[i]) .. '(' .. WIN_SASH .. ')')
@@ -356,9 +355,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 +365,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,20 +381,15 @@ 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)
EgtCurveCompoSetTempProp( nCrv2, dParE2 - 1, - nSplitId)
return nCrv1, nCrv2
end
@@ -452,7 +414,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)
@@ -482,14 +444,17 @@ local function CreateAreasFromSplits( nAreaId, vSplitCrvs)
-- assegno nome e info a tutte le curve di bordo a partire dalla curva da cui derviano ( salvata nella temp prop della curva)
for j = 0, nCnt - 1 do
-- assegno le info di child e source
EgtSetInfo( nFirst + j, WIN_SOU, vOrigCrvs[j+1])
AddInfo( vOrigCrvs[j+1], WIN_CHILD, nFirst + j)
-- assegno le info di child
if vOrigCrvs[j+1] < 0 then
AddInfo( abs( vOrigCrvs[j+1]), WIN_CHILD, -( nFirst + j))
else
AddInfo( vOrigCrvs[j+1], WIN_CHILD, nFirst + j)
end
-- assengo il nome : se deriva da outline lo copio, se deriva da split lo scelgo in base all'orientamento
if EgtGetName( vOrigCrvs[j+1]) == WIN_SPLIT then
if EgtGetName( abs( vOrigCrvs[j+1])) == WIN_SPLIT then
SetSplitName( nFirst + j)
else
EgtSetName( nFirst + j, EgtGetName( vOrigCrvs[j+1]))
EgtSetName( nFirst + j, EgtGetName( abs( vOrigCrvs[j+1])))
end
end
@@ -507,7 +472,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 +504,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
for i = 1, #vDimensions - 1 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 +552,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, nMuntinFillSide, nAreaNbr)
-- se area ha già sottoarea errore
if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then
@@ -605,21 +571,22 @@ 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)
EgtSetInfo( nAreaId, WIN_MUNTINFILL_SIDE, nMuntinFillSide)
if bFrench then
EgtSetInfo( nAreaId, WIN_SPLITTYPE, WIN_SPLITTYPES.FRENCH)
EgtSetInfo( nAreaId, WIN_DAYLIGHT_MEASURE, bDaylight)
end
-- copio il contorno dall'area parent
CopyParentOutline( nAreaId, nParentAreaId)
-- creo layer per split
local nSplitLayerId = EgtGroup( nAreaId)
EgtSetName( nSplitLayerId, WIN_BASESPLIT)
-- 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 +600,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, nMuntinFillSide, nAreaNbr)
local AreaResult = {}
@@ -647,9 +614,9 @@ function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues,
EgtSetName( nAreaId, WIN_AREA .. '(' .. WIN_SPLIT .. ')')
-- setto info
EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.SPLIT)
EgtSetInfo( nAreaId, WIN_MUNTINFILL_SIDE, nMuntinFillSide)
EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr)
EgtSetInfo( nAreaId, WIN_GRID_SPLIT, true)
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 +626,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 +705,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
Designing/WinLib/WinManageProject.lua
+30 -35
View File
@@ -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)
@@ -130,6 +117,18 @@ local function GetMeasureType( sMeasureType)
return WIN_MEASURE.PERCENTAGE
end
---------------------------------------------------------------------
local function GetMuntinSide( sSide)
if sSide == 'INTERNAL' then
return WIN_MUNTINFILL_SIDES.IN
elseif sSide == 'EXTERNAL' then
return WIN_MUNTINFILL_SIDES.OUT
elseif sSide == 'BOTH' then
return WIN_MUNTINFILL_SIDES.BOTH
end
return
end
---------------------------------------------------------------------
-- funzione che ricava la tipologia dell'anta in base al tipo di apertura e alla struttura
local function GetSashTypes( tSashes, vOpeningTypes)
@@ -237,9 +236,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 +297,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
@@ -318,14 +319,17 @@ local function ConvertTableToGeometry( AreaTable, nParentId)
-- FILL
elseif AreaTable[JWD_AREA_TYPE] == 'FILL' then
local nFillType = EgtIf( AreaTable[JWD_FILL_TYPE] == 'GLASS', WIN_FILLTYPES.GLASS, WIN_FILLTYPES.WOOD)
WinCreate.AddFill( nParentId, nFillType, nAreaNbr)
local nAreaId = WinCreate.AddFill( nParentId, nFillType, nAreaNbr)
if AreaTable[JWD_AREA_LIST] then
-- inglesine
ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][1], nAreaId)
end
-- SPLIT
elseif AreaTable[JWD_AREA_TYPE] == 'SPLIT' then
elseif AreaTable[JWD_AREA_TYPE] == 'SPLIT' or AreaTable[JWD_AREA_TYPE] == 'INGLESINA' 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,31 +337,22 @@ 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])
vHorizDimensions[i] = vSplitHorizDimensions[i][JWD_DIMENSION]
end
local nMuntinFillSide = GetMuntinSide( AreaTable[JWD_MUNTIN_SIDE]) -- lato inglesine
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, nMuntinFillSide, 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, false, true, nMuntinFillSide, 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, false, true, nMuntinFillSide, nAreaNbr)
end
for i = 1, #vSplitAreas do
ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][i], vSplitAreas[i])
Designing/WinProject.lua
+38 -25
View File
@@ -163,14 +163,14 @@ end
_G.GetProfileThresholdsList = GetProfileThresholdsList
----------------------------------------------------------------------------------
local function GetProfileData( nFrameGrp, nSashGrp)
local function GetProfileData( vGrps)
local tData = {}
-- a) dimensioni
for i = 1, 2 do
for i = 1, #vGrps do
-- scorro tutti i profili e salvo le dimensioni
local sName = EgtIf( i == 1, WIN_FRAME, WIN_SASH)
local vProfiles = EgtGetAllInGroup( EgtIf( i ==1, nFrameGrp, nSashGrp))
local sName = EgtGetName( vGrps[i])
local vProfiles = EgtGetAllInGroup( vGrps[i])
for j = 1, #vProfiles do
local sCurrName = sName .. '_' .. EgtGetName( vProfiles[j])
tData[sCurrName .. '_' .. WIN_DIM_STD] = EgtGetInfo( vProfiles[j], WIN_DIM_STD, 'd')
@@ -181,7 +181,7 @@ local function GetProfileData( nFrameGrp, nSashGrp)
-- b) overlap
-- tra ante e telaio
local vProfiles = EgtGetAllInGroup( nFrameGrp)
local vProfiles = EgtGetAllInGroup( vGrps[1])
for i = 1, #vProfiles do
local dTopOverlap = EgtGetInfo( vProfiles[i], WIN_SASH_TOP_OVERLAP, 'd')
local dBottomOverlap = EgtGetInfo( vProfiles[i], WIN_SASH_BOTTOM_OVERLAP, 'd')
@@ -194,25 +194,27 @@ local function GetProfileData( nFrameGrp, nSashGrp)
end
-- tra ante battenti/riceventi
local nSashActive = EgtGetFirstNameInGroup( nSashGrp, WIN_SASH_ACTIVE)
local nSashActive = EgtGetFirstNameInGroup( vGrps[2], WIN_SASH_ACTIVE)
if nSashActive then
tData[WIN_SASH_ACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashActive, WIN_OVERLAP, 'd')
tData[WIN_SASH_INACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashActive, WIN_OVERLAP, 'd')
end
local nSashFrench = EgtGetFirstNameInGroup( nSashGrp, WIN_FRENCH_IN)
local nSashFrench = EgtGetFirstNameInGroup( vGrps[2], WIN_FRENCH_IN)
if nSashFrench then
tData[WIN_FRENCH_IN .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashFrench, WIN_OVERLAP, 'd')
tData[WIN_FRENCH_OUT .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashFrench, WIN_OVERLAP, 'd')
end
local nSlideActive = EgtGetFirstNameInGroup( nSashGrp, WIN_SLIDE_ACTIVE)
local nSlideActive = EgtGetFirstNameInGroup( vGrps[2], WIN_SLIDE_ACTIVE)
if nSlideActive then
tData[WIN_SLIDE_ACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSlideActive, WIN_OVERLAP, 'd')
end
-- tra bottomrail
local nFrameBottomRail = EgtGetFirstNameInGroup( nFrameGrp, WIN_RAIL_BOTTOM)
local nFrameBottomRail = EgtGetFirstNameInGroup( vGrps[1], WIN_RAIL_BOTTOM)
if nFrameBottomRail then
tData[WIN_FRAME .. '_'.. WIN_BOTTOMRAIL .. '_' .. WIN_OVERLAP] = EgtGetInfo( nFrameBottomRail, WIN_OVERLAP, 'd')
end
local nSashBottomRail = EgtGetFirstNameInGroup( nSashGrp, WIN_RAIL_BOTTOM)
local nSashBottomRail = EgtGetFirstNameInGroup( vGrps[2], WIN_RAIL_BOTTOM)
if nSashBottomRail then
tData[WIN_SASH .. '_'.. WIN_BOTTOMRAIL .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashBottomRail, WIN_OVERLAP, 'd')
end
@@ -222,14 +224,15 @@ end
----------------------------------------------------------------------------------
local function WinGetProfileData()
local tData
if _G.sProfile == WDG.PROFILE then
-- se profilo corrente
local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
local nFrameGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_FRAME)
local nSashGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_SASH)
tData = GetProfileData( nFrameGrp, nSashGrp)
local nFillGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_FILL)
tData = GetProfileData( { nFrameGrp, nSashGrp, nFillGrp})
else
-- importo temporaneamente il profilo
local nLastId = EgtGetLastInGroup( GDB_ID.ROOT)
@@ -240,7 +243,7 @@ local function WinGetProfileData()
table.insert( vGrps, nCurrId)
nCurrId = EgtGetNext( nCurrId)
end
tData = GetProfileData( vGrps[1], vGrps[2])
tData = GetProfileData( vGrps)
EgtErase( vGrps)
end
WDG.PROFILEDATA = tData
@@ -267,15 +270,17 @@ _G.WinCreate_AddSash = WinCreate_AddSash
----------------------------------------------------------------------------------
local function WinCreate_AddSashGroup()
local MeasureTypeList = GetVariableList( 'MEASURETYPE')
local DimensionList = GetVariableList( 'DIMENSION')
local JointList = GetVariableList( 'JOINT')
local SashTypeList = GetVariableList( 'SASHTYPE')
local OpeningTypeList = GetVariableList( 'OPENINGTYPE')
local SashNbrList = GetVariableList( 'SASHNBR')
local AreaList = WinCreate.AddSashGroup( WDG.AREAID, WDG.MEASURETYPE, DimensionList, JointList, SashTypeList, OpeningTypeList, WDG.AREANBR, SashNbrList)
local AreaList = WinCreate.AddSashGroup( WDG.AREAID, MeasureTypeList, DimensionList, WDG.DAYLIGHT, JointList, nil, SashTypeList, OpeningTypeList, WDG.AREANBR, SashNbrList)
FillVariableList( 'AREAID', AreaList)
CleanVariableList( 'MEASURETYPE')
CleanVariableList( 'DIMENSION')
CleanVariableList( 'JOINT')
CleanVariableList( 'SASHTYPE')
@@ -310,23 +315,38 @@ _G.WinCreate_AddThreshold = WinCreate_AddThreshold
----------------------------------------------------------------------------------
local function WinCreate_AddSplits()
local MeasureTypeList = GetVariableList( 'MEASURETYPE')
local PositionList = GetVariableList( 'POSITION')
local AreaList = WinCreate.AddSplits( WDG.AREAID, WDG.SPLITORIENTATION, WDG.MEASURETYPE, PositionList, false, WDG.AREANBR)
local ElemDimList = GetVariableList( 'ELEMENTDIM')
local AreaList = WinCreate.AddSplits( WDG.AREAID, WDG.SPLITORIENTATION, MeasureTypeList, PositionList, ElemDimList, false, true, WDG_MUNTINSIDE, WDG.AREANBR)
FillVariableList( 'AREAID', AreaList)
CleanVariableList( 'MEASURETYPE')
CleanVariableList( 'POSITION')
CleanVariableList( 'ELEMENTDIM')
end
_G.WinCreate_AddSplits = WinCreate_AddSplits
----------------------------------------------------------------------------------
local function WinCreate_AddGridSplits()
local MeasureTypeListVert = GetVariableList( 'MEASURETYPE_VERT')
local MeasureTypeListHoriz = GetVariableList( 'MEASURETYPE_HORIZ')
local PositionListVert = GetVariableList( 'POSITION_VERT')
local PositionListHoriz = GetVariableList( 'POSITION_HORIZ')
local ElemDimListVert = GetVariableList( 'ELEMENTDIM_VERT')
local ElemDimListHoriz = GetVariableList( 'ELEMENTDIM_HORIZ')
local AreaList = WinCreate.AddGridSplits( WDG.AREAID, WDG.MEASURETYPE, PositionListVert, PositionListHoriz, WDG.STARTVERTICAL, WDG.AREANBR)
local AreaList = WinCreate.AddGridSplits( WDG.AREAID, MeasureTypeListVert, PositionListVert, MeasureTypeListHoriz, PositionListHoriz, WDG.STARTVERTICAL,
ElemDimListVert, ElemDimListHoriz, WDG.MUNTINSIDE, WDG.AREANBR)
FillVariableList( 'AREAID', AreaList)
CleanVariableList( 'MEASURETYPE_VERT')
CleanVariableList( 'MEASURETYPE_HORIZ')
CleanVariableList( 'POSITION_VERT')
CleanVariableList( 'POSITION_HORIZ')
CleanVariableList( 'ELEMENTDIM_VERT')
CleanVariableList( 'ELEMENTDIM_HORIZ')
end
_G.WinCreate_AddGridSplits = WinCreate_AddGridSplits
@@ -354,12 +374,6 @@ local function WinCalculate_CreatePartFromArea()
end
_G.WinCalculate_CreatePartFromArea = WinCalculate_CreatePartFromArea
----------------------------------------------------------------------------------
local function WinCalculate_RecalcSolids()
WinCalculate.RecalcSolids( WDG.FRAMEID)
end
_G.WinCalculate_RecalcSolids = WinCalculate_RecalcSolids
----------------------------------------------------------------------------------
local function WinCalculate_AddHardware()
WDG.HARDWAREKIT_LIST, WDG.HARDWAREPOSITION_LIST, WDG.HARDWAREOPTION_LIST = WinCalculate.AddHardware( WDG.FRAMEID, WDG.CALC_MACHINING, WDG.CALC_HARDWARELIST, WDG.CALC_POSITIONLIST, WDG.CALC_OPTIONLIST)
@@ -512,8 +526,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 .. '*')
@@ -535,7 +548,7 @@ local function WinGetAreaProfiles()
vProfiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES .. tostring( nOrder), 'vs')
end
else
table.insert( tabProfiles, { GroupId = vAreaNbrs[i], EntId = -1, Profiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES, 'vs')})
table.insert( tabProfiles, { GroupId = vAreaNbrs[i], EntId = 0, Profiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES, 'vs')})
end
end
end