//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : LUA_General.cpp       Data : 27.09.14        Versione : 1.5i5
// Contenuto : Funzioni generali per LUA.
//
//
//
// Modifiche : 27.09.14 DS Creazione modulo.
//
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "DllMain.h"
#include "EXE.h"
#include "LUA.h"
#include "GenTools.h"
#include "resource.h"
#include "AuxDialogBox.h"
#include "/EgtDev/Include/ExeExecutor.h"
#include "/EgtDev/Include/EGkLuaAux.h"
#include "/EgtDev/Include/EGkStringUtils3d.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EGnFileUtils.h"
#include "/EgtDev/Include/EGnFileCompare.h"
#include "/EgtDev/Include/EGnStringKeyVal.h"
#include "/EgtDev/Include/EGnEgtUUID.h"
#include "/EgtDev/Include/EgtPerfCounter.h"
#include "/EgtDev/Include/EgtIniFile.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include "/EgtDev/Include/EgtStringConverter.h"
#include <sstream>
#include <Windowsx.h>
#include <shlobj.h>

using namespace std ;

//----------------------------------------------------------------------------
static PerformanceCounter s_Counter ;

//-------------------------------------------------------------------------------
static int
MyPrint( lua_State* L)
{
   string sOut ;
   int n = lua_gettop( L) ;  /* number of arguments */
   lua_getglobal( L, "tostring") ;
   for ( int i = 1 ; i <= n ; ++ i) {
      const char* s ;
      lua_pushvalue( L, -1) ;  /* function to be called */
      lua_pushvalue( L, i) ;   /* value to print */
      lua_call( L, 1, 1) ;
      s = lua_tostring( L, -1) ;  /* get result */
      if ( s == nullptr)
         return luaL_error( L,
                            "'tostring' must return a string to 'print'") ;
      if ( i > 1)
         sOut += "\t" ;
      sOut += s ;
      lua_pop( L, 1) ;  /* pop result */
   }
   if ( ! sOut.empty())
      LOG_INFO( GetLogger(), sOut.c_str())

   return 0 ; 
}

//-------------------------------------------------------------------------------
static int
LuaEvalNumExpr( lua_State* L)
{
  // un solo parametro stringa : sExpr
   string sExpr ;
   LuaCheckParam( L, 1, sExpr)
   LuaClearStack( L) ;
  // valuto l'espressione
   double dVal ;
   bool bOk = ExeLuaEvalNumExpr( sExpr, &dVal) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, dVal) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaPause( lua_State* L)
{
  // 1 o 2 parametri : numero di millisecondi [, bForced]
   int nTime ;
   LuaCheckParam( L, 1, nTime)
   bool bForced = false ;
   LuaGetParam( L, 2, bForced) ;
   LuaClearStack( L) ;
  // se forzata o abilitata UI, controllo la durata della pausa e la eseguo
   if ( bForced  ||  ExeGetEnableUI()) {
      const int MIN_TIME = 0 ;
      const int MAX_TIME = 10000 ;
      if ( nTime < MIN_TIME)
         nTime = MIN_TIME ;
      else if ( nTime > MAX_TIME)
         nTime = MAX_TIME ;
      Sleep( nTime) ;
   }
  // restituisco il risultato
   LuaSetParam( L, true) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetKeyPressed( lua_State* L)
{
  // 1 parametro : nKeyCode
   int nKeyCode ;
   LuaCheckParam( L, 1, nKeyCode)
   LuaClearStack( L) ;
  // se abilitata UI, controllo se il tasto indicato è premuto
   bool bPressed = false ;
   if ( ExeGetEnableUI()) {
      bPressed = (( GetAsyncKeyState( nKeyCode) & 0x8000) != 0) ;
   }
  // restituisco il risultato
   LuaSetParam( L, bPressed) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaStartCounter( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // avvio il contatore
   s_Counter.Start() ;
   return 0 ;
}

//-------------------------------------------------------------------------------
static int
LuaStopCounter( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // fermo il contatore
   double dTime = s_Counter.Stop() ;
  // restituisco il risultato
   LuaSetParam( L, dTime) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaNumToString( lua_State* L)
{
  // 1 o 2 parametri : dVal [, nDec]
   double dVal ;
   LuaCheckParam( L, 1, dVal)
   int nDec = 3 ;
   LuaGetParam( L, 2, nDec) ;
   LuaClearStack( L) ;
  // costruisco la stringa
   string sVal = ToString( dVal, nDec) ;
  // ritorno il risultato
   LuaSetParam( L, sVal) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSplitString( lua_State* L)
{
  // 1 o 2 parametri : sVal [, sSep]
   string sVal ;
   string sSep = "," ;
   bool bFound = LuaGetParam( L, 1, sVal) ;
   LuaGetParam( L, 2, sSep) ;
   LuaClearStack( L) ;
  // se ricevuta stringa, la divido in parti separate da sSep
   if ( bFound) {
     // eseguo separazione (se tra i separatori c'è spazio ora tokenize collassa eventuali spazi consecutivi in uno solo)
      STRVECTOR vsVal ;
      Tokenize( sVal, sSep, vsVal) ;
     // ritorno il risultato
      LuaSetParam( L, vsVal) ;
   }
  // altrimenti restituisco nil
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSplitStringPlus( lua_State* L)
{
  // 2 parametri : sVal, sHea
   string sVal ;
   string sHea ;
   bool bOk = LuaGetParam( L, 1, sVal)  &&
              LuaGetParam( L, 2, sHea) ;
   LuaClearStack( L) ;
  // se ricevute stringhe, divido la prima in parti con intestazioni della seconda (che conservo)
   if ( bOk) {
      STRVECTOR vsVal ;
      TokenizePlus( sVal, sHea, vsVal) ;
     // ritorno il risultato
      LuaSetParam( L, vsVal) ;
   }
  // altrimenti restituisco nil
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaReplaceString( lua_State* L)
{
  // 3 parametri : sVal, sOld, sNew
   string sVal ;
   LuaCheckParam( L, 1, sVal)
   string sOld ;
   LuaCheckParam( L, 2, sOld)
   string sNew ;
   LuaCheckParam( L, 3, sNew)
   LuaClearStack( L) ;
  // eseguo sostituzione nella stringa della sequenza indicata dal secondo parametro con quella del terzo
   int nRes = ReplaceString( sVal, sOld, sNew) ;
  // restituisco il risultato
   LuaSetParam( L, sVal) ;
   LuaSetParam( L, nRes) ;
   return 2 ;
}
//-------------------------------------------------------------------------------
static int
LuaSetVal( lua_State* L)
{
  // 2 parametri : Key, bVal|nVal|dVal|sVal|vtVal|ptVal|b3Val|frVal
   string sKey ;
   LuaCheckParam( L, 1, sKey)
   bool bOk = false ;
   string sNotes = "" ;
   switch ( lua_type( L, 2)) {
   case LUA_TBOOLEAN :
      {  bool bVal ;
         LuaGetParam( L, 2, bVal) ;
         LuaClearStack( L) ;
         bOk = SetVal( sKey, bVal, sNotes) ;
      } break ;
   case LUA_TNUMBER :
      {  double dVal ;
         LuaGetParam( L, 2, dVal) ;
         LuaClearStack( L) ;
         bOk = SetVal( sKey, dVal, sNotes) ;
      } break ;
   case LUA_TSTRING :
      {  string sVal ;
         LuaGetParam( L, 2, sVal) ;
         LuaClearStack( L) ;
         bOk = SetVal( sKey, (const string&) sVal, sNotes) ;
      } break ;
   case LUA_TTABLE :
      {  Frame3d frVal ;
         BBox3d b3Val ;
         Vector3d vtVal ;     // va bene anche per Point3d
         INTVECTOR vnVal ;
         DBLVECTOR vdVal ;
         STRVECTOR vsVal ;
         if ( LuaGetParam( L, 2, frVal)) {
            LuaClearStack( L) ;
            bOk = SetVal( sKey, frVal, sNotes) ;
         }
         else if ( LuaGetParam( L, 2, b3Val)) {
            LuaClearStack( L) ;
            bOk = SetVal( sKey, b3Val, sNotes) ;
         }
         else if ( LuaGetParam( L, 2, vtVal)) {
            LuaClearStack( L) ;
            bOk = SetVal( sKey, vtVal, sNotes) ;
         }
         else if ( LuaGetParam( L, 2, vnVal)) {
            LuaClearStack( L) ;
            bOk = SetVal( sKey, vnVal, sNotes) ;
         }
         else if ( LuaGetParam( L, 2, vdVal)) {
            LuaClearStack( L) ;
            bOk = SetVal( sKey, vdVal, sNotes) ;
         }
         else if ( LuaGetParam( L, 2, vsVal)) {
            LuaClearStack( L) ;
            bOk = SetVal( sKey, vsVal, sNotes) ;
         }
      } break ;
   }
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, sNotes) ;
   else
      LuaSetParam(L, "") ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetVal( lua_State* L)
{
  // 2 o 3 parametri : String, Key, sType
   string sVal ;
   LuaCheckParam( L, 1, sVal)
   string sKey ;
   LuaCheckParam( L, 2, sKey)
   string sType = "s" ;
   LuaGetParam( L, 3, sType) ;
   LuaClearStack( L) ;
  // recupero l'info
   if ( sType == "b"  ||  sType == "B") {
      bool bVal ;
      if ( GetVal( sVal, sKey, bVal))
         LuaSetParam( L, bVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( sType == "i"  ||  sType == "I") {
      int nVal ;
      if ( GetVal( sVal, sKey, nVal))
         LuaSetParam( L, nVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( sType == "d"  ||  sType == "D") {
      double dVal ;
      if ( GetVal( sVal, sKey, dVal))
         LuaSetParam( L, dVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( sType == "v"  ||  sType == "V") {
      Vector3d vtVal ;
      if ( GetVal( sVal, sKey, vtVal))
         LuaSetParam( L, vtVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( sType == "p"  ||  sType == "P") {
      Point3d ptVal ;
      if ( GetVal( sVal, sKey, ptVal))
         LuaSetParam( L, ptVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( sType == "x"  ||  sType == "X") {
      BBox3d b3Val ;
      if ( GetVal( sVal, sKey, b3Val))
         LuaSetParam( L, b3Val) ;
      else
         LuaSetParam( L) ;
   }
   else if ( sType == "f"  ||  sType == "F") {
      Frame3d frVal ;
      if ( GetVal( sVal, sKey, frVal))
         LuaSetParam( L, frVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( sType == "vi"  ||  sType == "vI") {
      INTVECTOR vnVal ;
      if ( GetVal( sVal, sKey, vnVal))
         LuaSetParam( L, vnVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( sType == "vd"  ||  sType == "vD") {
      DBLVECTOR vdVal ;
      if ( GetVal( sVal, sKey, vdVal))
         LuaSetParam( L, vdVal) ;
      else
         LuaSetParam( L) ;
   }
   else if ( sType == "vs"  ||  sType == "vS") {
      STRVECTOR vsVal ;
      if ( GetVal( sVal, sKey, vsVal))
         LuaSetParam( L, vsVal) ;
      else
         LuaSetParam( L) ;
   }
   else {     //  "s"    "S"
      string sInfo ;
      if ( GetVal( sVal, sKey, sInfo))
         LuaSetParam( L, sInfo) ;
      else
         LuaSetParam( L) ;
   }
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetUUID( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero UUID e lo trasformo in stringa
   EgtUUID uuId ;
   bool bOk = CreateEgtUUID( uuId) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, ToString( uuId)) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaExecTsc( lua_State* L)
{
  // 1 parametro : file
   string sFile ;
   LuaCheckParam( L, 1, sFile)
   LuaClearStack( L) ;
  // eseguo lo script TSC
   bool bOk = ExeTscExecFile( sFile) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaExecTscLine( lua_State* L)
{
  // 1 parametro : linea
   string sLine ;
   LuaCheckParam( L, 1, sLine)
   LuaClearStack( L) ;
  // eseguo la linea TSC
   bool bOk = ExeTscExecLine( sLine) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetTscVar( lua_State* L)
{
  // 2 parametri : nome, valore
   string sName ;
   LuaCheckParam( L, 1, sName)
   int nVal ;
   LuaCheckParam( L, 2, nVal)
   LuaClearStack( L) ;
  // assegno il valore alla variabile Tsc
   bool bOk = ExeTscSetVariable( sName, nVal) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetTscVar( lua_State* L)
{
  // 1 parametro : nome
   string sName ;
   LuaCheckParam( L, 1, sName)
   LuaClearStack( L) ;
  // recupero il valore della variabile Tsc
   int nVal ;
   bool bOk = ExeTscGetVariable( sName, nVal) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, nVal) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetDebugLevel( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // restituisco il livello di debug
   int nDebugLev = ExeGetDebugLevel() ;
   LuaSetParam( L, nDebugLev) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetUserLevel( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // restituisco il livello utente
   int nUserLev = ExeGetUserLevel() ;
   LuaSetParam( L, nUserLev) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOutLog( lua_State* L)
{
  // 1 o 2 parametri : stringa da emettere [, DebugLevel = 0]
   string sOut ;
   LuaCheckParam( L, 1, sOut)
   int nDbgLev = 0 ;
   LuaGetParam( L, 2, nDbgLev) ;
   LuaClearStack( L) ;
  // accodo il messaggio nel file di log
   ExeOutLog( sOut, nDbgLev) ;
  // non c'è risultato
   return 0 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetEnableUI( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // accodo il messaggio nel file di log
   bool bOk = ExeGetEnableUI() ;
  // restituisco lo stato di abilitazione dell'interfaccia utente
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOutBox( lua_State* L)
{
  // 2, 3 o 4 parametri : sOut, sTitle [, sIcon] [, sButtons]
   string sOut ;
   LuaCheckParam( L, 1, sOut)
   string sTitle ;
   LuaCheckParam( L, 2, sTitle)
   string sIcon ;
   LuaGetParam( L, 3, sIcon) ;
   int nIcon = 0 ;
   ToUpper( sIcon) ;
   if ( sIcon == "ERROR")
      nIcon = MB_ICONERROR ;
   else if ( sIcon == "WARNING")
      nIcon = MB_ICONWARNING ;
   else if ( sIcon == "INFO")
      nIcon = MB_ICONINFORMATION ;
   else if ( sIcon == "QUESTION")
      nIcon = MB_ICONQUESTION ;
   string sButtons ;
   LuaGetParam( L, 4, sButtons) ;
   int nButtons = MB_OKCANCEL ;
   ToUpper( sButtons) ;
   if ( sButtons == "OK")
      nButtons = MB_OK ;
   else if ( sButtons == "OKCANCEL")
      nButtons = MB_OKCANCEL ;
   else if ( sButtons == "ABORTRETRYIGNORE")
      nButtons = MB_ABORTRETRYIGNORE ;
   else if ( sButtons == "YESNOCANCEL")
      nButtons = MB_YESNOCANCEL ;
   else if ( sButtons == "YESNO")
      nButtons = MB_YESNO ;
   else if ( sButtons == "RETRYCANCEL")
      nButtons = MB_RETRYCANCEL ;
   else if ( sButtons == "CANCELTRYCONTINUE")
      nButtons = MB_CANCELTRYCONTINUE ;
   LuaClearStack( L) ;
  // emetto finestra di dialogo (solo se ablitata UI)
   int nRes = ExeMessageBox( sOut, sTitle, nButtons | nIcon) ;
  // risultato
   if ( nRes == IDOK  ||  nRes == IDRETRY  ||  nRes == IDYES  ||  nRes == IDTRYAGAIN)
      LuaSetParam( L, true) ;
   else if ( nRes ==  IDNO  ||  nRes == IDCONTINUE  ||  nRes == IDIGNORE)
      LuaSetParam( L, false) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaProcessEvents( lua_State* L)
{
  // 2 parametri : nProg, nPause
   int nProg ;
   LuaCheckParam( L, 1, nProg)
   int nPause ;
   LuaCheckParam( L, 2, nPause)
   LuaClearStack( L) ;
  // lancio aggiornamento interfaccia (viene fatto solo se abilitata UI)
   int nRes = ExeProcessEvents( nProg, nPause) ;
  // restituisco il risultato
   LuaSetParam( L, nRes) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaOutText( lua_State* L)
{
  // 1 parametro : sText
   string sText ;
   LuaCheckParam( L, 1, sText)
   LuaClearStack( L) ;
  // lancio emissione testo (viene fatto solo se abilitata UI)
   bool bOk = ExeOutText( sText) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaFileDialog( lua_State* L)
{
  // 3 parametri : bOpenVsSave, sFile, sFilter
   bool bOpenVsSave ;
   LuaCheckParam( L, 1, bOpenVsSave)
   string sFile ;
   LuaCheckParam( L, 2, sFile)
   string sFilter ;
   LuaCheckParam( L, 3, sFilter)
   LuaClearStack( L) ;
  // se abilitata UI, emetto la finestra di dialogo
   if ( ExeGetEnableUI()) {
     // Converto i parametri nel formato wide
      AtoWEX<MAX_PATH> wsFileName( sFile.c_str()) ;
      AtoW wsFilter( sFilter.c_str()) ;
     // Converto L'/' in L'\\' nel nome file proposto
      for ( wchar_t* pC = wsFileName.m_psz ; *pC != L'\0' ; ++ pC) {
         if ( *pC == L'/')
            *pC = L'\\' ;
      }
     // Cambio L'|' in L'\0' nel filtro
      for ( wchar_t* pC = wsFilter.m_psz ; *pC != L'\0' ; ++ pC) {
         if ( *pC == L'|')
            *pC = L'\0' ;
      }
     // Riempio la struttura dati per il dialogo
      OPENFILENAME ofn ;
      ZeroMemory( &ofn, sizeof( ofn)) ;
      ofn.lStructSize  = sizeof( ofn) ;
      ofn.hwndOwner    = ExeGetMainWindowHandle() ;
      ofn.lpstrFilter  = LPWSTR( wsFilter) ;
      ofn.lpstrFile    = LPWSTR( wsFileName) ;
      ofn.nMaxFile     = MAX_PATH ;
      ofn.Flags        = OFN_DONTADDTORECENT | OFN_PATHMUSTEXIST ;
     // Visualizzo il dialogo 
      if ( bOpenVsSave) {
         ofn.Flags |= OFN_FILEMUSTEXIST | OFN_HIDEREADONLY ;
         if ( GetOpenFileName( &ofn) != FALSE)
            LuaSetParam( L, wstrztoA( wsFileName)) ;
         else
            LuaSetParam( L) ;
      }
      else {
         ofn.Flags |= OFN_OVERWRITEPROMPT ;
         if ( GetSaveFileName( &ofn) != FALSE)
            LuaSetParam( L, wstrztoA( wsFileName)) ;
         else
            LuaSetParam( L) ;
      }
   }
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaExistsFile( lua_State* L)
{
  // 1 parametro : sFile
   string sFile ;
   LuaCheckParam( L, 1, sFile)
   LuaClearStack( L) ;
  // verifico esistenza file
   bool bOk = ExistsFile( sFile) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaCopyFile( lua_State* L)
{
  // 2 parametri : sFile, sNewFile
   string sFile ;
   LuaCheckParam( L, 1, sFile)
   string sNewFile ;
   LuaCheckParam( L, 2, sNewFile)
   LuaClearStack( L) ;
  // copio il file
   bool bOk = CopyFileEgt( sFile, sNewFile) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaRenameFile( lua_State* L)
{
  // 2 parametri : sFile, sNewFile
   string sFile ;
   LuaCheckParam( L, 1, sFile)
   string sNewFile ;
   LuaCheckParam( L, 2, sNewFile)
   LuaClearStack( L) ;
  // rinomino il file
   bool bOk = RenameFile( sFile, sNewFile) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaEraseFile( lua_State* L)
{
  // 1 parametro : file
   string sFile ;
   LuaCheckParam( L, 1, sFile)
   LuaClearStack( L) ;
  // cancello il file
   bool bOk = EraseFile( sFile) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaFindAllFiles( lua_State* L)
{
  // 1 parametro : specifiche del file
   string sFileSpec ;
   LuaCheckParam( L, 1, sFileSpec)
   LuaClearStack( L) ;
  // recupero tutti i file che rispondono alle specifiche
   STRVECTOR vsFiles ;
   bool bOk = FindAllFiles( sFileSpec, vsFiles) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, vsFiles) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaCompareFilesLastWriteTime( lua_State* L)
{
  // 2 parametri : file1, file2
   string sFile1 ;
   LuaCheckParam( L, 1, sFile1)
   string sFile2 ;
   LuaCheckParam( L, 2, sFile2)
   LuaClearStack( L) ;
  // confronto la data di ultima scrittura dei due file
   int nRes ;
   bool bOk = CompareFilesLastWriteTime( sFile1, sFile2, nRes) ;
  // restituisco il risultato
   if ( bOk)
      LuaSetParam( L, nRes) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
int
CALLBACK DirectoryBoxProc( HWND hwndDlg, UINT uMsg, LPARAM lParam, LPARAM lpData) 
{
   if ( uMsg == BFFM_INITIALIZED)
      SendMessage( hwndDlg, BFFM_SETSELECTION, TRUE, lpData) ;
   return 0 ;
}

//-------------------------------------------------------------------------------
static int
LuaDirectoryDialog( lua_State* L)
{
  // 2 parametri : sText, sDir
   string sText ;
   LuaCheckParam( L, 1, sText)
   string sDir ;
   LuaCheckParam( L, 2, sDir)
   LuaClearStack( L) ;
  // se abilitata UI, emetto la finestra di dialogo
   if ( ExeGetEnableUI()) {
     // Converto i parametri nel formato wide
      AtoWEX<MAX_PATH> wsText( sText.c_str()) ;
      AtoWEX<MAX_PATH> wsDirName( sDir.c_str()) ;
     // Converto L'/' in L'\\' nel nome directory proposto
      for ( wchar_t* pC = wsDirName.m_psz ; *pC != L'\0' ; ++ pC) {
         if ( *pC == L'/')
            *pC = L'\\' ;
      }
     // Riempio la struttura dati per il dialogo
      BROWSEINFO bi = { 0} ;
      bi.hwndOwner = ExeGetMainWindowHandle() ;
      bi.lpszTitle = LPWSTR( wsText) ;
      bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_USENEWUI ;
      bi.lpfn = DirectoryBoxProc ;
      bi.lParam = (LPARAM) LPWSTR( wsDirName) ;
     // Visualizzo il dialogo
      LPITEMIDLIST pIdl = SHBrowseForFolder( &bi) ;
      if ( pIdl != NULL) {
        // recupero la path della directory
         WCHAR wPath[MAX_PATH] ;
         if ( SHGetPathFromIDList( pIdl, wPath) != FALSE)
            LuaSetParam( L, wstrztoA( wPath)) ;
         else
            LuaSetParam( L) ;
        // free memory used
         IMalloc* pImalloc = NULL ;
         if ( SUCCEEDED( SHGetMalloc( &pImalloc))) {
            pImalloc->Free( pIdl) ;
            pImalloc->Release() ;
         }

      }
      else
         LuaSetParam( L) ;
   }
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaExistsDirectory( lua_State* L)
{
  // 1 parametro : sDir
   string sDir ;
   LuaCheckParam( L, 1, sDir)
   LuaClearStack( L) ;
  // verifico esistenza direttorio
   bool bOk = ExistsDirectory( sDir) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaCreateDirectory( lua_State* L)
{
  // 1 parametro : sDir
   string sDir ;
   LuaCheckParam( L, 1, sDir)
   LuaClearStack( L) ;
  // creo direttorio
   bool bOk = CreateDirectoryEgt( sDir) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaEmptyDirectory( lua_State* L)
{
  // 1 parametro : sDir
   string sDir ;
   LuaCheckParam( L, 1, sDir)
   LuaClearStack( L) ;
  // svuoto il direttorio
   bool bOk = EmptyDirectory( sDir) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaEraseDirectory( lua_State* L)
{
  // 1 parametro : sDir
   string sDir ;
   LuaCheckParam( L, 1, sDir)
   LuaClearStack( L) ;
  // cancello direttorio (deve essere vuoto)
   bool bOk = EraseDirectory( sDir) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaEraseNonEmptyDirectory( lua_State* L)
{
  // 1 parametro : sDir
   string sDir ;
   LuaCheckParam( L, 1, sDir)
   LuaClearStack( L) ;
  // cancello direttorio (deve essere vuoto)
   bool bOk = EraseNonEmptyDirectory( sDir) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaTextFileCompare( lua_State* L)
{
  // 4 parametri : file1, file2, inizio commento, file diff
   string sFile1 ;
   LuaCheckParam( L, 1, sFile1)
   string sFile2 ;
   LuaCheckParam( L, 2, sFile2)
   string sRemStart ;
   LuaCheckParam( L, 3, sRemStart)
   string sFileDiff ;
   LuaCheckParam( L, 4, sFileDiff)
   LuaClearStack( L) ;
  // eseguo il confronto
   int nDiff ;
   bool bOk = TextFileCompare( sFile1, sFile2, sRemStart, sFileDiff, nDiff) ;
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, nDiff) ;
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaBinaryFileCompare( lua_State* L)
{
  // 3 parametri : file1, file2, file diff
   string sFile1 ;
   LuaCheckParam( L, 1, sFile1)
   string sFile2 ;
   LuaCheckParam( L, 2, sFile2)
   string sFileDiff ;
   LuaCheckParam( L, 3, sFileDiff)
   LuaClearStack( L) ;
  // eseguo il confronto
   int nDiff ;
   bool bOk = BinaryFileCompare( sFile1, sFile2, sFileDiff, nDiff) ;
   LuaSetParam( L, bOk) ;
   LuaSetParam( L, nDiff) ;
   return 2 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetStringFromIni( lua_State* L)
{
  // 4 parametri : sSec, sKey, sDef, sIniFile
   string sSec ;
   LuaCheckParam( L, 1, sSec)
   string sKey ;
   LuaCheckParam( L, 2, sKey)
   string sDef ;
   LuaCheckParam( L, 3, sDef)
   string sIniFile ;
   LuaCheckParam( L, 4, sIniFile)
   LuaClearStack( L) ;
  // leggo da file INI
   string sVal = GetPrivateProfileStringUtf8( sSec.c_str(), sKey.c_str(), sDef.c_str(), sIniFile.c_str()) ;
   LuaSetParam( L, sVal) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaWriteStringToIni( lua_State* L)
{
  // 4 parametri : sSec, sKey, sVal, sIniFile
   string sSec ;
   LuaCheckParam( L, 1, sSec)
   string sKey ;
   LuaCheckParam( L, 2, sKey)
   string sVal ;
   LuaCheckParam( L, 3, sVal)
   string sIniFile ;
   LuaCheckParam( L, 4, sIniFile)
   LuaClearStack( L) ;
  // scrivo su file INI
   bool bOk = WritePrivateProfileStringUtf8( sSec.c_str(), sKey.c_str(), sVal.c_str(), sIniFile.c_str()) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetIniFile( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero la path del file Ini dell'eseguibile
   string sIniFile = ExeGetIniFile() ;
  // restituisco il risultato
   if ( ! sIniFile.empty())
      LuaSetParam( L, sIniFile) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetTempDir( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero la path del direttorio temporaneo dell'eseguibile
   string sTempDir ;
   ExeGetTempDir( sTempDir) ;
  // restituisco il risultato
   if ( ! sTempDir.empty())
      LuaSetParam( L, sTempDir) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetExeVersion( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // costruisco la stringa con le versioni
   string sVer ;
   if ( ! ExeGetExecutableVersion( sVer))
      sVer = "ExeVersion error" ;
  // restituisco il risultato
   LuaSetParam( L, sVer) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetVersion( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // costruisco la stringa con le versioni
   string sVer ;
   if ( ! ExeGetVersionInfo( sVer, "\n"))
      sVer = "VersionInfo error" ;
  // restituisco il risultato
   LuaSetParam( L, sVer) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaIs64bit( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // restituisco il risultato
#if defined( _WIN64)
   bool bRes = true ;
#elif defined( _WIN32)
   bool bRes = false ;
#endif    
   LuaSetParam( L, bRes) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetLanguage( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupero il nome della lingua corrente
   string sLang = ExeGetLanguage() ;
   LuaSetParam( L, sLang) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetMsg( lua_State* L)
{
  // 1 parametro : nMsg
   int nMsg ;
   LuaCheckParam( L, 1, nMsg)
   LuaClearStack( L) ;
  // recupero il nome della lingua corrente
   string sMsg = ExeGetMsg( nMsg) ;
   LuaSetParam( L, sMsg) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaVerifyKeyOption( lua_State* L)
{
  // 1 parametro : nOptInd
   int nOptInd ;
   LuaCheckParam( L, 1, nOptInd)
   LuaClearStack( L) ;
  // verifico l'abilitazione dell'opzione (da chiave + licenza)
   bool bOk = ExeVerifyKeyOption( nOptInd) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaSetDefaultFont( lua_State* L)
{
  // 1 parametro : sDefaultFont
   string sDefaultFont ;
   LuaCheckParam( L, 1, sDefaultFont)
   LuaClearStack( L) ;
  // imposta il font di default
   bool bOk = ExeSetFont( "", sDefaultFont) ;
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaGetDefaultFont( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // recupera il font di cefault
   string sDefaultFont ;
   bool bOk = ExeGetDefaultFont( sDefaultFont) ;
   if ( bOk)
      LuaSetParam( L, sDefaultFont) ;
   else
      LuaSetParam( L) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaWinExec( lua_State* L)
{
  // un solo parametro : CmdLine
   string sCmdLine ;
   LuaCheckParam( L, 1, sCmdLine)
   LuaClearStack( L) ;
  // mando in esecuzione la linea di comando
   STARTUPINFO si ;
   PROCESS_INFORMATION pi ;
   ZeroMemory( &si, sizeof( si)) ;
   si.cb = sizeof( si) ;
   ZeroMemory( &pi, sizeof( pi)) ;
   bool bOk = ( CreateProcess( NULL, stringtoW( sCmdLine), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi) != FALSE) ;
   CloseHandle( pi.hProcess) ;
   CloseHandle( pi.hThread) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaCloseExe( lua_State* L)
{
  // 1 parametro opzionale : [nExitCode]
   int nExitCode = 0 ;
   LuaGetParam( L, 1, nExitCode) ;
   LuaClearStack( L) ;
  // eseguo chiusura forzata
   if ( ExeOnTerminateProcess( nExitCode))
      TerminateProcess( GetCurrentProcess(), abs( nExitCode)) ;
  // restituisco il risultato (se arrivo qui vuol dire che non è consnetito terminare l'esecuzione)
   LuaSetParam( L, false) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaCreateMutex( lua_State* L)
{
  // un solo parametro : sMutexName
   string sMutexName ;
   LuaCheckParam( L, 1, sMutexName)
   LuaClearStack( L) ;
  // verifico esistenza Mutex con Nome (altrimenti lo creo per bloccare gli altri)
   bool bOk = ExeCreateMutex( sMutexName) ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
static int
LuaReleaseMutex( lua_State* L)
{
  // nessun parametro
   LuaClearStack( L) ;
  // rilascio l'eventuale Mutex con Nome attivo 
   bool bOk = ExeReleaseMutex() ;
  // restituisco il risultato
   LuaSetParam( L, bOk) ;
   return 1 ;
}

//-------------------------------------------------------------------------------
// =================================== DIALOG ===================================
// Variabili Globali
const int OFFS_CTRLS = 40 ;
enum TYPE_CTRLS { CTRL_NONE = 0, CTRL_CHECK = 1, CTRL_COMBO = 2, CTRL_EDIT = 3, CTRL_COLOR = 4, CTRL_BUTTON = 5} ;
static COLORREF s_CustomColors[16] = {12632256} ;                 // 16 colori GRAY
static bool s_bCustomColorsInit = false ;                         // flag di inizializzazione colori
const char* SEC_SCENE = "Scene" ;
const char* KEY_CUSTOMCOLORS = "CustomColors" ;

// Dialogo Modeless
const int MAX_CTRLS = IDC_TEXT8 - IDC_TEXT1 + 1 ;
static int s_nCtrls = 0 ;
static string s_sCaption ;
static string s_sText[MAX_CTRLS] ;
static string s_sEdit[MAX_CTRLS] ;
static int    s_nType[MAX_CTRLS] ;
struct DialogContext {
   bool       bDone = false ;         // flag per chiusura dialogo (X/Ok/Cancel)
   bool       bCancelled = false ;    // true se X/Cancel
   bool       bSelecting = false ;    // true quando un BS + in modalità selezione
   int        nLastBS = -1 ;          // indice dell'ultimo BS premuto
   STRVECTOR  vsResult ;              // valori finali da ritornare a Lua
} ;
static string s_sIdSel_ML ;
static bool s_bSelectionMode = false ;       // se true allora diventa dialogo "Modeless"
static int s_nActiveRow = - 1 ;              // indice della riga di "BS:" attiva

//-------------------------------------------------------------------------------
// OnClosingDialog
//
// Scopo:
//   Gestisce la chiusura del dialogo modeless in modo centralizzato e sicuro.
//   Questa funzione viene chiamata quando l’utente chiude il dialogo tramite:
//     - OK
//     - Cancel
//     - pulsante X
//     - WM_CLOSE
//
// Comportamento:
//   - Riabilita la finestra principale (Main Window), che era stata disabilitata durante il funzionamento
//     modale del dialogo.
//
//   - Distrugge la finestra del dialogo.
//
//   - Riporta il focus alla finestra principale, garantendo continuità nell’interazione dell’utente.
//
//   - Deseleziona tutti gli oggetti nella scena e aggiorna la vista, in modo che nessuna selezione residua
//     rimanga attiva dopo la chiusura.
//-------------------------------------------------------------------------------
static void
OnClosingDialog( HWND hwndDlg) {
  // reset stato globale
   s_bSelectionMode = false ;
   s_nActiveRow = -1 ;
   nDlgModelessItem = -1 ;
  // il controllo passa al Main
   HWND hMain = GetParent( hwndDlg) ;
   EnableWindow( hMain, TRUE) ;
   DestroyWindow( hwndDlg) ;
   phDlgModeless = nullptr ;
   SetFocus( hMain) ;
  // deseleziono tutto
   ExeDeselectAll() ;
   ExeDraw() ;
}

//-------------------------------------------------------------------------------
// StartSelectionMode
//
// Scopo:
//   Attiva la modalità di selezione (modeless) del dialogo. Questa modalità permette all’utente di interagire 
//   con la scena mentre il dialogo rimane aperto e attivo.
//
// Parametri:
//   hDlg       → handle del dialogo
//   nEditId    → ID dell’edit associato al pulsante BS premuto
//   nActiveRow → indice della riga BS attiva (0..MAX_CTRLS-1)
//-------------------------------------------------------------------------------
static void
StartSelectionMode( HWND hDlg, int nEditId, int nActiveRow)
{
  // il dialogo torna modeless rispetto alla scena
   HWND hMain = GetParent( hDlg) ;
   EnableWindow( hMain, TRUE) ;
  // resta comunque in primo piano
   SetWindowPos( hDlg, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE) ;

  // disabilito tutti gli edit associati ai BS tranne che quello attivo
   for ( int i = 0; i < s_nCtrls ; ++ i) {
      if (s_sEdit[i].find( "BS:") == 0) {
        int idEdit = IDC_EDIT1 + i ;
        EnableWindow( GetDlgItem( hDlg, idEdit), ( i == nActiveRow ? TRUE : FALSE)) ;
      }
   }

  // seleziono solo gli elementi presenti nell'edit corrispondente
   nDlgModelessItem = - 1 ;      // !<-- Temporaneo [***]
   ExeDeselectAll() ;            // !<-- NB. avendo messo nDlgModelessItem = -1 il testo non viene rimosso
   s_bSelectionMode = true ;
   s_nActiveRow = nActiveRow ;
   nDlgModelessItem = nEditId ;  // !<-- Aggiorno [***]
   AtoWEX<128> wsEdit( "") ;
   GetDlgItemText( hDlg, nEditId, LPWSTR( wsEdit), 128) ;
   string sIds = wstrztoA( wsEdit) ;
   STRVECTOR vsIds ;
   Tokenize( sIds, ",", vsIds) ;
   for ( const string& sId : vsIds) {
      int nId = GDB_ID_NULL ;
      if ( FromString( sId, nId)  &&  nId != GDB_ID_NULL)
         ExeSelectObj( nId) ;
   }
   ExeDraw() ;
}

//-------------------------------------------------------------------------------
// EndSelectionMode
//
// Scopo:
//   Termina la modalità di selezione e riporta il dialogo in stato modale.
//-------------------------------------------------------------------------------
static void
EndSelectionMode( HWND hDlg)
{
   s_bSelectionMode = false ;
   s_nActiveRow = -1 ;
   nDlgModelessItem = -1 ;

  // disabilito tutti gli edit associati ai BS
   for ( int i = 0; i < s_nCtrls ; ++ i) {
      if ( s_sEdit[i].find( "BS:") == 0) {
        int idEdit = IDC_EDIT1 + i ;
        EnableWindow( GetDlgItem( hDlg, idEdit), FALSE) ;
        SetDlgItemText( hDlg, IDC_BUTTON_SEL1 + i, stringtoW( string{ "-"})) ;
      }
   }

  // il dialogo torna modale
   HWND hMain = GetParent( hDlg) ;
   EnableWindow( hMain, FALSE) ;
   SetFocus( hDlg) ;
  // deseleziono tutto
   ExeDeselectAll() ; //!<-- NB. avendo messo nDlgModelessItem = -1 il testo non viene rimosso
   ExeDraw() ;
}

//-------------------------------------------------------------------------------
BOOL
CALLBACK DialogBoxModelessProc( HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
  // variabili static locali per mantenere lo stato tra chiamate per selezione colori
   static COLORREF selectedColor[MAX_CTRLS] = {0} ;      // BLACK
   static HBRUSH   hColorBrush[MAX_CTRLS] = {NULL} ;     // non definito

   switch ( message) {
      case WM_INITDIALOG :
         {
           // imposto il dialogo come modale
            HWND hMain = GetParent( hwndDlg) ;
            EnableWindow( hMain, FALSE) ;
            SetFocus( hwndDlg) ;

           // imposto il contesto della funzione per recuperalo in futuro (per la funzione di CallBack Lua)
            SetWindowLongPtr( hwndDlg, GWLP_USERDATA, (LONG_PTR)lParam) ;

           // colore di default
            COLORREF defaultColor = RGB( 255, 0, 0) ;
           // inizializzazione colori e brush
            for ( int i = 0 ; i < MAX_CTRLS ; ++ i) {
               selectedColor[i] = defaultColor ;
               if ( hColorBrush[i] != NULL)
                  DeleteObject( hColorBrush[i]) ;
               hColorBrush[i] = CreateSolidBrush( selectedColor[i]) ;
            }
           // dati del dialogo
            HWND hwndOwner = GetParent( hwndDlg) ;
            if ( hwndOwner == nullptr)
               hwndOwner = GetDesktopWindow() ;
            RECT rcOwner, rcDlg ;
            GetWindowRect( hwndOwner, &rcOwner) ;
            GetWindowRect( hwndDlg, &rcDlg) ;
           // determino la posizione dell'ultima riga di dati da visualizzare
            HWND hwndLR = GetDlgItem( hwndDlg, IDC_TEXT1 + Clamp( s_nCtrls, 1, MAX_CTRLS) - 1) ;
            RECT rcLR ;
            GetWindowRect( hwndLR, &rcLR) ;
            POINT ptLR{ rcLR.left, rcLR.top} ;
            ScreenToClient( hwndDlg, &ptLR) ;
           // centro e scalo il dialogo
            int nNewH = rcLR.top - rcOwner.top + 2 * OFFS_CTRLS ;  // non chiaro perchè va sottratto rcOwner.top ma funziona sempre
            SetWindowPos( hwndDlg, HWND_TOP,
                          ( rcOwner.left + rcOwner.right - ( rcDlg.right - rcDlg.left)) / 2,
                          ( rcOwner.top + rcOwner.bottom - nNewH) / 2,
                          ( rcDlg.right - rcDlg.left),
                          nNewH, 0) ;
           // riposiziono il bottone Ok
            HWND hwndOk = GetDlgItem( hwndDlg, IDOK) ;
            RECT rcOk ;
            GetWindowRect( hwndOk, &rcOk) ;
            POINT ptOk{ rcOk.left, rcOk.top} ;
            ScreenToClient( hwndDlg, &ptOk) ;
            SetWindowPos( hwndOk, hwndDlg, ptOk.x, ptLR.y + OFFS_CTRLS, 0, 0, SWP_NOSIZE | SWP_NOZORDER) ;
           // riposiziono il bottone Cancel
            HWND hwndCl = GetDlgItem( hwndDlg, IDCANCEL) ;
            RECT rcCl ;
            GetWindowRect( hwndCl, &rcCl) ;
            POINT ptCl{ rcCl.left, rcCl.top} ;
            ScreenToClient( hwndDlg, &ptCl) ;
            SetWindowPos( hwndCl, hwndDlg, ptCl.x, ptLR.y + OFFS_CTRLS, 0, 0, SWP_NOSIZE | SWP_NOZORDER) ;
           // stile finestra
            LONG style = GetWindowLong( hwndDlg, GWL_STYLE) ;
            style |= WS_SYSMENU ;
            SetWindowLong( hwndDlg, GWL_STYLE, style) ;
         }

        // assegno titolo del dialogo
         SetWindowText( hwndDlg, stringtoW( s_sCaption)) ;

        // assegno testi e valori di default e nascondo linee dei controlli non usati
         for ( int i = 0 ; i < MAX_CTRLS ; ++ i) {
            if ( i < s_nCtrls) {

              // imposto il testo nella riga corrente
               SetDlgItemText( hwndDlg, IDC_TEXT1 + i, stringtoW( s_sText[i])) ;

              // --- se CheckBox
               if ( s_sEdit[i].find( "CK:") == 0) {
                  bool bChecked = false ;
                  FromString( s_sEdit[i].substr( 3), bChecked) ;
                  CheckDlgButton( hwndDlg, IDC_CHECK1 + i, ( bChecked ? BST_CHECKED : BST_UNCHECKED)) ;
                  ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;            // nascondo Edit
                  ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;           // nascondo Combo
                  ShowWindow( GetDlgItem( hwndDlg, IDC_BUTTON_SEL1 + i), SW_HIDE) ;      // nascondo Button di selezione
                  s_nType[i] = CTRL_CHECK ;
               }

              // --- se ComboBox
               else if ( s_sEdit[i].find( "CB:") == 0) {
                  string sList = s_sEdit[i].substr( 3) ;
                  STRVECTOR vsVal ;
                  Tokenize( sList, ",", vsVal) ;
                  int nSel = 0 ;
                  HWND hwndCBox = GetDlgItem( hwndDlg, IDC_COMBO1 + i) ;
                  for ( int j = 0 ; j < ssize( vsVal) ; ++ j) {
                     string sItem ; 
                     if ( vsVal[j][0] == '*') {
                        nSel = j ;
                        sItem = vsVal[j].substr( 1) ;
                     }
                     else
                        sItem = vsVal[j] ;
                     ComboBox_AddString( hwndCBox, stringtoW( sItem)) ;
                  }
                  ComboBox_SetCurSel( hwndCBox, nSel) ;
                  int nEditHeight = int( SendMessage( hwndCBox, CB_GETITEMHEIGHT, (WPARAM)-1, 0)) ;
                  int nItemHeight = int( SendMessage( hwndCBox, CB_GETITEMHEIGHT, 0, 0)) ;
                  int nTotalHeight = nEditHeight + nItemHeight * ( ssize( vsVal) + 1) ;
                  RECT rc ; GetWindowRect( hwndCBox, &rc) ;
                  HWND parent = GetParent(hwndCBox) ; MapWindowPoints( NULL, parent, (LPPOINT)&rc, 2) ;
                  SetWindowPos( hwndCBox, NULL, rc.left, rc.top, rc.right - rc.left, nTotalHeight, SWP_NOZORDER) ;
                  ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;            // nascondo Edit
                  ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;           // nascondo CheckBox
                  ShowWindow( GetDlgItem( hwndDlg, IDC_BUTTON_SEL1 + i), SW_HIDE) ;      // nascondo Button di selezione
                  s_nType[i] = CTRL_COMBO ;
               }

              // --- se ColorPicker
               else if ( s_sEdit[i].find( "CP:") == 0) {
                  string sVal = s_sEdit[i].substr( 3) ;
                  Color CColor ;
                  if ( ! FromString( sVal, CColor))
                     CColor = INVISIBLE ;
                  selectedColor[i] = RGB( CColor.GetIntRed(), CColor.GetIntGreen(), CColor.GetIntBlue()) ;
                  if ( hColorBrush[i] != NULL)
                     DeleteObject( hColorBrush[i]) ;
                  hColorBrush[i] = CreateSolidBrush( selectedColor[i]) ;
                 // recupero i valori dei colori personalizzati dal file .ini
                  if ( ! s_bCustomColorsInit) {
                    // recupero il file Ini
                     string sIniFile = ExeGetIniFile() ;
                     if ( ! sIniFile.empty()) {
                        string sCustomVals = GetPrivateProfileStringUtf8( SEC_SCENE, KEY_CUSTOMCOLORS, "", sIniFile.c_str()) ;
                        STRVECTOR vsWinColors ; Tokenize( sCustomVals, ",", vsWinColors) ;
                        for ( int j = 0 ; j < ssize( vsWinColors) && j < 16 ; ++ j) {
                           unsigned int unVal ;
                           if ( FromString( vsWinColors[j], unVal)) {
                              unsigned int unR = unVal & 0xFF ;
                              unsigned int unG = ( unVal >> 8) & 0xFF ;
                              unsigned int unB = ( unVal >> 16) & 0xFF ;
                              s_CustomColors[j] = RGB( unR, unG, unB) ;
                           }
                        }
                     }
                     s_bCustomColorsInit = true ;
                  }
                 // nascondo qualsiasi tipo di componente
                  ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;            // nascondo Edit
                  ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;           // nascondo Combo
                  ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;           // nascondo Check
                  ShowWindow( GetDlgItem( hwndDlg, IDC_BUTTON_SEL1 + i), SW_HIDE) ;      // nascondo Button di selezione

                 // margini per dimensione del rettangolo preview pickColor
                  const int MARGIN_RIGHT = 8 ;        // spazio tra preview e bordo destro dialog
                  const int PREVIEW_HEIGHT = 20 ;     // altezza del rettangolo
                  const int PREVIEW_MIN_WIDTH = 40 ;  // larghezza minima

                 // creazione della static preview
                  HWND hwndPreview = NULL ;
                  HWND hwndEdit = GetDlgItem( hwndDlg, IDC_EDIT1 + i) ;
                  RECT rcEdit ; GetClientRect( hwndDlg, &rcEdit) ; // coordinate client del dialog
                  if ( hwndEdit != nullptr  &&  GetWindowRect( hwndEdit, &rcEdit)) {
                    // converti rcLabel in coordinate client
                     POINT ptEdit = { rcEdit.left, rcEdit.top } ;
                     ScreenToClient( hwndDlg, &ptEdit) ;
                     int x = ptEdit.x ;
                     int y = ptEdit.y ;
                     int width = rcEdit.right - rcEdit.left ;
                     if ( width < PREVIEW_MIN_WIDTH)
                        width = PREVIEW_MIN_WIDTH ;
                     hwndPreview = CreateWindowEx( 0, L"STATIC", NULL,
                                                   WS_CHILD | WS_VISIBLE | SS_NOTIFY | SS_CENTERIMAGE | WS_BORDER,
                                                   x, y, width, PREVIEW_HEIGHT,
                                                   hwndDlg, ( HMENU)( IDC_COLOR1 + i),
                                                   GetModuleHandle( NULL), NULL) ;
                  }
                 // pulizia elementi testuali
                  if ( hwndPreview) {
                     SetWindowText( hwndPreview, L"") ;
                     SetWindowPos( hwndPreview, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE) ;
                     InvalidateRect( hwndPreview, NULL, TRUE) ;
                     UpdateWindow( hwndPreview) ;
                  }
                  s_nType[i] = CTRL_COLOR ;
               }

              // --- se Button di selezione
               else if ( s_sEdit[i].find( "BS:") == 0) {
                  ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;                  // nascondo la Combo
                  ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;                  // nascondo la Check
                  SetDlgItemText( hwndDlg, IDC_BUTTON_SEL1 + i, stringtoW( string{ "-"})) ;     // modalità non Selezione
                  EnableWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), FALSE) ;                   // disattivo la Edit
                 // associo alla casella di testo la funzione di KeyPress su Enter
                  HWND hEdit = GetDlgItem( hwndDlg, IDC_EDIT1 + i) ;
                  if ( hEdit != nullptr)
                     SetWindowSubclass( hEdit, UpdateSelectionModelessDialog, 1, (DWORD_PTR)( IDC_EDIT1 + i)) ;
                  s_nType[i] = CTRL_BUTTON ;
               }

              // --- se Testo
               else {
                  SetDlgItemText( hwndDlg, IDC_EDIT1 + i, stringtoW( s_sEdit[i])) ;
                  ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;                 // nascondo Combo
                  ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;                 // nascondo Check
                  ShowWindow( GetDlgItem( hwndDlg, IDC_BUTTON_SEL1 + i), SW_HIDE) ;            // nascondo Button di selezione
                  s_nType[i] = CTRL_EDIT ;
               }
            }
           // se numero di controllo superiore al massimo, non visualizzo nullo ( in questo caso aggiungere elementi a Dialog in .rc)
            else {
              // nascondo tutto
               ShowWindow( GetDlgItem( hwndDlg, IDC_TEXT1 + i), SW_HIDE) ;
               ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;
               ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;
               ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;
               ShowWindow( GetDlgItem( hwndDlg, IDC_BUTTON_SEL1 + i), SW_HIDE) ;
               s_nType[i] = CTRL_NONE ;
            }
         }
         break ;

      case WM_CTLCOLORSTATIC :
         {
            HDC hdcStatic = ( HDC)wParam ;
            HWND hwndCtrl = ( HWND)lParam ;
            int ctrlId = GetDlgCtrlID( hwndCtrl) ;
            if ( ctrlId >= IDC_COLOR1  &&  ctrlId <= IDC_COLOR8) {
               int idx = ctrlId - IDC_COLOR1 ;
               if ( hColorBrush[idx] == NULL)
                  hColorBrush[idx] = CreateSolidBrush( selectedColor[idx]) ;
               SetBkMode( hdcStatic, OPAQUE) ;
               SetBkColor( hdcStatic, selectedColor[idx]) ;
               return ( INT_PTR)hColorBrush[idx] ;
            }
         }
         break ;

      case WM_COMMAND : {
         int id = LOWORD( wParam) ;
         int code = HIWORD( wParam) ;

        // --- se click di un Button di selezione
         if ( id >= IDC_BUTTON_SEL1  &&  id < IDC_BUTTON_SEL1 + MAX_CTRLS) {
            int nBtnId = id ;
            int nEditId = IDC_EDIT1 + ( id - IDC_BUTTON_SEL1) ;
            int nActiveRow = nEditId - IDC_EDIT1 ;
           // se il bottone premuto è lo stesso
            if ( nDlgModelessItem == nEditId) {
              // se selezione attiva, allora deve terminare
               if ( s_bSelectionMode) {
                  SetDlgItemText( hwndDlg, nBtnId, stringtoW( string{ "-"})) ;
                  EndSelectionMode( hwndDlg) ;
               }
              // se selezione non attiva, allora viene attivata
               else {
                  SetDlgItemText( hwndDlg, nBtnId, stringtoW( string{ "S"})) ;
                  StartSelectionMode( hwndDlg, nEditId, nActiveRow) ;
               }
            }
           // se nuovo buttone premuto
            else {
              // se esisteva una selezione precedente, questa viene annullata
               if ( nDlgModelessItem != -1) {
                 // recupero il Button di selezione precedente e modifico il suo testo
                  int nPrevBtnId = IDC_BUTTON_SEL1 + ( nDlgModelessItem - IDC_EDIT1) ;
                  SetDlgItemText( hwndDlg, nPrevBtnId, stringtoW( string{ "-"})) ;
               }
              // la selezione passa al comando corrente
               nDlgModelessItem = nEditId ;
               SetDlgItemText( hwndDlg, nBtnId, stringtoW( string{ "S"})) ;
              // il dialogo diventa "Modeless" temporaneamente
               s_nActiveRow = nEditId - IDC_EDIT1 ;
               StartSelectionMode( hwndDlg, nEditId, nActiveRow) ;
            }
            return TRUE ;  // !<-- esco
         }
        // --- se comando di Preview per brush di colori mediante click del mouse
         else if ( code == STN_CLICKED  &&  id >= IDC_COLOR1  &&  id <= IDC_COLOR8) {
          // se selezione attiva, allora deve terminare
            if ( s_bSelectionMode) {
               // se esisteva una selezione precedente, questa viene annullata
               if ( nDlgModelessItem != -1) {
                 // recupero il Button di selezione precedente e modifico il suo testo
                  int nPrevBtnId = IDC_BUTTON_SEL1 + ( nDlgModelessItem - IDC_EDIT1) ;
                  SetDlgItemText( hwndDlg, nPrevBtnId, stringtoW( string{ "-"})) ;
               }
               EndSelectionMode( hwndDlg) ;
            }
            int idx = id - IDC_COLOR1 ;
            HWND hwndPreview = GetDlgItem( hwndDlg, IDC_COLOR1 + idx) ;
            if ( ! hwndPreview)
               return TRUE ;
           // apertura ChooseColor (usa hwndDlg come owner)
            CHOOSECOLOR cc = {} ;
            cc.lStructSize = sizeof( cc) ;
            cc.hwndOwner = hwndDlg ;
            cc.lpCustColors = s_CustomColors ;
            cc.rgbResult = selectedColor[idx] ;
            cc.Flags = CC_FULLOPEN | CC_RGBINIT ;
            if ( ChooseColor( &cc)) {
               selectedColor[idx] = cc.rgbResult ;
              // salvo nel file Ini i nuovi colori personalizzati
               string sIniFile = ExeGetIniFile() ;
               if ( ! sIniFile.empty()) {
                  string sOut = "" ;
                  for ( int j = 0 ; j < ssize( s_CustomColors) && j < 16 ; ++ j)
                     sOut += ToString( ( unsigned int)s_CustomColors[j]) + "," ;
                  sOut.pop_back() ;
                  WritePrivateProfileStringUtf8( SEC_SCENE, KEY_CUSTOMCOLORS, sOut.c_str(), sIniFile.c_str()) ;
               }
               if ( hColorBrush[idx] != NULL)
                  DeleteObject( hColorBrush[idx]) ;
               hColorBrush[idx] = CreateSolidBrush( selectedColor[idx]) ;
               InvalidateRect(hwndPreview, NULL, TRUE) ;
               UpdateWindow( hwndPreview) ;
            }
            return TRUE ; // !<-- Esco
         }

         switch ( LOWORD( wParam)) {
            case IDOK : {
              // recupero il contesto impostato alla creazione della finestra (durante esecuzione WM_INITDIALOG)
               DialogContext* ctx = (DialogContext*)GetWindowLongPtr( hwndDlg, GWLP_USERDATA) ;
               if ( ctx != nullptr) {
                 // inizializzo i risultati
                  ctx->vsResult.clear() ;
                  ctx->vsResult.reserve( s_nCtrls) ;
                 // recupero i valori degli Item
                  for ( int i = 0 ; i < s_nCtrls ; ++ i) {
                     AtoWEX<128> wsEdit( "") ;
                     s_sEdit[i] = "" ;

                     switch ( s_nType[i]) {
                     case CTRL_CHECK :
                        s_sEdit[i] = ( IsDlgButtonChecked( hwndDlg, IDC_CHECK1 + i) == BST_CHECKED ? "1" : "0") ;
                        break ;
                     case CTRL_COMBO :
                        if ( GetDlgItemText( hwndDlg, IDC_COMBO1 + i, LPWSTR( wsEdit), 128) > 0)
                           s_sEdit[i] = wstrztoA( wsEdit) ;
                        break ;
                     case CTRL_EDIT :
                        if ( GetDlgItemText( hwndDlg, IDC_EDIT1 + i, LPWSTR( wsEdit), 128) > 0)
                           s_sEdit[i] = wstrztoA( wsEdit) ;
                        break ;
                     case CTRL_COLOR :
                        {
                           COLORREF col = selectedColor[i] ;
                           BYTE r = GetRValue( col), g = GetGValue( col), b = GetBValue( col) ;
                           char buf[16] ;
                           sprintf_s( buf, sizeof( buf), "%u,%u,%u", r, g, b) ;
                           s_sEdit[i] = buf ;
                        }
                        break ;
                     case CTRL_BUTTON :
                        if ( GetDlgItemText( hwndDlg, IDC_EDIT1 + i, LPWSTR( wsEdit), 128) > 0)
                           s_sEdit[i] = wstrztoA( wsEdit) ;
                        break ;
                     }

                    // inserisco i valori all'interno della tabella Lua
                     ctx->vsResult.push_back( s_sEdit[i]) ;
                  }

                  ctx->bCancelled = false ;
                  ctx->bDone = true ;
               }

              // chiudo il dialogo
               OnClosingDialog( hwndDlg) ;
               return TRUE ;
            }
            [[fallthrough]] ;
            case IDCANCEL : {
              // pulizia brush colori
               for ( int i = 0 ; i < MAX_CTRLS ; ++ i) {
                  if ( hColorBrush[i] != NULL) {
                     DeleteObject( hColorBrush[i]) ;
                     hColorBrush[i] = NULL ;
                  }
               }
              // recupero il contesto impostato alla creazione della finestra ( durante esecuzione WM_INITDIALOG) e se esiste lo rimuovo
               DialogContext* ctx = (DialogContext*)GetWindowLongPtr( hwndDlg, GWLP_USERDATA) ;
               if ( ctx != nullptr) {
                  ctx->bCancelled = true ;
                  ctx->bDone = true ;
               }
              // chiudo il dialogo
               OnClosingDialog( hwndDlg) ;
               return TRUE ;
            }
         }

        // se siamo in modalità di Selezione e il comando attivo non si riferisce ad un button di Selezione (BS), il dialogo torna modale
         if ( s_bSelectionMode) {
            bool bIsBS = ( id >= IDC_BUTTON_SEL1  &&  id < IDC_BUTTON_SEL1 + MAX_CTRLS) ;
            bool bIsActiveEdit = ( id == IDC_EDIT1 + s_nActiveRow) ;
           // il dialogo torna modale
            if ( ! bIsBS && ! bIsActiveEdit)
               EndSelectionMode( hwndDlg) ;
         }
         break ;
      }

      case WM_CLOSE : {
         // recupero il contesto impostato alla creazione della finestra ( durante esecuzione WM_INITDIALOG) e se esiste lo rimuovo
         DialogContext* ctx = (DialogContext*)GetWindowLongPtr( hwndDlg, GWLP_USERDATA) ;
         if ( ctx != nullptr) {
            ctx->bCancelled = true ;
            ctx->bDone = true ;
         }
        // chiudo il dialogo
         OnClosingDialog( hwndDlg) ;
         return TRUE ;
      }
   }

   return FALSE ;
}

//-------------------------------------------------------------------------------
//  LuaDialogBox (Modeless)
//
//  Scopo:
//  ------
//  Questa funzione implementa un dialogo "modale" dal punto di vista del codice Lua, ma "modeless" dal punto di vista della
//  UI Windows quando necessario. L’obiettivo è permettere al codice Lua di rimanere sospeso finché l’utente non chiude il
//  dialogo (OK/Cancel/X), mantenendo però la UI attiva e permettendo selezioni nella scena quando l’utente preme un pulsante
//  BS (Button Selection).
//
//  Perché serve:
//  -------------
//  - I dialoghi modali standard (DialogBox) bloccano completamente la UI, mentre i dialoghi modeless standard (CreateDialog)
//    NON bloccano il codice Lua.
//  - Le coroutine Lua (lua_yield/lua_resume) non sono utilizzabili in questo contesto perché il thread principale
//    dell’applicazione non può essere sospeso tramite yield: il codice Lua non riprende correttamente e la UI non si
//    aggiorna coerentemente)
//
//  Come funziona:
//  --------------
//  1) Il dialogo viene creato con CreateDialogParam(), quindi la UI rimane attiva.
//  2) La funzione NON ritorna subito: entra in un message loop locale (Esattamente equivalente al loop all'interno di
//     DialogBox()). Il cuore del loop è GetMessage(), che è una chiamata BLOCCANTE. Significa che il thread rimane in
//     attesa senza consumare CPU finché non arriva un messaggio. Non c’è polling, non c’è busy loop. Il comportamento è
//     identico a quello di un dialogo modale nativo.
//  3) Il ciclo rimane attivo finché:
//        - l’utente non chiude il dialogo (OK/Cancel/X)
//        - oppure la finestra viene distrutta
//     In quel momento ctx->bDone viene impostato a true.
//  4) Durante la vita del dialogo, se l’utente preme un pulsante BS, il dialogo diventa temporaneamente "modeless":
//        - la main window viene abilitata
//        - il dialogo rimane abilitato ma passa in secondo piano logico
//        - l’utente può selezionare oggetti nella scena
//     Quando la selezione termina, il dialogo torna modale.
//  5) Quando il dialogo chiude, i valori vengono copiati in ctx->vsResult e ritornati a Lua come risultato della funzione.
//
//  Vantaggi della soluzione:
//  -------------------------
//  - Lua rimane bloccato come con un dialogo modale tradizionale.
//  - La UI rimane completamente attiva.
//  - Le selezioni BS (mediante Button Selection) funzionano senza bloccare il programma.
//  - Nessun uso di coroutine Lua (che non erano affidabili in questo contesto).
//  - Nessun consumo CPU anomalo.
//  - Comportamento stabile e prevedibile.
//
//  Nota importante:
//  ----------------
//  Il dialogo NON viene mai disabilitato durante la selezione BS (Button Selection). Solo la main window viene
//  abilitata temporaneamente.
//  Questo è fondamentale: disabilitare il dialogo impedirebbe all’utente di poterlo riselezionare dopo la selezione nella scena.
//
static int
LuaDialogBox( lua_State* L)
{
  // 1 .. 9 parametri : sCaption, { sText, sDefault}, ...
   LuaCheckParam( L, 1, s_sCaption)
   s_nCtrls = 0 ;
   for ( int i = 0 ; i < MAX_CTRLS ; ++ i) {
      STRVECTOR vData ;
      if ( LuaGetParam( L, 2 + i, vData)  &&  ssize( vData) >= 2) {
         s_sText[i] = Trim( vData[0]) ;
         s_sEdit[i] = Trim( vData[1]) ;
         ++ s_nCtrls ;
      }
      else
         break ;
   }
   LuaClearStack( L) ;

  // se UI disabilitata, esco
   if ( ! ExeGetEnableUI()) {
      LuaSetParam( L) ;
      return 1 ;
   }

  // se dialogo Modeless già aperto, errore
   if ( phDlgModeless != nullptr) {
      LuaSetParam( L) ;
      return 1 ;
   }

  // creazione del contesto e della Coroutine da gestire
   DialogContext* ctx = new DialogContext() ;
   if ( ctx == nullptr) {
      LuaSetParam( L) ;
      return 1 ;
   }

  // creazione di un dialogo Modeless
   HWND hTopWnd = ExeGetMainWindowHandle() ;
   nDlgModelessItem = -1 ;
   phDlgModeless = ( CreateDialogParam( GetModuleIstance(), MAKEINTRESOURCE( IDD_LUADLG), hTopWnd,
                                       (DLGPROC)DialogBoxModelessProc, (LPARAM)ctx)) ;
   if ( phDlgModeless == nullptr) {
      delete( ctx) ;
      ctx = nullptr ;
      LuaSetParam( L) ;
      return 1 ;
   }

  // porto la finestra in primo piano
   ShowWindow( phDlgModeless, SW_SHOW) ;
   SetForegroundWindow( phDlgModeless) ;

  // message Loop Modale (ripresa del Loop come da dialogo modale)
   MSG msg ;
   while ( ! ctx->bDone  &&  IsWindow( phDlgModeless)) {
      if ( GetMessage( &msg, NULL, 0, 0) <= 0)
         break ;
      if ( ! IsDialogMessage( phDlgModeless, &msg)) {
         TranslateMessage( &msg) ;
         DispatchMessage( &msg) ;
      }
   }

  // ritorno i valori lua
   if ( ctx->bCancelled)
      LuaSetParam( L, false) ;
   else
      LuaSetParam( L, ctx->vsResult) ;

  // libero la memoria
   delete ctx ;
   ctx = nullptr ;
   return 1 ;
}

//-------------------------------------------------------------------------------
bool
LuaInstallGeneral( LuaMgr& luaMgr)
{
   bool bOk = ( &luaMgr != nullptr) ;
   bOk = bOk && luaMgr.RegisterFunction( "print", MyPrint) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEvalNumExpr", LuaEvalNumExpr) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtPause", LuaPause) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetKeyPressed", LuaGetKeyPressed) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtStartCounter", LuaStartCounter) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtStopCounter", LuaStopCounter) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtNumToString", LuaNumToString) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitString", LuaSplitString) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSplitStringPlus", LuaSplitStringPlus) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtReplaceString", LuaReplaceString) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetVal", LuaSetVal) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetVal", LuaGetVal) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetUUID", LuaGetUUID) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExecTsc", LuaExecTsc) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExecTscLine", LuaExecTscLine) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetTscVar", LuaSetTscVar) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetTscVar", LuaGetTscVar) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetDebugLevel", LuaGetDebugLevel) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetUserLevel", LuaGetUserLevel) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOutLog", LuaOutLog) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetEnableUI", LuaGetEnableUI) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOutBox", LuaOutBox) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtProcessEvents", LuaProcessEvents) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtOutText", LuaOutText) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFileDialog", LuaFileDialog) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExistsFile", LuaExistsFile) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCopyFile", LuaCopyFile) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtRenameFile", LuaRenameFile) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEraseFile", LuaEraseFile) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtFindAllFiles", LuaFindAllFiles) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCompareFilesLastWriteTime", LuaCompareFilesLastWriteTime) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDirectoryDialog", LuaDirectoryDialog) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtExistsDirectory", LuaExistsDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCreateDirectory", LuaCreateDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEmptyDirectory", LuaEmptyDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEraseDirectory", LuaEraseDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtEraseNonEmptyDirectory", LuaEraseNonEmptyDirectory) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtTextFileCompare", LuaTextFileCompare) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtBinaryFileCompare", LuaBinaryFileCompare) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetStringFromIni", LuaGetStringFromIni) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtWriteStringToIni", LuaWriteStringToIni) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetIniFile", LuaGetIniFile) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetTempDir", LuaGetTempDir) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetExeVersion", LuaGetExeVersion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetVersion", LuaGetVersion) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtIs64bit", LuaIs64bit) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetLanguage", LuaGetLanguage) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtMsg", LuaGetMsg) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtVerifyKeyOption", LuaVerifyKeyOption) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtSetDefaultFont", LuaSetDefaultFont) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtGetDefaultFont", LuaGetDefaultFont) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtWinExec", LuaWinExec) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtCloseExe", LuaCloseExe) ;  
   bOk = bOk && luaMgr.RegisterFunction( "EgtCreateMutex", LuaCreateMutex) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtReleaseMutex", LuaReleaseMutex) ;
   bOk = bOk && luaMgr.RegisterFunction( "EgtDialogBox", LuaDialogBox) ;
   return bOk ;
}