//---------------------------------------------------------------------------- // 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 "/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 "Windowsx.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 parametro : numero di millisecondi int nTime ; LuaCheckParam( L, 1, nTime) LuaClearStack( L) ; // se abilitata UI, controllo la durata della pausa e la eseguo if ( 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 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 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 ; } //------------------------------------------------------------------------------- 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 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 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 ; } //------------------------------------------------------------------------------- const int MAX_CTRLS = IDC_TEXT8 -IDC_TEXT1 + 1 ; const int OFFS_CTRLS = 40 ; enum TYPE_CTRLS { CTRL_NONE = 0, CTRL_CHECK = 1, CTRL_COMBO = 2, CTRL_EDIT = 3} ; 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] ; //------------------------------------------------------------------------------- BOOL CALLBACK DialogBoxProc( HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam) { switch ( message) { case WM_INITDIALOG : { // 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) ; } // 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) { SetDlgItemText( hwndDlg, IDC_TEXT1 + i, stringtoW( s_sText[i])) ; 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) ; ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ; s_nType[i] = CTRL_CHECK ; } 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 < int( vsVal.size()) ; ++ 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) ; ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ; ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ; s_nType[i] = CTRL_COMBO ; } else { SetDlgItemText( hwndDlg, IDC_EDIT1 + i, stringtoW( s_sEdit[i])) ; ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ; ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ; s_nType[i] = CTRL_EDIT ; } } else { 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) ; s_nType[i] = CTRL_NONE ; } } break ; case WM_COMMAND : switch ( LOWORD( wParam)) { case IDOK : 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 ; } } // continua di seguito case IDCANCEL : EndDialog( hwndDlg, wParam) ; return TRUE ; } } return FALSE ; } //------------------------------------------------------------------------------- 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) && vData.size() >= 2) { s_sText[i] = Trim( vData[0]) ; s_sEdit[i] = Trim( vData[1]) ; ++ s_nCtrls ; } else break ; } LuaClearStack( L) ; // se abilitata UI, lancio dialogo if ( ExeGetEnableUI()) { // lancio dialogo HWND hTopWnd = ExeGetMainWindowHandle() ; bool bOk = ( DialogBox( GetModuleIstance(), MAKEINTRESOURCE( IDD_LUADLG), hTopWnd, (DLGPROC)DialogBoxProc) == IDOK) ; // restituzione parametri if ( bOk) { STRVECTOR vRes ; for ( int i = 0 ; i < s_nCtrls ; ++ i) vRes.emplace_back( s_sEdit[i]) ; LuaSetParam( L, vRes) ; } else { LuaSetParam( L) ; } } else LuaSetParam( L) ; 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( "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( "EgtExistsDirectory", LuaExistsDirectory) ; bOk = bOk && luaMgr.RegisterFunction( "EgtCreateDirectory", LuaCreateDirectory) ; bOk = bOk && luaMgr.RegisterFunction( "EgtEmptyDirectory", LuaEmptyDirectory) ; bOk = bOk && luaMgr.RegisterFunction( "EgtEraseDirectory", LuaEraseDirectory) ; 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( "EgtDialogBox", LuaDialogBox) ; bOk = bOk && luaMgr.RegisterFunction( "EgtWinExec", LuaWinExec) ; bOk = bOk && luaMgr.RegisterFunction( "EgtCloseExe", LuaCloseExe) ; bOk = bOk && luaMgr.RegisterFunction( "EgtCreateMutex", LuaCreateMutex) ; bOk = bOk && luaMgr.RegisterFunction( "EgtReleaseMutex", LuaReleaseMutex) ; return bOk ; }