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
+201 -256
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 -- Intestazioni
require( 'EgtBase') require( 'EgtBase')
_ENV = EgtProtectGlobal() _ENV = EgtProtectGlobal()
EgtEnableDebug( false) EgtEnableDebug( false)
-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-- TODO DA CANCELLARE!!!! quando verrà passato automaticamente da programma -- TODO DA CANCELLARE!!!! quando verrà passato automaticamente da programma
local WIN = {} --local WIN = {}
WIN.BASEDIR = 'C:\\EgtData\\Window\\CAMAuto' --WIN.BASEDIR = 'C:\\EgtData\\Window\\CAMAuto'
WIN.FILE = 'C:\\Temp\\Window.nge' --WIN.FILE = 'C:\\Temp\\TestSerramenti\\4.bwe'
--WIN.MACHINE = 'Saomad-Just3500'
--WIN.FLAG = 2
-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-- Imposto direttorio libreria specializzata per serramenti -- Imposto direttorio libreria specializzata per serramenti
EgtAddToPackagePath( WIN.BASEDIR .. '\\LuaLibs\\?.lua') EgtAddToPackagePath( WIN.BASEDIR .. '\\LuaLibs\\?.lua')
-- Imposto direttorio strategie. N.B. Le strategie dovranno essere caricate con il nome del direttorio padre -- Imposto direttorio strategie. N.B. Le strategie dovranno essere caricate con il nome del direttorio padre
EgtAddToPackagePath( WIN.BASEDIR .. '\\Strategies\\?.lua') EgtAddToPackagePath( WIN.BASEDIR .. '\\Strategies\\?.lua')
local sTxtLogFile = EgtChangePathExtension( WIN.FILE, '.txt') -- carico il progetto
EgtOpenFile( WIN.FILE) 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 sMachDir = EgtGetCurrMachineDir()
local sMachine = WIN.MACHINE
EgtResetCurrMachGroup()
if not sMachDir then 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 return
end end
if not EgtExistsFile( sMachDir .. '\\Window\\WinData.lua') then 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 return
end 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 -- Elimino direttori altre macchine e imposto direttorio macchina corrente per ricerca librerie
EgtRemoveBaseMachineDirFromPackagePath() EgtRemoveBaseMachineDirFromPackagePath()
@@ -44,6 +71,9 @@ _G.package.loaded.FeatureData = nil
_G.package.loaded.MachiningLib = nil _G.package.loaded.MachiningLib = nil
local WinExec = require( 'WinExec') local WinExec = require( 'WinExec')
local WinLib = require( 'WinLib')
local JSON = require( 'JSON')
local PartData = require( 'PartData')
-- Carico i dati globali -- Carico i dati globali
local WinData = require( 'WinData') local WinData = require( 'WinData')
@@ -51,9 +81,6 @@ local WinData = require( 'WinData')
-- Variabili globali -- Variabili globali
PARTS = {} -- tabella contenente tutte le informazioni di ogni pezzo PARTS = {} -- tabella contenente tutte le informazioni di ogni pezzo
-- Colore del grezzo
local ColA = Color3d( 255, 165, 0, 30)
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
local function GetDataConfig() local function GetDataConfig()
-- recupero utensili dal magazzino -- recupero utensili dal magazzino
@@ -63,6 +90,25 @@ local function GetDataConfig()
return true return true
end 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 function WriteErrToLogFile( nErr, sMsg, nRot, idCut, idTask)
local hFile = io.open( sTxtLogFile, 'a') local hFile = io.open( sTxtLogFile, 'a')
@@ -74,39 +120,28 @@ local function WriteErrToLogFile( nErr, sMsg, nRot, idCut, idTask)
hFile:close() hFile:close()
end 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 *** -- *** Recupero i pezzi da processare ***
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
local function MyProcessInputData() local function MyProcessInputData()
-- Recupero le travi selezionate
local nId = EgtGetFirstInGroup( GDB_ID.ROOT) local nId = EgtGetFirstPart()
while nId do while nId do
-- Per capire se è un pezzo controllo una nota, servirebbe info dedicata, oppure essere sicuri che vengano passati solo pezzi -- TODO caricare il file di costanti
if EgtGetInfo( nId, 'OFFY_1', 'd') then -- 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)))}) 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 end
nId = EgtGetNext( nId) nId = EgtGetNext( nId)
end end
if #PARTS == 0 then
EgtOutBox( 'Non ci sono pezzi', 'Lavora Pezzi', 'ERROR') PartData.GetDimensionPart( PARTS)
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
EgtDeselectAll() EgtDeselectAll()
@@ -114,160 +149,20 @@ local function MyProcessInputData()
end end
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
local function GetDispOffsetFromNotes( nPieceIndex) -- *** Inserimento dei pezzi nel grezzo ***
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 ***
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
local function MyProcessPieces() local function MyProcessPieces()
-- creo macchinata -- recupero macchinata (è sempre la prima e ce n'è solo una)
local MachGroupName = NewMachGroupName() local nMachGroup = EgtGetFirstMachGroup()
local nMachGroup = EgtAddMachGroup( MachGroupName) EgtSetCurrMachGroup( nMachGroup)
-- si crea il grezzo for i = 1, #PARTS do
CreateRaws( PARTS) PARTS[i].idRaw = EgtGetRawPartFromPart( PARTS[i].id)
end
-- allineo i pezzi come orientamento richiesto dalla macchina
AlignRawsToTable( PARTS)
-- aggiungo sovramateriale ai grezzi -- aggiungo sovramateriale ai grezzi
AddOverMaterialToRaw( PARTS) PartData.AddOverMaterialToRaw( PARTS)
-- recupero offset per posizionamento -- recupero offset per posizionamento
for i = 1, #PARTS do for i = 1, #PARTS do
@@ -275,24 +170,21 @@ local function MyProcessPieces()
PARTS[i].DispOffsets.Phase1 = {} PARTS[i].DispOffsets.Phase1 = {}
PARTS[i].DispOffsets.Phase2 = {} 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)
end
-- se non sono stati inseriti o c'è stato un errore esco subito -- se non sono stati inseriti o c'è stato un errore esco subito
if not bInsertedAllOffs then if not bInsertedAllOffs then
EgtOutBox( 'Errore offset non trovati', 'BatchProcessWin', 'ERROR', 'OK')
return false return false
end end
end end
-- si dispongono i pezzi sulla tavola -- si dispongono i pezzi sulla tavola
local bDispOk, sErr = WinData.ExecDisposition( PARTS) local bDispOk, sErr = WinData.AdjustDisposition( PARTS)
if not bDispOk then if not bDispOk then
if not sErr then if not sErr then
sErr = 'Errore non gestito in WinData.ExecDisposition' sErr = 'Errore non gestito in WinData.AdjustDisposition'
end end
EgtOutBox( sErr, 'ProcessWin', 'ERROR', 'OK') EgtOutBox( sErr, 'BatchProcessWin', 'ERROR', 'OK')
return false return false
end end
@@ -305,91 +197,126 @@ local function MyProcessPieces()
return true return true
end end
-------------------------------------------------------------------------------------------------------------
-- *** Inserimento delle lavorazioni ***
-------------------------------------------------------------------------------------------------------------
local function MyProcessFeatures()
local bOk = WinExec.ProcessFeatures( PARTS)
return true
end
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
-- *** Esecuzione *** -- *** 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 = '' -- se il progetto deve essere completamente riprocessato
if WIN.FLAG == 0 then if WIN.FLAG == 1 then
sFlag = 'CHECK+GENERATE' 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 else
sFlag = 'FLAG='..tostring( WIN.FLAG) bToProcess = false
end 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) EgtOutLog( sLog)
-- Se da elaborare -- se bisogna processare
EgtOutLog( ' +++ Processing Parts >>>') if bToProcess then
-- Se da elaborare
EgtOutLog( ' +++ Processing Parts >>>')
-- nascondo geometrie varie -- nascondo geometrie varie
local vAuxId = { EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Profile'), EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Area*'), EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Aux')} local vAuxId = { EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Profile'), EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Area*'), EgtGetFirstNameInGroup( GDB_ID.ROOT, 'Aux')}
EgtSetStatus( vAuxId, GDB_ST.OFF) 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 -- Abilito Vmill
EgtSetInfo( EgtGetCurrMachGroup(), 'Vm', '1') 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 -- Salvo il progetto
local _, sName, _ = EgtSplitPath( WIN.FILE) EgtSaveFile( WIN.FILE)
EgtSetInfo( EgtGetCurrMachGroup(), 'NcName', sName .. '.cnc')
-- altrimenti è solo da ricalcolare (eventualmente)
-- Salvo il progetto else
EgtSaveFile( WIN.FILE) -- 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
-- *** Eseguo simulazione con verifica collisione in cieco *** bToRecalc = true
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 end
WIN.ROT = 0 EgtOutLog( ' +++ Loading Project already processed >>>')
WIN.CUTID = 0 -- Passo in modalità lavora
WIN.TASKID = 0 EgtSetCurrMachGroup( EgtGetLastMachGroup())
local vItem = EgtSplitString( sErr, ';') or {} -- Se necessario eseguo aggiornamento con setup corrente e ricalcolo delle lavorazioni
for i = 1, #vItem do if bToRecalc then
vItem[i] = EgtTrim( vItem[i] or '') 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 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 end
-- *** Genero programma CN *** ( se richiesto) -- *** Genero programma CN *** ( se richiesto)
@@ -402,8 +329,26 @@ end
-- *** Eseguo stima tempi *** -- *** Eseguo stima tempi ***
EgtOutLog( ' +++ Estimating T&L >>>') EgtOutLog( ' +++ Estimating T&L >>>')
if not EgtEstimate( '', 'EgtCAM5 - ' .. WIN.FILE) then 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 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') EgtOutLog( ' +++ BatchProcess completed')
CAMAuto/CreateMachGroups.lua
+29 -71
View File
@@ -1,7 +1,5 @@
-- Process.lua by Egalware s.r.l. 2024/06/13 -- CreateMachGroups.lua by Egalware s.r.l. 2026/02/09
-- Gestione calcolo disposizione e lavorazioni per serramenti -- Creazione dei MachGroup del file già aperto
-- Si opera sulla macchina corrente
-- 2024/06/13 PRIMA VERSIONE
-- Intestazioni -- Intestazioni
@@ -9,8 +7,27 @@ require( 'EgtBase')
_ENV = EgtProtectGlobal() _ENV = EgtProtectGlobal()
EgtEnableDebug( false) 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() local sMachDir = EgtGetCurrMachineDir()
if not sMachDir then if not sMachDir then
EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Serramenti', 'ERROR') EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Serramenti', 'ERROR')
@@ -29,6 +46,9 @@ EgtAddToPackagePath( sMachDir .. '\\Window\\?.lua')
EgtOutLog( '*** Window Process Start ***', 1) EgtOutLog( '*** Window Process Start ***', 1)
-- Carico le librerie -- Carico le librerie
EgtAddToPackagePath( EgtGetSourceDir() .. 'LuaLibs\\?.lua')
local WinLib = require( 'WinLib')
local PartData = require( 'PartData')
-- Carico i dati globali -- Carico i dati globali
local WinData = require( 'WinData') local WinData = require( 'WinData')
@@ -40,37 +60,11 @@ GROUPS = {}
-- Colore del grezzo -- Colore del grezzo
local ColA = Color3d( 255, 165, 0, 30) 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 *** -- *** Recupero i pezzi da processare ***
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
local function GetInfoPieces() local function GetInfoPieces()
-- Recupero le travi selezionate -- Recupero i pezzi delle finestre
local nId = EgtGetFirstPart() local nId = EgtGetFirstPart()
while nId do while nId do
-- TODO caricare il file di costanti -- TODO caricare il file di costanti
@@ -96,7 +90,7 @@ local function GetInfoPieces()
PARTS[i].DispOffsets.Phase1 = {} PARTS[i].DispOffsets.Phase1 = {}
PARTS[i].DispOffsets.Phase2 = {} PARTS[i].DispOffsets.Phase2 = {}
local bInsertedAllOffs = GetDispOffsetFromNotes( i) local bInsertedAllOffs = PartData.GetDispOffsetFromNotes( PARTS, i)
-- recupero info profili -- recupero info profili
PARTS[i].SemiProfiles = {} PARTS[i].SemiProfiles = {}
@@ -117,6 +111,7 @@ local function GetInfoPieces()
-- se non sono stati inseriti o c'è stato un errore esco subito -- se non sono stati inseriti o c'è stato un errore esco subito
if not bInsertedAllOffs then if not bInsertedAllOffs then
EgtOutBox( 'Errore offset non trovati', 'BatchProcessWin', 'ERROR', 'OK')
return false return false
end end
@@ -131,43 +126,6 @@ local function GetInfoPieces()
return true return true
end 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 -- Crea il grezzo che verrà messo in macchina
--------------------------------------------------------------------- ---------------------------------------------------------------------
@@ -335,7 +293,7 @@ local function CreateMachGroups()
AlignRawsToTable( GROUPS[j]) AlignRawsToTable( GROUPS[j])
-- aggiungo sovramateriale ai grezzi -- aggiungo sovramateriale ai grezzi
AddOverMaterialToRaw( GROUPS[j]) PartData.AddOverMaterialToRaw( GROUPS[j])
-- si dispongono i pezzi sulla tavola -- si dispongono i pezzi sulla tavola
local bDispOk, sErr = WinData.ExecDisposition( GROUPS[j]) 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 *** -- *** variabili globali ***
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
TOOLS = nil TOOLS = {}
MACHININGS = nil 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??? -- *** COSTANTI *** TODO -> DA SPOSTARE IN WINDATA???
@@ -192,6 +193,17 @@ function WinExec.GetToolsFromDB()
end 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 *** -- *** Inserimento delle lavorazioni nelle travi ***
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
@@ -218,6 +230,8 @@ local function CollectFeatures( vProc, Part, nIndexPart)
Proc.sType = sType Proc.sType = sType
Proc.b3Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD) Proc.b3Box = EgtGetBBoxGlob( ProcId, GDB_BB.STANDARD)
Proc.nPhase = EgtGetInfo( ProcId, 'PHASE', 'i') or nil 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 -- se esiste la geometria
if Proc.b3Box and not Proc.b3Box:isEmpty() then 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 elseif isVector3d( value) then
CopiedTable[ key] = Vector3d( value) CopiedTable[ key] = Vector3d( value)
else else
CopiedTable[ key] = BeamLib.TableCopyDeep( value) CopiedTable[ key] = WinLib.TableCopyDeep( value)
end end
else else
CopiedTable[ key] = value CopiedTable[ key] = value
CAMAuto/ProcessWin.lua
+8 -78
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 -- Imposto direttorio strategie. N.B. Le strategie dovranno essere caricate con il nome del direttorio padre
EgtAddToPackagePath( WIN.BASEDIR .. '\\Strategies\\?.lua') 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() local sMachDir = EgtGetCurrMachineDir()
if not sMachDir then if not sMachDir then
EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Serramenti', 'ERROR') EgtOutBox( 'Errore nel caricamento della macchina corrente', 'Lavora Serramenti', 'ERROR')
@@ -44,6 +44,7 @@ _G.package.loaded.FeatureData = nil
_G.package.loaded.MachiningLib = nil _G.package.loaded.MachiningLib = nil
local WinExec = require( 'WinExec') local WinExec = require( 'WinExec')
local PartData = require( 'PartData')
-- Carico i dati globali -- Carico i dati globali
local WinData = require( 'WinData') local WinData = require( 'WinData')
@@ -58,7 +59,7 @@ local ColA = Color3d( 255, 165, 0, 30)
-- *** Recupero i pezzi da processare *** -- *** Recupero i pezzi da processare ***
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
local function MyProcessInputData() local function MyProcessInputData()
-- Recupero le travi selezionate -- Recupero i pezzi selezionati
local nId = EgtGetFirstSelectedObj() local nId = EgtGetFirstSelectedObj()
while nId do while nId do
local nPartId = EgtGetParent( EgtGetParent( nId or GDB_ID.NULL) or GDB_ID.NULL) local nPartId = EgtGetParent( EgtGetParent( nId or GDB_ID.NULL) or GDB_ID.NULL)
@@ -76,22 +77,8 @@ local function MyProcessInputData()
end end
nId = EgtGetNextSelectedObj() nId = EgtGetNextSelectedObj()
end end
if #PARTS == 0 then
EgtOutBox( 'Non sono state selezionati pezzi', 'Lavora Pezzi', 'ERROR') PartData.GetDimensionPart( PARTS)
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
EgtDeselectAll() EgtDeselectAll()
@@ -107,26 +94,6 @@ local function GetDataConfig()
return true return true
end 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) local function GetDispOffsetFromInput( nPieceIndex)
-- assegno alle stringhe i valori letti, in modo che vengano proposti quelli nel dialogo -- assegno alle stringhe i valori letti, in modo che vengano proposti quelli nel dialogo
@@ -151,43 +118,6 @@ local function GetDispOffsetFromInput( nPieceIndex)
return true return true
end 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 -- Crea il grezzo che verrà messo in macchina
--------------------------------------------------------------------- ---------------------------------------------------------------------
@@ -246,7 +176,7 @@ local nMachGroupId = EgtGetFirstMachGroup()
end end
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
-- *** Inserimento delle travi nel grezzo *** -- *** Inserimento dei pezzi nel grezzo ***
------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------
local function MyProcessPieces() local function MyProcessPieces()
@@ -261,7 +191,7 @@ local function MyProcessPieces()
AlignRawsToTable( PARTS) AlignRawsToTable( PARTS)
-- aggiungo sovramateriale ai grezzi -- aggiungo sovramateriale ai grezzi
AddOverMaterialToRaw( PARTS) PartData.AddOverMaterialToRaw( PARTS)
-- recupero offset per posizionamento -- recupero offset per posizionamento
for i = 1, #PARTS do for i = 1, #PARTS do
@@ -269,7 +199,7 @@ local function MyProcessPieces()
PARTS[i].DispOffsets.Phase1 = {} PARTS[i].DispOffsets.Phase1 = {}
PARTS[i].DispOffsets.Phase2 = {} PARTS[i].DispOffsets.Phase2 = {}
local bInsertedAllOffs = GetDispOffsetFromNotes( i) local bInsertedAllOffs = PartData.GetDispOffsetFromNotes( PARTS, i)
-- se non sono settati nelle note, li chiedo -- se non sono settati nelle note, li chiedo
if not bInsertedAllOffs then if not bInsertedAllOffs then
bInsertedAllOffs = GetDispOffsetFromInput( i) bInsertedAllOffs = GetDispOffsetFromInput( i)
Designing/Main.lua
+174 -92
View File
@@ -52,6 +52,7 @@ local dSashDim = 78
local vFrameDims = { dFrameDim, dFrameDim, dFrameDim, dFrameDim} local vFrameDims = { dFrameDim, dFrameDim, dFrameDim, dFrameDim}
local vSashDims = { dSashDim, dSashDim, dSashDim, dSashDim} 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\\Profilo78.nge'
-- local sProfilePath = 'C:\\EgtData\\EgtWindowMaker\\Profiles\\ProfiloSaomad.nge' -- local sProfilePath = 'C:\\EgtData\\EgtWindowMaker\\Profiles\\ProfiloSaomad.nge'
@@ -67,7 +68,7 @@ WinCreate.ImportProfile( sProfilePath)
-- creo telaio -- 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, 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.CHAMFER_SIDE, { WindowWidth, WindowHeight + 500, WindowHeight}, vFrameJoints, vFrameDims)
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.ROUND_ARC, { WindowWidth, 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 ------------------------ ------------------------ 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) -- { 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}, -- 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) -- { 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}, -- 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 ------------------------ ------------------------ Cambi profilo ------------------------
-- vetro / anta -- 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) -- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- local nSashId = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_RIGHT) -- local nSashId = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_RIGHT)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- vetro / anta in orizzontale -- 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) -- local nSashId = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- anta / vetro -- 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) -- local nSashId = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- vetro / anta / vetro -- 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) -- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- local nSashId = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims) -- local nSashId = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[3], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas[3], WIN_FILLTYPES.GLASS)
-- vetro / anta / anta -- 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) -- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- local nSashId1 = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims) -- local nSashId1 = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims)
-- local nSashId2 = WinCreate.AddSash( vAreas[3], 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) -- WinCreate.AddFill( nSashId2, WIN_FILLTYPES.GLASS)
-- anta battente / anta ricevente / vetro -- anta battente / anta ricevente / vetro
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 66}, { 90}) -- 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}, { 50}, { vSashJoints, vSashJoints}, { vSashDims, vSashDims}, { WIN_SASHTYPES.ACTIVE, WIN_SASHTYPES.INACTIVE}, -- 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- vetro / anta / vetro / anta (1) -- vetro / anta / vetro / anta (1)
-- 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 vAreas2 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 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}, { 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( vAreas2[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas3[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas3[1], WIN_FILLTYPES.GLASS)
-- local nSashId1 = WinCreate.AddSash( vAreas2[2], vSashJoints) -- 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) -- WinCreate.AddFill( nSashId2, WIN_FILLTYPES.GLASS)
-- vetro / anta / vetro / anta (2) -- 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) -- WinCreate.AddFill( vAreas[1], WIN_FILLTYPES.GLASS)
-- local nSashId1 = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims) -- local nSashId1 = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSashId1, WIN_FILLTYPES.GLASS) -- 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) -- WinCreate.AddFill( nSashId2, WIN_FILLTYPES.GLASS)
-- vetro / vetro / anta / anta -- 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- local nSashId1 = WinCreate.AddSash( vAreas[3], vSashJoints, vSashDims) -- 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) -- WinCreate.AddFill( nSashId2, WIN_FILLTYPES.GLASS)
-- anta / vetro con split -- 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) -- local nSashId = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSashId, WIN_FILLTYPES.GLASS) -- 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas2[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas2[2], WIN_FILLTYPES.GLASS)
-- anta con split / vetro -- 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 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreasSash[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreasSash[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- ante ( divise da split orizzontale) / vetro -- ante ( divise da split orizzontale) / 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 vAreas2 = WinCreate.AddSplits( vAreas[1], WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 30}, { 95}) -- 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) -- local nSashId1 = WinCreate.AddSash( vAreas2[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSashId1, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSashId1, WIN_FILLTYPES.GLASS)
-- local nSashId2 = WinCreate.AddSash( vAreas2[2], vSashJoints, vSashDims) -- 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') -- WinCreate.AddThreshold( nFrameId, 'Threshold')
-- anta mobile a sx -- 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}) -- { WIN_SASHTYPES.SLIDE_MOVABLE, WIN_SASHTYPES.SLIDE_FIXED}, { WIN_OPENING_TYPES.COPLANARSLIDE_RIGHT, WIN_OPENING_TYPES.FIXED})
-- WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS) -- local nFill1 = WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], 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]) -- local nSashGrpId = EgtGetParent( vSash[1])
-- WinCreate.AddHardware( nSashGrpId, '000592', 'Sx') -- WinCreate.AddHardware( nSashGrpId, '000592', 'Sx')
-- anta mobile a dx -- 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}) -- { 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], 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') -- WinCreate.AddHardware( nSashGrpId, '000592', 'Dx')
-- 2 ante mobili, sx davanti -- 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}) -- { 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], 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') -- WinCreate.AddHardware( nSashGrpId, '000593', 'Sx')
-- 2 ante mobili, dx davanti -- 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}) -- { 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], 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 -- 4 ante, le centrali sono mobili
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { 4500, 2100}, vFrameJoints, vFrameDims) -- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { 4500, 2100}, vFrameJoints, vFrameDims)
-- -- WinCreate.AddThreshold( nFrameId, 'Threshold') -- -- 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}, -- { 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_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}) -- { 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 -- 4 ante mobili
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { 4500, 2100}, vFrameJoints, vFrameDims) -- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { 4500, 2100}, vFrameJoints, vFrameDims)
-- -- WinCreate.AddThreshold( nFrameId, 'Threshold') -- -- 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}, -- { 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_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}) -- { 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) -- local nFill1 = WinCreate.AddFill( vSash[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS) -- local nFill2 = WinCreate.AddFill( vSash[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[3], WIN_FILLTYPES.GLASS) -- local nFill3 = WinCreate.AddFill( vSash[3], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSash[4], 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]) -- local nSashGrpId = EgtGetParent( vSash[1])
-- WinCreate.AddHardware( nSashGrpId, '000595', 'Dx') -- WinCreate.AddHardware( nSashGrpId, '000595', 'Dx')
@@ -266,16 +280,16 @@ local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { WindowWidth, Win
-- divisione orizzontale / verticale -- divisione orizzontale / verticale
-- WinCreate.AddBottomRail( nFrameId, 2) -- WinCreate.AddBottomRail( nFrameId, 2)
-- -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { 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}, { 70}, { 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- divisione verticale ed orizzontale (1) -- divisione verticale ed orizzontale (1)
-- WinCreate.AddBottomRail( nFrameId, 1, { 60}) -- WinCreate.AddBottomRail( nFrameId, 1, { 60})
-- local vAreas1 = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 100}) -- 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}, { 50}, { 60}) -- 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}, { 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas2[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas2[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas3[1], 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) -- divisione verticale ed orizzontale (2)
-- WinCreate.AddBottomRail( nFrameId, 1) -- 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[3], 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 -- divisione orizzontale / verticale
-- local nSashId = WinCreate.AddSash( nFrameId, vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT) -- local nSashId = WinCreate.AddSash( nFrameId, vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddBottomRail( nSashId, 1, { 100}) -- WinCreate.AddBottomRail( nSashId, 1, { 100})
-- -- local vAreas = WinCreate.AddSplits( nSashId, WIN_SPLITORIENTATION.HORIZONTAL, { 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}, { 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas[2], WIN_FILLTYPES.GLASS)
-- divisione verticale e orizzontale -- divisione verticale e orizzontale
-- local nSashId = WinCreate.AddSash( nFrameId, vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT) -- 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 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}, { 50}, { 60}) -- 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}, { 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas2[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreas2[2], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreas3[1], 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 ------------------------ ------------------------ Finestre con più ante singole ------------------------
-- due ante divisione verticale -- 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) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_RIGHT) -- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_RIGHT)
-- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS)
-- due ante divisione orizzontale -- 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) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTONLY_TOP)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTONLY_TOP) -- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTONLY_TOP)
-- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS)
-- tre ante -- 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.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) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims) -- 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) -- local nSash3Id = WinCreate.AddSash( vAreas[3], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSash3Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash3Id, WIN_FILLTYPES.GLASS)
-- tre ante una sopra e due sotto -- tre ante : una sopra e due sotto
-- local vAreas1 = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 115}) -- local vAreas1 = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 115})
-- local vAreas2 = WinCreate.AddSplits( vAreas1[2], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 95}) -- local vAreas2 = WinCreate.AddSplits( vAreas1[1], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 50, 50}, { 95})
-- local nSash1Id = WinCreate.AddSash( vAreas1[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.FIXED) -- local nSash1Id = WinCreate.AddSash( vAreas1[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.FIXED)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas2[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT) -- local nSash2Id = WinCreate.AddSash( vAreas2[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS) -- 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) -- WinCreate.AddFill( nSash3Id, WIN_FILLTYPES.GLASS)
-- sei ante (1) -- sei ante (1)
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 50}, { 105}) -- 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}, { 33.333, 33.333}, { 95, 95}) -- 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}, { 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) -- local nSash1Id = WinCreate.AddSash( vAreas1[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas1[2], vSashJoints, vSashDims) -- 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) -- WinCreate.AddFill( nSash6Id, WIN_FILLTYPES.GLASS)
-- sei ante (2) -- 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) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims) -- 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 ------------------------ ------------------------ Finestre con ante battenti e riceventi ------------------------
-- battente / ricevente -- 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- battente / ricevente / ricevente -- 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_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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- 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) -- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS)
-- battente / battente / ricevente -- 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_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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- 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) -- WinCreate.AddFill( vSashes[3], WIN_FILLTYPES.GLASS)
-- battente / battente / ricevente / ricevente -- 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}, -- { 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_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}) -- { 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 ------------------------ ------------------------ Finestre con ante singole e ante battenti/riceventi ------------------------
-- tre ante : singola / ricevente / battente -- 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) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- tre ante ( singola / ricevente/ battente) con split nelle ante -- 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 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreasSash1[2], 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}) -- { 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreasSash2[2], 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vAreasSash3[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vAreasSash3[2], WIN_FILLTYPES.GLASS)
-- 3 ante : sopra battente / ricevente, sotto singola -- 3 ante : sopra battente / ricevente, sotto singola
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 70}, { 105}) -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 30, 70}, { 105})
-- local nSash0Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.FIXED) -- local nSash0Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.FIXED)
-- WinCreate.AddFill( nSash0Id, WIN_FILLTYPES.GLASS) -- 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- 4 ante : sopra anta singola e sotto singola ( con split) / battente / ricevente -- 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 vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 70, 30}, { 95})
-- local vAreas1 = WinCreate.AddSplits( vAreas[2], WIN_SPLITORIENTATION.VERTICAL, { WIN_MEASURE.PERCENTAGE}, { 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[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTONLY_TOP) -- local nSash0Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTONLY_TOP)
-- WinCreate.AddFill( nSash0Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash0Id, WIN_FILLTYPES.GLASS)
-- local nSash1Id = WinCreate.AddSash( vAreas1[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT) -- 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[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashAreas[2], 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[2], WIN_FILLTYPES.GLASS)
-- sei ante : divisione orizzontale e per ogni divisione anta singola / battente/ ricevente -- 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) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims,WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- local nSash2Id = WinCreate.AddSash( vAreas[3], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT) -- local nSash2Id = WinCreate.AddSash( vAreas[3], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash2Id, WIN_FILLTYPES.GLASS) -- 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes1[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes1[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes1[2], 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes2[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes2[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes2[2], 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 ------------------------ ------------------------ Ferramenta ------------------------
-- local nFrameId = WinCreate.CreateFrame( WIN_FRAME_TYPES.RECT, { 1500, 2100}, vFrameJoints, vFrameDims) -- 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 -- -- WinCreate.AddHardware( nSashId, '000604', 'Sx') -- trapezio
-- 2 ante singole -- 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 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) -- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_RIGHT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- 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') -- -- WinCreate.AddHardware( nSash2Id, '000604', 'Dx')
-- 2 ante singole con apertura sul montante -- 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 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) -- local nSash2Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- 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') -- WinCreate.AddHardware( nSash2Id, '000558', 'Sx')
-- 3 ante : sotto singola, sopra battente / ricevente -- 3 ante : sotto singola, sopra battente / ricevente
-- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE}, { 60}, { 95}) -- local vAreas = WinCreate.AddSplits( nFrameId, WIN_SPLITORIENTATION.HORIZONTAL, { WIN_MEASURE.PERCENTAGE, WIN_MEASURE.PERCENTAGE}, { 60, 40}, { 95})
-- local nSash1Id = WinCreate.AddSash( vAreas[2], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT) -- local nSash1Id = WinCreate.AddSash( vAreas[1], vSashJoints, vSashDims, WIN_OPENING_TYPES.TILTTURN_LEFT)
-- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( nSash1Id, WIN_FILLTYPES.GLASS)
-- WinCreate.AddHardware( nSash1Id, '000558', 'Sx') -- 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], 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') -- WinCreate.AddHardware( nSashGrpId, '000559', 'Sx')
-- 2 ante : battente / ricevente -- 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], 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 -- -- WinCreate.AddHardware( nSashGrpId, '000599', 'Sx') -- arco ribassato
-- 2 ante : ricevente / battente -- 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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS)
-- WinCreate.AddFill( vSashes[2], 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') -- WinCreate.AddHardware( nSashGrpId, '000559', 'Dx')
-- 3 ante : battente / battente / ricevente -- 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_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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- 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') -- WinCreate.AddHardware( nSashGrpId, '000564', 'Sx')
-- 3 ante : ricevente / battente / battente -- 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_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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- 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') -- WinCreate.AddHardware( nSashGrpId, '000564', 'Dx')
-- 3 ante : battente / ricevente / ricevente -- 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_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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- 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') -- WinCreate.AddHardware( nSashGrpId, '000565', 'Sx')
-- 3 ante : ricevente / ricevente / battente -- 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_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}) -- { WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_LEFT, WIN_OPENING_TYPES.TURNONLY_RIGHT})
-- WinCreate.AddFill( vSashes[1], WIN_FILLTYPES.GLASS) -- 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') -- WinCreate.AddHardware( nSashGrpId, '000565', 'Dx')
-- 4 ante : battente / battente / ricevente / ricevente -- 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}, -- { 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_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}) -- { 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') -- WinCreate.AddHardware( nSashGrpId, '000575', 'Sx')
-- 4 ante : ricevente / ricevente / battente / battente -- 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}, -- { 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_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}) -- { 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.AddFill( nSashId, WIN_FILLTYPES.GLASS)
-- WinCreate.AddHardware( nSashId, '000573', 'Sx') -- WinCreate.AddHardware( nSashId, '000573', 'Sx')
----------------------------------------------------------------------------------- -----------------------------------------------------------------------------------
-- imposto se calcolare solidi/preview o meno -- imposto se calcolare solidi/preview o meno
Designing/WinConst.lua
+41 -19
View File
@@ -59,6 +59,7 @@ WIN_MEASURE = {
} }
-- tipologia di figli -- tipologia di figli
WIN_CHILDREN_TYPE = 'ChildrenType'
WIN_CHILDREN_TYPES = { WIN_CHILDREN_TYPES = {
NULL = 0, NULL = 0,
SASH = 1, SASH = 1,
@@ -100,13 +101,23 @@ WIN_AREATYPES = {
WIN_SPLITTYPE = 'SplitType' WIN_SPLITTYPE = 'SplitType'
WIN_SPLITTYPES = { WIN_SPLITTYPES = {
NULL = 0, NULL = 0,
MULLION = 1, -- montante nel telaio che separa due ante MULLION = 1, -- montante nel telaio che separa due ante
FRENCH = 2, -- per ante battente / ricevente FRENCH = 2, -- per ante battente / ricevente
MIXED = 3, -- cambio profilo MIXED = 3, -- cambio profilo
INSASH = 4, -- divisione nell'anta MUNTIN_SASH = 4, -- divisione nell'anta che separa due vetri
INFRAME = 5, -- divisione nel telaio che separa due vetri fissi 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 -- tipi di riempimento interno
WIN_FILLTYPE = 'FillType' WIN_FILLTYPE = 'FillType'
WIN_FILLTYPES = { WIN_FILLTYPES = {
@@ -177,38 +188,41 @@ WIN_TOP = 'Top'
WIN_LEFT = 'Left' WIN_LEFT = 'Left'
-- info varie su aree e curve -- info varie su aree e curve
WIN_SLIDE_WINDOW = 'SlideWindow'
WIN_MIXED_WINDOW = 'ProfileChangeWindow'
WIN_PART_DIM = 'PartDim' WIN_PART_DIM = 'PartDim'
WIN_SOU = 'SOU'
WIN_CHILD = 'CHILD' 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_OUTLINE = 'OutlineRef'
WIN_REF_MUNTIN = 'MuntinRef'
WIN_REF_PART = 'PartRef' WIN_REF_PART = 'PartRef'
WIN_REF_BOTTOMRAIL_PART = 'BottomRailPartRef' WIN_REF_BOTTOMRAIL_PART = 'BottomRailPartRef'
WIN_PREV_OUTLINES = 'PrevOutlines' WIN_PREV_OUTLINES = 'PrevOutlines'
WIN_NEXT_OUTLINES = 'NextOutlines' WIN_NEXT_OUTLINES = 'NextOutlines'
WIN_REF_SPLIT = 'RefSplit'
WIN_INV_SPLIT = 'InvSplit'
WIN_CRV_ON_FRENCH_SPLIT = 'OutlineOnFrenchSplit' WIN_CRV_ON_FRENCH_SPLIT = 'OutlineOnFrenchSplit'
WIN_SPLIT_STARTINTERS = 'SplitStartInters' WIN_SPLIT_STARTINTERS = 'SplitStartInters'
WIN_SPLIT_ENDINTERS = 'SplitEndInters' WIN_SPLIT_ENDINTERS = 'SplitEndInters'
WIN_SASH_CHILDREN = 'SashChildren'
WIN_FILL_CHILDREN = 'FillChildren'
WIN_THRESHOLD_PROFILE = 'ThresholdProfile' WIN_THRESHOLD_PROFILE = 'ThresholdProfile'
WIN_SLIDE_WINDOW = 'SlideWindow'
WIN_SASH_NBR = 'SashNbr' WIN_SASH_NBR = 'SashNbr'
WIN_AREA_NBR = 'AreaNbr' WIN_AREA_NBR = 'AreaNbr'
WIN_AREA_PROFILES = 'AreaProfiles' WIN_AREA_PROFILES = 'AreaProfiles'
WIN_MEASURE_VALUE = 'MeasureValue' WIN_MEASURE_VALUE = 'MeasureValue'
WIN_GRIDSPLIT_ORDER = 'GridSplitOrder' WIN_GRIDSPLIT_ORDER = 'GridSplitOrder'
WIN_SPLIT_POSITION = 'SplitPosition' WIN_SPLIT_POSITION = 'SplitPosition'
WIN_SPLIT_REF_DIM = 'SplitRefDim'
WIN_SPLIT_OFFS = 'SplitOffs' WIN_SPLIT_OFFS = 'SplitOffs'
WIN_GRID_SPLIT = 'GridSplit' WIN_GRID_SPLIT = 'GridSplit'
WIN_DAYLIGHT_MEASURE = 'DaylightMeasure'
WIN_EXTRA_CRV = 'Extra'
WIN_SPECIAL_CRV = 'Special'
-- PROFILI -- PROFILI
WIN_PROFILE = 'Profile' WIN_PROFILE = 'Profile'
WIN_PROFILEPATH = 'ProfilePath' WIN_PROFILEPATH = 'ProfilePath'
WIN_INFO_GRP = 'Info'
-- nomi dei profili -- nomi dei profili
WIN_SASH_TOP = 'Sash_Top' WIN_SASH_TOP = 'Sash_Top'
@@ -236,6 +250,9 @@ WIN_FRENCH_IN = 'French_In'
WIN_FRENCH_OUT = 'French_Out' WIN_FRENCH_OUT = 'French_Out'
WIN_SASH_SPLIT = 'Sash_Split' WIN_SASH_SPLIT = 'Sash_Split'
WIN_FILL_SPLIT_OUT = 'Fill_Split_Out'
WIN_FILL_SPLIT_IN = 'Fill_Split_In'
WIN_SLIDE = 'Slide' WIN_SLIDE = 'Slide'
WIN_MOVABLE = 'Movable' WIN_MOVABLE = 'Movable'
WIN_SLIDE_MOVABLEBACK = 'Slide_MovableBack' WIN_SLIDE_MOVABLEBACK = 'Slide_MovableBack'
@@ -335,10 +352,6 @@ WIN_PROFILETYPE = 'ProfileType'
-- GIUNZIONI -- GIUNZIONI
WIN_JOINTS = 'Joints' WIN_JOINTS = 'Joints'
WIN_JOINT_BL = 'JointBL'
WIN_JOINT_BR = 'JointBR'
WIN_JOINT_TL = 'JointTL'
WIN_JOINT_TR = 'JointTR'
WIN_STARTJOINT = 'StartJoint' WIN_STARTJOINT = 'StartJoint'
WIN_ENDJOINT = 'EndJoint' WIN_ENDJOINT = 'EndJoint'
@@ -382,10 +395,19 @@ WIN_REF_PRC = 'PrcRef'
-- CAMBIO PROFILO -- CAMBIO PROFILO
WIN_PRF_CHANGE = 'ProfileChange' 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_CURVES = 'ProfileChangeCurves'
WIN_MIXED_MILLING = 'ProfileChangeMilling' WIN_MIXED_MILLING = 'ProfileChangeMilling'
WIN_MIXED_SPLIT_REF = 'MixedSplitRef' 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 -- SOLIDI
Designing/WinJWDConst.lua
+2
View File
@@ -32,6 +32,7 @@ JWD_VALUE = 'Value'
JWD_ID_GROUP = 'GroupId' JWD_ID_GROUP = 'GroupId'
JWD_ID_SASH = 'SashId' JWD_ID_SASH = 'SashId'
JWD_MEASURE_TYPE = 'MeasureType' JWD_MEASURE_TYPE = 'MeasureType'
JWD_MEASURE_DAYLIGHT = 'IsDimensionLight'
JWD_ELEMENT_DIMENSION = 'ElementDimensionList' JWD_ELEMENT_DIMENSION = 'ElementDimensionList'
JWD_FRAME_SHAPE = 'Shape' JWD_FRAME_SHAPE = 'Shape'
@@ -51,6 +52,7 @@ JWD_SPLIT_HORIZ_POS = 'SplitHorizList'
JWD_SPLIT_AREA = 'Area' JWD_SPLIT_AREA = 'Area'
JWD_ELEMENT_VERT_DIMENSION = 'ElementDimVertList' JWD_ELEMENT_VERT_DIMENSION = 'ElementDimVertList'
JWD_ELEMENT_HORIZ_DIMENSION = 'ElementDimHorizList' JWD_ELEMENT_HORIZ_DIMENSION = 'ElementDimHorizList'
JWD_MUNTIN_SIDE = 'Side'
JWD_FILL_TYPE = 'FillType' JWD_FILL_TYPE = 'FillType'
Designing/WinLib/WinCalculate.lua
+4258 -2451
View File
File diff suppressed because it is too large Load Diff
Designing/WinLib/WinCreate.lua
+85 -100
View File
@@ -35,7 +35,6 @@ local function CopyParentOutline( nAreaId, nParentAreaId)
-- copio le curve di outline del parent e setto le corrispondenze sou/child -- copio le curve di outline del parent e setto le corrispondenze sou/child
for i = 1, #vParentCrvs do for i = 1, #vParentCrvs do
local nOutlineId = EgtCopy( vParentCrvs[i], nOutlineLayerId) local nOutlineId = EgtCopy( vParentCrvs[i], nOutlineLayerId)
EgtSetInfo( nOutlineId, WIN_SOU, vParentCrvs[i])
EgtSetInfo( vParentCrvs[i], WIN_CHILD, nOutlineId) EgtSetInfo( vParentCrvs[i], WIN_CHILD, nOutlineId)
end end
return nOutlineLayerId return nOutlineLayerId
@@ -277,7 +276,7 @@ end
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
-- funzione che aggiunge un gruppo di ante -- 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 -- se già presente sottoarea errore
if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then
@@ -285,7 +284,7 @@ function WinCreate.AddSashGroup( nParentAreaId, vMeasureTypes, vDimensions, vJoi
end end
-- creo gli split di tipo french -- 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 -- trasformo le aree risultanti ( che sono null) nelle aree dell'anta settando le info opportune
for i = 1, #vAreas do for i = 1, #vAreas do
EgtSetName( vAreas[i], EgtGetName( vAreas[i]) .. '(' .. WIN_SASH .. ')') EgtSetName( vAreas[i], EgtGetName( vAreas[i]) .. '(' .. WIN_SASH .. ')')
@@ -356,9 +355,8 @@ end
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
-- funzione che taglia lo split con il bordo della regione -- 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) EgtExtendCurveStartByLen( nSplitId, 10)
EgtExtendCurveEndByLen( nSplitId, 10) EgtExtendCurveEndByLen( nSplitId, 10)
local ptS = EgtIP( nSplitId, nCompo, EgtSP( nSplitId)) local ptS = EgtIP( nSplitId, nCompo, EgtSP( nSplitId))
@@ -367,37 +365,6 @@ local function AdjustSplitCurve( nSplitId, nCompo, vOutlineCrvs, nOutlineLayerId
local dParE = EgtCurveParamAtPoint( nSplitId, ptE) local dParE = EgtCurveParamAtPoint( nSplitId, ptE)
EgtTrimCurveStartEndAtParam( nSplitId, dParS, dParE) 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 end
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
@@ -414,20 +381,15 @@ local function GetBorderRegions( nSplitId, nCompo, nAreaId)
-- aggiungo la curva di split al bordo per chiuderlo orientandola opportunamente -- aggiungo la curva di split al bordo per chiuderlo orientandola opportunamente
local nSplitId1 = EgtCopyGlob( nSplitId, nAreaId) local nSplitId1 = EgtCopyGlob( nSplitId, nAreaId)
if AreSamePointApprox( EgtSP( nSplitId1), EgtSP( nCrv1)) then
EgtInvertCurve( nSplitId1)
end
EgtAddCurveCompoCurve( nCrv1, nSplitId1) EgtAddCurveCompoCurve( nCrv1, nSplitId1)
local _, dParE1 = EgtCurveDomain( nCrv1) local _, dParE1 = EgtCurveDomain( nCrv1)
EgtCurveCompoSetTempProp( nCrv1, dParE1 - 1, nSplitId) EgtCurveCompoSetTempProp( nCrv1, dParE1 - 1, nSplitId)
local nSplitId2 = EgtCopyGlob( nSplitId, nAreaId) local nSplitId2 = EgtCopyGlob( nSplitId, nAreaId)
if AreSamePointApprox( EgtSP( nSplitId2), EgtSP( nCrv2)) then EgtInvertCurve( nSplitId2)
EgtInvertCurve( nSplitId2)
end
EgtAddCurveCompoCurve( nCrv2, nSplitId2) EgtAddCurveCompoCurve( nCrv2, nSplitId2)
local _, dParE2 = EgtCurveDomain( nCrv2) local _, dParE2 = EgtCurveDomain( nCrv2)
EgtCurveCompoSetTempProp( nCrv2, dParE2 - 1, nSplitId) EgtCurveCompoSetTempProp( nCrv2, dParE2 - 1, - nSplitId)
return nCrv1, nCrv2 return nCrv1, nCrv2
end end
@@ -452,7 +414,7 @@ local function CreateAreasFromSplits( nAreaId, vSplitCrvs)
for i = 1, #vSplitCrvs do for i = 1, #vSplitCrvs do
-- aggiusto lo split per averlo a filo con l'outline -- 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 -- calcolo i bordi delle due regioni definite dallo split
local nCrv1, nCrv2 = GetBorderRegions( vSplitCrvs[i], nCompoRef, nGrpTmp) 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) -- 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 for j = 0, nCnt - 1 do
-- assegno le info di child e source -- assegno le info di child
EgtSetInfo( nFirst + j, WIN_SOU, vOrigCrvs[j+1]) if vOrigCrvs[j+1] < 0 then
AddInfo( vOrigCrvs[j+1], WIN_CHILD, nFirst + j) 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 -- 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) SetSplitName( nFirst + j)
else else
EgtSetName( nFirst + j, EgtGetName( vOrigCrvs[j+1])) EgtSetName( nFirst + j, EgtGetName( abs( vOrigCrvs[j+1])))
end end
end end
@@ -507,7 +472,7 @@ end
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
-- funzione che calcola le dimensioni assolute delle divisioni -- funzione che calcola le dimensioni assolute delle divisioni
local function CalcSplitDimensions( vMeasureTypes, vValues, dDim) local function CalcSplitDimensions( vMeasureTypes, vValues, dDim, dDimMax)
local vDimensions = {} local vDimensions = {}
-- calcolo le dimensioni di tutti gli split assoluti e percentuali e calcolo i valori di riferimento per eventuali split proporzionali -- calcolo le dimensioni di tutti gli split assoluti e percentuali e calcolo i valori di riferimento per eventuali split proporzionali
@@ -539,42 +504,43 @@ local function CalcSplitDimensions( vMeasureTypes, vValues, dDim)
end end
end end
-- se dimensione massima diversa da quella di calcolo ( e.g. sottoaree di griglia) scalo le dimensioni delle aree sulla dimensione massima per fare in modo che gli split non scompaiano
if dDimMax < dDim - GEO.EPS_SMALL then
for i = 1, #vDimensions do
vDimensions[i] = vDimensions[i] * dDimMax / dDim
end
end
return vDimensions return vDimensions
end 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 -- 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 vSplitCurves = {}
local dPosition = 0 local dPosition = 0
for i = 1, #vDimensions do for i = 1, #vDimensions - 1 do
-- calcolo la posizione cumulata -- calcolo la posizione cumulata
dPosition = dPosition + vDimensions[i] dPosition = dPosition + vDimensions[i]
-- creo la curva se rientra nelle dimensione limite
local nSplitCrv if dPosition < dDimMax - GEO.EPS_SMALL then
if nSplitType == WIN_SPLITORIENTATION.VERTICAL then local nSplitCrv
-- aree ordinate da sx a dx if nSplitType == WIN_SPLITORIENTATION.VERTICAL then
local dCurrPosition = dPosition -- aree ordinate da sx a dx
-- creo la linea se rientra nella regione limite nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + X_AX() * dPosition, Y_AX(), b3OutlineLayer:getDimY())
local dX = b3OutlineLayer:getMin():getX() + dCurrPosition elseif nSplitType == WIN_SPLITORIENTATION.HORIZONTAL then
if dX > b3Limit:getMin():getX() + GEO.EPS_SMALL and dX < b3Limit:getMax():getX() - GEO.EPS_SMALL then -- aree ordinate dal basso all'alto
nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + X_AX() * dCurrPosition, Y_AX(), b3OutlineLayer:getDimY()) nSplitCrv = EgtLinePVL( nLayerId, b3OutlineLayer:getMin() + Y_AX() * dPosition, X_AX(), b3OutlineLayer:getDimX())
EgtInvertCurve( nSplitCrv)
end 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) EgtSetName( nSplitCrv, WIN_SPLIT)
table.insert( vSplitCurves, nSplitCrv) table.insert( vSplitCurves, nSplitCrv)
EgtSetInfo( nSplitCrv, WIN_SPLIT_POSITION, dPosition) EgtSetInfo( nSplitCrv, WIN_SPLIT_POSITION, dPosition)
@@ -586,7 +552,7 @@ end
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
-- funzione che crea tagli split multipli -- 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 -- se area ha già sottoarea errore
if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then if EgtGetFirstNameInGroup( nParentAreaId, WIN_AREA .. '*') then
@@ -605,8 +571,12 @@ function WinCreate.AddSplits( nParentAreaId, nSplitType, vMeasureTypes, vValues,
EgtSetInfo( nAreaId, WIN_SPLIT_DIR, nSplitType) EgtSetInfo( nAreaId, WIN_SPLIT_DIR, nSplitType)
EgtSetInfo( nAreaId, WIN_MEASURE_TYPE, vMeasureTypes) EgtSetInfo( nAreaId, WIN_MEASURE_TYPE, vMeasureTypes)
EgtSetInfo( nAreaId, WIN_MEASURE_VALUE, vValues) 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_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 -- copio il contorno dall'area parent
CopyParentOutline( nAreaId, nParentAreaId) CopyParentOutline( nAreaId, nParentAreaId)
@@ -614,12 +584,9 @@ function WinCreate.AddSplits( nParentAreaId, nSplitType, vMeasureTypes, vValues,
-- creo layer per split -- creo layer per split
local nSplitLayerId = EgtGroup( nAreaId) local nSplitLayerId = EgtGroup( nAreaId)
EgtSetName( nSplitLayerId, WIN_BASESPLIT) 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 -- 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 if #vSplitCurves == 0 then
-- se non ci sono curve valide cancello tutto ed esco -- se non ci sono curve valide cancello tutto ed esco
EgtErase( nAreaId) EgtErase( nAreaId)
@@ -633,7 +600,7 @@ end
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
-- funzione che crea tagli split grid -- 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 = {} local AreaResult = {}
@@ -647,9 +614,9 @@ function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues,
EgtSetName( nAreaId, WIN_AREA .. '(' .. WIN_SPLIT .. ')') EgtSetName( nAreaId, WIN_AREA .. '(' .. WIN_SPLIT .. ')')
-- setto info -- setto info
EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.SPLIT) EgtSetInfo( nAreaId, WIN_AREATYPE, WIN_AREATYPES.SPLIT)
EgtSetInfo( nAreaId, WIN_MUNTINFILL_SIDE, nMuntinFillSide)
EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr) EgtSetInfo( nAreaId, WIN_AREA_NBR, nAreaNbr)
EgtSetInfo( nAreaId, WIN_GRID_SPLIT, true) EgtSetInfo( nAreaId, WIN_GRID_SPLIT, true)
EgtSetInfo( nAreaId, WIN_PART_DIM, vPartsDim)
-- copio il contorno dall'area parent e setto opportune corrispondenze sou/child -- copio il contorno dall'area parent e setto opportune corrispondenze sou/child
local nOutlineLayerId = CopyParentOutline( nAreaId, nParentAreaId) local nOutlineLayerId = CopyParentOutline( nAreaId, nParentAreaId)
@@ -659,54 +626,72 @@ function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues,
local nSplitLayerId = EgtGroup( nAreaId) local nSplitLayerId = EgtGroup( nAreaId)
EgtSetName( nSplitLayerId, WIN_BASESPLIT) EgtSetName( nSplitLayerId, WIN_BASESPLIT)
-- stabilisco direzione principale e secondaria -- stabilisco dati per direzione principale e secondaria
local vMainTypes, vOtherTypes, vMainValues, vOtherValues, nMainSplitOrientation, nOtherSplitOrientation local vMainTypes, vOtherTypes, vMainValues, vOtherValues, nMainSplitOrientation, nOtherSplitOrientation, vMainDim, vOtherDim
if bStartVertical then if bStartVertical then
vMainTypes = vVertMeasureTypes vMainTypes = vVertMeasureTypes
vMainValues = vVertValues vMainValues = vVertValues
nMainSplitOrientation = WIN_SPLITORIENTATION.VERTICAL nMainSplitOrientation = WIN_SPLITORIENTATION.VERTICAL
vMainDim = vVertDim
vOtherTypes = vHorizMeasureTypes vOtherTypes = vHorizMeasureTypes
vOtherValues = vHorizValues vOtherValues = vHorizValues
nOtherSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL nOtherSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL
vOtherDim = vHorizDim
else else
vMainTypes = vHorizMeasureTypes vMainTypes = vHorizMeasureTypes
vMainValues = vHorizValues vMainValues = vHorizValues
nMainSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL nMainSplitOrientation = WIN_SPLITORIENTATION.HORIZONTAL
vMainDim = vHorizDim
vOtherTypes = vVertMeasureTypes vOtherTypes = vVertMeasureTypes
vOtherValues = vVertValues vOtherValues = vVertValues
nOtherSplitOrientation = WIN_SPLITORIENTATION.VERTICAL nOtherSplitOrientation = WIN_SPLITORIENTATION.VERTICAL
vOtherDim = vVertDim
end end
-- salvo i dati dello split principale nell'area principale, i dati dello split secondario verranno salvati nelle aree virtuali -- 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_SPLIT_DIR, nMainSplitOrientation)
EgtSetInfo( nAreaId, WIN_MEASURE_TYPE, vMainTypes) EgtSetInfo( nAreaId, WIN_MEASURE_TYPE, vMainTypes)
EgtSetInfo( nAreaId, WIN_MEASURE_VALUE, vMainValues) 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 -- 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 for i = 1, #vMainSplit do
EgtSetInfo( vMainSplit[i], WIN_GRIDSPLIT_ORDER, 0) EgtSetInfo( vMainSplit[i], WIN_GRIDSPLIT_ORDER, 0)
end end
local vMainAreas = CreateAreasFromSplits( nAreaId, vMainSplit) 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 for i = 1, #vMainAreas do
-- recupero outline per calcolare il limite delle curve di split
local nAreaOutlineLayerId = EgtGetFirstNameInGroup( vMainAreas[i], WIN_AREAOUTLINE) local nAreaOutlineLayerId = EgtGetFirstNameInGroup( vMainAreas[i], WIN_AREAOUTLINE)
local b3Limit = EgtGetBBox( nAreaOutlineLayerId, GDB_BB.STANDARD) local b3Curr = EgtGetBBox( nAreaOutlineLayerId, GDB_BB.STANDARD)
local dDim = EgtIf( nOtherSplitOrientation == WIN_SPLITORIENTATION.VERTICAL, b3Curr:getDimX(), b3Curr:getDimY())
-- calcolo gli split nella direzione secondaria if dDim < dMinDim - GEO.EPS_SMALL then
local vOtherSplit = CalcSplitCurves( nSplitLayerId, b3OutlineLayer, b3Limit, nOtherSplitOrientation, vOtherTypes, vOtherValues) dMinDim = dDim
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)
end end
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 -- sposto le aree secondarie nell'area di split e le rinomino
for i = 1, #AreaResult do for i = 1, #AreaResult do
@@ -720,7 +705,7 @@ function WinCreate.AddGridSplits( nParentAreaId, vVertMeasureTypes, vVertValues,
EgtSetInfo( vMainAreas[i], WIN_SPLIT_DIR, nOtherSplitOrientation) EgtSetInfo( vMainAreas[i], WIN_SPLIT_DIR, nOtherSplitOrientation)
EgtSetInfo( vMainAreas[i], WIN_MEASURE_TYPE, vOtherTypes) EgtSetInfo( vMainAreas[i], WIN_MEASURE_TYPE, vOtherTypes)
EgtSetInfo( vMainAreas[i], WIN_MEASURE_VALUE, vOtherValues) 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 end
return AreaResult return AreaResult
Designing/WinLib/WinManageProject.lua
+30 -35
View File
@@ -47,19 +47,6 @@ local function GetDimensions( tDimensions)
return vDims return vDims
end 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) local function GetFrameShape( sShape)
@@ -130,6 +117,18 @@ local function GetMeasureType( sMeasureType)
return WIN_MEASURE.PERCENTAGE return WIN_MEASURE.PERCENTAGE
end 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 -- funzione che ricava la tipologia dell'anta in base al tipo di apertura e alla struttura
local function GetSashTypes( tSashes, vOpeningTypes) local function GetSashTypes( tSashes, vOpeningTypes)
@@ -237,9 +236,10 @@ local function ConvertTableToGeometry( AreaTable, nParentId)
-- recupero dati -- recupero dati
local tSashes = AreaTable[JWD_SASH_LIST] local tSashes = AreaTable[JWD_SASH_LIST]
local nBottomRailNbr = 0 local nBottomRailNbr = 0
local vElementDim = GetDimensions( AreaTable[JWD_BR_ELEMENT_DIMENSION]) local vElementDim = {}
if AreaTable[JWD_BOTTOMRAIL] then if AreaTable[JWD_BOTTOMRAIL] then
nBottomRailNbr = AreaTable[JWD_BOTTOMRAIL_QTY] nBottomRailNbr = AreaTable[JWD_BOTTOMRAIL_QTY]
vElementDim = GetDimensions( AreaTable[JWD_BR_ELEMENT_DIMENSION])
end end
-- lettura opzioni ferramenta -- lettura opzioni ferramenta
@@ -297,9 +297,10 @@ local function ConvertTableToGeometry( AreaTable, nParentId)
vPartsDim[i] = GetDimensions( tSashes[i][JWD_ELEMENT_DIMENSION]) vPartsDim[i] = GetDimensions( tSashes[i][JWD_ELEMENT_DIMENSION])
end end
local vSashTypes, sHandleSide = GetSashTypes( tSashes, vOpeningTypes) local vSashTypes, sHandleSide = GetSashTypes( tSashes, vOpeningTypes)
local bDaylight = AreaTable[JWD_MEASURE_DAYLIGHT]
-- aggiungo il gruppo di ante -- 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 -- aggiungo le ante
for i = 1, #vAreas do for i = 1, #vAreas do
-- bottomrail -- bottomrail
@@ -318,14 +319,17 @@ local function ConvertTableToGeometry( AreaTable, nParentId)
-- FILL -- FILL
elseif AreaTable[JWD_AREA_TYPE] == 'FILL' then elseif AreaTable[JWD_AREA_TYPE] == 'FILL' then
local nFillType = EgtIf( AreaTable[JWD_FILL_TYPE] == 'GLASS', WIN_FILLTYPES.GLASS, WIN_FILLTYPES.WOOD) 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 -- SPLIT
elseif AreaTable[JWD_AREA_TYPE] == 'SPLIT' then elseif AreaTable[JWD_AREA_TYPE] == 'SPLIT' or AreaTable[JWD_AREA_TYPE] == 'INGLESINA' then
local vVertDimensions = {} local vVertDimensions = {}
local vVertMeasureType = {} 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] local vSplitVertDimensions = AreaTable[JWD_SPLIT_VERT_POS]
for i = 1, #vSplitVertDimensions do for i = 1, #vSplitVertDimensions do
vVertMeasureType[i] = GetMeasureType( vSplitVertDimensions[i][JWD_MEASURE_TYPE]) vVertMeasureType[i] = GetMeasureType( vSplitVertDimensions[i][JWD_MEASURE_TYPE])
@@ -333,31 +337,22 @@ local function ConvertTableToGeometry( AreaTable, nParentId)
end end
local vHorizDimensions = {} local vHorizDimensions = {}
local vHorizMeasureType = {} 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] local vSplitHorizDimensions = AreaTable[JWD_SPLIT_HORIZ_POS]
for i = 1, #vSplitHorizDimensions do for i = 1, #vSplitHorizDimensions do
vHorizMeasureType[i] = GetMeasureType( vSplitHorizDimensions[i][JWD_MEASURE_TYPE]) vHorizMeasureType[i] = GetMeasureType( vSplitHorizDimensions[i][JWD_MEASURE_TYPE])
vHorizDimensions[i] = vSplitHorizDimensions[i][JWD_DIMENSION] vHorizDimensions[i] = vSplitHorizDimensions[i][JWD_DIMENSION]
end end
local nMuntinFillSide = GetMuntinSide( AreaTable[JWD_MUNTIN_SIDE]) -- lato inglesine
local vSplitAreas local vSplitAreas
if AreaTable[JWD_SPLIT_TYPE] == 'GRID' then if AreaTable[JWD_SPLIT_TYPE] == 'GRID' then
local vElementDimension = {} vSplitAreas = WinCreate.AddGridSplits( nParentId, vVertMeasureType, vVertDimensions, vHorizMeasureType, vHorizDimensions, AreaTable[JWD_SPLIT_START_VERT],
if AreaTable[JWD_SPLIT_START_VERT] then vVertElementDimension, vHorizElementDimension, nMuntinFillSide, nAreaNbr)
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)
elseif AreaTable[JWD_SPLIT_TYPE] == 'VERTICAL' then 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 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 end
for i = 1, #vSplitAreas do for i = 1, #vSplitAreas do
ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][i], vSplitAreas[i]) ConvertTableToGeometry( AreaTable[JWD_AREA_LIST][i], vSplitAreas[i])
Designing/WinProject.lua
+37 -24
View File
@@ -163,14 +163,14 @@ end
_G.GetProfileThresholdsList = GetProfileThresholdsList _G.GetProfileThresholdsList = GetProfileThresholdsList
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
local function GetProfileData( nFrameGrp, nSashGrp) local function GetProfileData( vGrps)
local tData = {} local tData = {}
-- a) dimensioni -- a) dimensioni
for i = 1, 2 do for i = 1, #vGrps do
-- scorro tutti i profili e salvo le dimensioni -- scorro tutti i profili e salvo le dimensioni
local sName = EgtIf( i == 1, WIN_FRAME, WIN_SASH) local sName = EgtGetName( vGrps[i])
local vProfiles = EgtGetAllInGroup( EgtIf( i ==1, nFrameGrp, nSashGrp)) local vProfiles = EgtGetAllInGroup( vGrps[i])
for j = 1, #vProfiles do for j = 1, #vProfiles do
local sCurrName = sName .. '_' .. EgtGetName( vProfiles[j]) local sCurrName = sName .. '_' .. EgtGetName( vProfiles[j])
tData[sCurrName .. '_' .. WIN_DIM_STD] = EgtGetInfo( vProfiles[j], WIN_DIM_STD, 'd') tData[sCurrName .. '_' .. WIN_DIM_STD] = EgtGetInfo( vProfiles[j], WIN_DIM_STD, 'd')
@@ -181,7 +181,7 @@ local function GetProfileData( nFrameGrp, nSashGrp)
-- b) overlap -- b) overlap
-- tra ante e telaio -- tra ante e telaio
local vProfiles = EgtGetAllInGroup( nFrameGrp) local vProfiles = EgtGetAllInGroup( vGrps[1])
for i = 1, #vProfiles do for i = 1, #vProfiles do
local dTopOverlap = EgtGetInfo( vProfiles[i], WIN_SASH_TOP_OVERLAP, 'd') local dTopOverlap = EgtGetInfo( vProfiles[i], WIN_SASH_TOP_OVERLAP, 'd')
local dBottomOverlap = EgtGetInfo( vProfiles[i], WIN_SASH_BOTTOM_OVERLAP, 'd') local dBottomOverlap = EgtGetInfo( vProfiles[i], WIN_SASH_BOTTOM_OVERLAP, 'd')
@@ -194,25 +194,27 @@ local function GetProfileData( nFrameGrp, nSashGrp)
end end
-- tra ante battenti/riceventi -- tra ante battenti/riceventi
local nSashActive = EgtGetFirstNameInGroup( nSashGrp, WIN_SASH_ACTIVE) local nSashActive = EgtGetFirstNameInGroup( vGrps[2], WIN_SASH_ACTIVE)
if nSashActive then if nSashActive then
tData[WIN_SASH_ACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashActive, WIN_OVERLAP, 'd') tData[WIN_SASH_ACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashActive, WIN_OVERLAP, 'd')
tData[WIN_SASH_INACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashActive, WIN_OVERLAP, 'd')
end end
local nSashFrench = EgtGetFirstNameInGroup( nSashGrp, WIN_FRENCH_IN) local nSashFrench = EgtGetFirstNameInGroup( vGrps[2], WIN_FRENCH_IN)
if nSashFrench then if nSashFrench then
tData[WIN_FRENCH_IN .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashFrench, WIN_OVERLAP, 'd') tData[WIN_FRENCH_IN .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashFrench, WIN_OVERLAP, 'd')
tData[WIN_FRENCH_OUT .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashFrench, WIN_OVERLAP, 'd')
end end
local nSlideActive = EgtGetFirstNameInGroup( nSashGrp, WIN_SLIDE_ACTIVE) local nSlideActive = EgtGetFirstNameInGroup( vGrps[2], WIN_SLIDE_ACTIVE)
if nSlideActive then if nSlideActive then
tData[WIN_SLIDE_ACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSlideActive, WIN_OVERLAP, 'd') tData[WIN_SLIDE_ACTIVE .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSlideActive, WIN_OVERLAP, 'd')
end end
-- tra bottomrail -- tra bottomrail
local nFrameBottomRail = EgtGetFirstNameInGroup( nFrameGrp, WIN_RAIL_BOTTOM) local nFrameBottomRail = EgtGetFirstNameInGroup( vGrps[1], WIN_RAIL_BOTTOM)
if nFrameBottomRail then if nFrameBottomRail then
tData[WIN_FRAME .. '_'.. WIN_BOTTOMRAIL .. '_' .. WIN_OVERLAP] = EgtGetInfo( nFrameBottomRail, WIN_OVERLAP, 'd') tData[WIN_FRAME .. '_'.. WIN_BOTTOMRAIL .. '_' .. WIN_OVERLAP] = EgtGetInfo( nFrameBottomRail, WIN_OVERLAP, 'd')
end end
local nSashBottomRail = EgtGetFirstNameInGroup( nSashGrp, WIN_RAIL_BOTTOM) local nSashBottomRail = EgtGetFirstNameInGroup( vGrps[2], WIN_RAIL_BOTTOM)
if nSashBottomRail then if nSashBottomRail then
tData[WIN_SASH .. '_'.. WIN_BOTTOMRAIL .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashBottomRail, WIN_OVERLAP, 'd') tData[WIN_SASH .. '_'.. WIN_BOTTOMRAIL .. '_' .. WIN_OVERLAP] = EgtGetInfo( nSashBottomRail, WIN_OVERLAP, 'd')
end end
@@ -229,7 +231,8 @@ local function WinGetProfileData()
local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE) local nProfileGrp = EgtGetFirstNameInGroup( GDB_ID.ROOT, WIN_PROFILE)
local nFrameGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_FRAME) local nFrameGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_FRAME)
local nSashGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_SASH) local nSashGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_SASH)
tData = GetProfileData( nFrameGrp, nSashGrp) local nFillGrp = EgtGetFirstNameInGroup( nProfileGrp, WIN_FILL)
tData = GetProfileData( { nFrameGrp, nSashGrp, nFillGrp})
else else
-- importo temporaneamente il profilo -- importo temporaneamente il profilo
local nLastId = EgtGetLastInGroup( GDB_ID.ROOT) local nLastId = EgtGetLastInGroup( GDB_ID.ROOT)
@@ -240,7 +243,7 @@ local function WinGetProfileData()
table.insert( vGrps, nCurrId) table.insert( vGrps, nCurrId)
nCurrId = EgtGetNext( nCurrId) nCurrId = EgtGetNext( nCurrId)
end end
tData = GetProfileData( vGrps[1], vGrps[2]) tData = GetProfileData( vGrps)
EgtErase( vGrps) EgtErase( vGrps)
end end
WDG.PROFILEDATA = tData WDG.PROFILEDATA = tData
@@ -267,15 +270,17 @@ _G.WinCreate_AddSash = WinCreate_AddSash
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
local function WinCreate_AddSashGroup() local function WinCreate_AddSashGroup()
local MeasureTypeList = GetVariableList( 'MEASURETYPE')
local DimensionList = GetVariableList( 'DIMENSION') local DimensionList = GetVariableList( 'DIMENSION')
local JointList = GetVariableList( 'JOINT') local JointList = GetVariableList( 'JOINT')
local SashTypeList = GetVariableList( 'SASHTYPE') local SashTypeList = GetVariableList( 'SASHTYPE')
local OpeningTypeList = GetVariableList( 'OPENINGTYPE') local OpeningTypeList = GetVariableList( 'OPENINGTYPE')
local SashNbrList = GetVariableList( 'SASHNBR') 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) FillVariableList( 'AREAID', AreaList)
CleanVariableList( 'MEASURETYPE')
CleanVariableList( 'DIMENSION') CleanVariableList( 'DIMENSION')
CleanVariableList( 'JOINT') CleanVariableList( 'JOINT')
CleanVariableList( 'SASHTYPE') CleanVariableList( 'SASHTYPE')
@@ -310,23 +315,38 @@ _G.WinCreate_AddThreshold = WinCreate_AddThreshold
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
local function WinCreate_AddSplits() local function WinCreate_AddSplits()
local MeasureTypeList = GetVariableList( 'MEASURETYPE')
local PositionList = GetVariableList( 'POSITION') 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) FillVariableList( 'AREAID', AreaList)
CleanVariableList( 'MEASURETYPE')
CleanVariableList( 'POSITION') CleanVariableList( 'POSITION')
CleanVariableList( 'ELEMENTDIM')
end end
_G.WinCreate_AddSplits = WinCreate_AddSplits _G.WinCreate_AddSplits = WinCreate_AddSplits
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
local function WinCreate_AddGridSplits() local function WinCreate_AddGridSplits()
local MeasureTypeListVert = GetVariableList( 'MEASURETYPE_VERT')
local MeasureTypeListHoriz = GetVariableList( 'MEASURETYPE_HORIZ')
local PositionListVert = GetVariableList( 'POSITION_VERT') local PositionListVert = GetVariableList( 'POSITION_VERT')
local PositionListHoriz = GetVariableList( 'POSITION_HORIZ') 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) FillVariableList( 'AREAID', AreaList)
CleanVariableList( 'MEASURETYPE_VERT')
CleanVariableList( 'MEASURETYPE_HORIZ')
CleanVariableList( 'POSITION_VERT') CleanVariableList( 'POSITION_VERT')
CleanVariableList( 'POSITION_HORIZ') CleanVariableList( 'POSITION_HORIZ')
CleanVariableList( 'ELEMENTDIM_VERT')
CleanVariableList( 'ELEMENTDIM_HORIZ')
end end
_G.WinCreate_AddGridSplits = WinCreate_AddGridSplits _G.WinCreate_AddGridSplits = WinCreate_AddGridSplits
@@ -354,12 +374,6 @@ local function WinCalculate_CreatePartFromArea()
end end
_G.WinCalculate_CreatePartFromArea = WinCalculate_CreatePartFromArea _G.WinCalculate_CreatePartFromArea = WinCalculate_CreatePartFromArea
----------------------------------------------------------------------------------
local function WinCalculate_RecalcSolids()
WinCalculate.RecalcSolids( WDG.FRAMEID)
end
_G.WinCalculate_RecalcSolids = WinCalculate_RecalcSolids
---------------------------------------------------------------------------------- ----------------------------------------------------------------------------------
local function WinCalculate_AddHardware() 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) 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')}) table.insert( tabProfiles, { GroupId = vAreaNbrs[i], EntId = 1, Profiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES, 'vs')})
elseif nAreaType == WIN_AREATYPES.SPLIT then elseif nAreaType == WIN_AREATYPES.SPLIT then
local nSplitLayId = EgtGetFirstNameInGroup( vAreaIds[i], WIN_SPLIT) local nSplitType = EgtGetInfo( vAreaIds[i], WIN_SPLITTYPE, 'i')
local nSplitType = EgtGetInfo( nSplitLayId, WIN_SPLITTYPE, 'i')
-- se french split devo recuperare le ante che definisce -- se french split devo recuperare le ante che definisce
if nSplitType == WIN_SPLITTYPES.FRENCH then if nSplitType == WIN_SPLITTYPES.FRENCH then
local vSashes = EgtGetNameInGroup( vAreaIds[i], WIN_AREA .. '*') local vSashes = EgtGetNameInGroup( vAreaIds[i], WIN_AREA .. '*')
@@ -535,7 +548,7 @@ local function WinGetAreaProfiles()
vProfiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES .. tostring( nOrder), 'vs') vProfiles = EgtGetInfo( vAreaIds[i], WIN_AREA_PROFILES .. tostring( nOrder), 'vs')
end end
else 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 end
end end