Egalware/EgtExecutor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
EgtExecutor/LUA_General.cpp
T
Dario Sassi 0da1798029 EgtExecutor : 
- piccole modifiche a scelta colore per dialogo lua.
2026-02-24 08:42:06 +01:00

1613 lines
54 KiB
C++
Raw Permalink Blame History

//----------------------------------------------------------------------------
// 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 <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 ;
}
//-------------------------------------------------------------------------------
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, CTRL_COLOR = 4} ;
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] ;
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" ;
//-------------------------------------------------------------------------------
BOOL
CALLBACK DialogBoxProc( 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 :
{
// 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) ;
}
// 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 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 ( per sicurezza)
ShowWindow( GetDlgItem( hwndDlg, IDC_EDIT1 + i), SW_HIDE) ;
ShowWindow( GetDlgItem( hwndDlg, IDC_COMBO1 + i), SW_HIDE) ;
ShowWindow( GetDlgItem( hwndDlg, IDC_CHECK1 + i), SW_HIDE) ;
// 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
// ottieni o crea la static preview (allargata fino al bordo destro del dialog)
HWND hwndPreview = NULL ;
RECT rcLabel ;
HWND hwndLabel = GetDlgItem( hwndDlg, IDC_TEXT1 + i) ;
RECT rcClient ; GetClientRect( hwndDlg, &rcClient) ; // coordinate client del dialog
if ( hwndLabel && GetWindowRect( hwndLabel, &rcLabel)) {
// converti rcLabel in coordinate client
POINT ptLabel = { rcLabel.right, rcLabel.top } ;
ScreenToClient( hwndDlg, &ptLabel) ;
int x = ptLabel.x + 8 ; // distanza dal label
int y = ptLabel.y ;
int width = rcClient.right - x - MARGIN_RIGHT ;
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 ;
}
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_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) ;
// comando di Preview per brush di colori mediante click del mouse
if ( code == STN_CLICKED && id >= IDC_COLOR1 && id <= IDC_COLOR8) {
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 ;
}
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 ;
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 ;
}
}
}
[[fallthrough]] ;
case IDCANCEL : {
// pulizia brush colori
for ( int i = 0 ; i < MAX_CTRLS ; ++ i) {
if ( hColorBrush[i] != NULL) {
DeleteObject( hColorBrush[i]) ;
hColorBrush[i] = NULL ;
}
}
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( "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 ;
}
Reference in New Issue View Git Blame Copy Permalink