Optimizar código

[MaxiDucoli]

Hola, buenas tardes.
Aprovecho que hay un gurú que sabe bocha de WinApi y quería preguntar lo siguiente:

Tengo este código insertado en un Timer dentro de un formulario que se ejecuta como "Loading Screen" mientras se carga un emulador de fondo.
Una vez que abrió el emulador el código busca el Caption del mismo y lo trae al frente y luego se cierra.
Hay alguna manera de optimizar el código este o sí o sí se tiene que hacer de una manera como esta?

Se pueden buscar los exe en ejecución y terminarlos directamente? Eso sería de mucha ayuda para el programa principal así puedo cerrar los emuladores al presionar ESCAPE (que ya me solucionaron como hacerlo, pero lo hago algo "Sucio" y a veces falla).

Les dejo el código y muchas gracias de ante mano!!!!

Código Delphi [-]
unit close;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, jpeg, pngimage, Vcl.Forms,TLHelp32, Vcl.Dialogs, JvBackgrounds, Vcl.ExtCtrls;

type
  TFrmLaunchIMG = class(TForm)
    JvBackground1: TJvBackground;
    TmrClose: TTimer;
    procedure FormCreate(Sender: TObject);
    procedure TmrCloseTimer(Sender: TObject);

  private
    { Private declarations }

  public
    { Public declarations }
  end;

var
  FrmLaunchIMG: TFrmLaunchIMG;
  Contador : integer;
  Win2 : HWND;
  Mensaje : String;

implementation

{$R *.dfm}



function FindWindowExtd(partialTitle: string): HWND;
var
  hWndTemp: hWnd;
  iLenText: Integer;
  cTitletemp: array [0..254] of Char;
  sTitleTemp: string;
begin
  hWndTemp := FindWindow(nil, nil);
  while hWndTemp <> 0 do begin
    iLenText := GetWindowText(hWndTemp, cTitletemp, 255);
    sTitleTemp := cTitletemp;
    sTitleTemp := UpperCase(copy( sTitleTemp, 1, iLenText));
    partialTitle := UpperCase(partialTitle);
    if pos( partialTitle, sTitleTemp ) <> 0 then
      Break;
    hWndTemp := GetWindow(hWndTemp, GW_HWNDNEXT);
  end;
  result := hWndTemp;
end;

procedure TFrmLaunchIMG.FormCreate(Sender: TObject);
begin
FrmLaunchIMG.Height := Screen.Height;
FrmLaunchIMG.Width := Screen.Width;
JVBackGround1.Image.Picture.LoadFromFile(ParamStr(1));
Contador := 0;
end;

procedure TFrmLaunchIMG.TmrCloseTimer(Sender: TObject);
begin
SetWindowPos(FrmLaunchIMG.Handle, HWND_TOPMOST, 0, 0, 0, 0,
                 SWP_NoMove or SWP_NoSize);
 inc(Contador);

 if Contador > 5 then Contador := 0;


      if Contador = 5 then
      Begin

            Win2 :=  FindWindowExtd('RetroArch');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('PPSSPP ');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('Slot');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('Cemu');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('Redream');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('FS-UAE');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('Future');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('MAME');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('scummvm');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('Dolphin');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('WINGAMES');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;

            Win2 :=  FindWindowExtd('DAPHNE');
            if IsWindow(Win2) then
            begin
                Sleep(200);
                //SetForegroundWindow(Win2);
                SetWindowPos(Win2, HWND_TOPMOST, 0, 0, 0, 0,
                SWP_NoMove or SWP_NoSize);
                application.Terminate;
            end;
      End;
end;



end.

[[escafandra]]

No termino de entender con precisión lo que pretendes. ¿Quieres abrir un proceso, esperar a que esté abierto y entonces ponerlo en primer plano y tras esto cerrar la aplicación que lo abrió?


SI es esto lo que pretendes, yo utilizaría un createprocess que esperaría que se abra, localizaría el handle de la ventana del proceso abierto para ponerlo en primer plano y luego me termino tranquilamente.


Para localizar el handle de la ventana no usaría FindWindow, existe una forma mejor. Puesto que conocemos el hProcess del proceso hijo, conocemos su ProcessID. Con esto en la mano, enumeramos las ventanas hasta encontrar una que tenga ese ProcessID y nos quedamos con su Handle para ponerla en primer plano.

Código Delphi [-]

// Importamos GetProcessId si nuestro delphi no la tiene

function GetProcessId(hProcess: THANDLE): DWORD; stdcall;  external  Kernel32;



........................


implementation


//------------------------------------------------------------------------------
// Enumeramos las ventanas para encontrar la que tenga el PId buscado.
function GetWindowFromPId(PId: DWORD): THandle;
type
  TWinParam = record
    Handle: THandle;
    PId: DWORD;
  end;
  PWinParam = ^TWinParam;
var
  WinParam: TWinParam;

  function EnumWindowsProc(Handle: Thandle; lParam: LPARAM): BOOL; stdcall;
  var
    PId: DWORD;
  begin
    Result:= true;
    PId:= 0;
    GetWindowThreadProcessId(Handle, PId);
    if PWinParam(lParam).PId = PId then
    begin
      PWinParam(lParam).Handle:= Handle;
      Result:= false;
    end;
  end;

begin
  WinParam.Handle:= 0;
  WinParam.PId:= PId;
  EnumWindows(@EnumWindowsProc, LPARAM(@WinParam));
  repeat
    Result:= WinParam.Handle;
    WinParam.Handle:= Windows.GetParent(Result);
  until WinParam.Handle = 0;
end;

//------------------------------------------------------------------------------
// Creamos un proceso.
function Execute(CommandLine: String): THandle;
var
  SI: TStartupInfo;
  PI: TProcessInformation;
begin
  ZeroMemory(@SI, sizeof(TStartupInfo));
  SI.cb:= sizeof(SI);
  SI.dwFlags:= STARTF_USESHOWWINDOW or STARTF_USEPOSITION or STARTF_USESIZE;
  SI.wShowWindow:= SW_SHOW;
  Result:= 0;
  if CreateProcess(nil, PCHAR(CommandLine), nil, nil, false, 0, nil, nil, SI, PI) then
  begin
    WaitForInputIdle(PI.hProcess, 10000);
    Result:= GetWindowFromPId(PI.dwProcessId);
    CloseHandle(PI.hProcess);
    CloseHandle(PI.hThread);
  end;
end;

// Creamos un proceso, localizamos la ventana y la ponemos en primer plano
// Luego nos cerramos.
procedure EjecutamosyNosVamos;
var
  hWin: HWND;
begin
  hWin:= Execute('Notepad.exe');
  SetWindowPos(hWin, HWND_TOPMOST, 0,0,0,0, SWP_NOMOVE or SWP_NOSIZE);
  Close;  //Nos vamos
end;

Saludos.

[[escafandra]]

Empezado por MaxiDucoli

Se pueden buscar los exe en ejecución y terminarlos directamente? Eso sería de mucha ayuda para el programa principal...

Se me olvidaba esta parte.


Se puede terminar cualquier proceso a lo bruto aunque no es lo más recomendable. Se hace con la API TerminateProcess, pero es mejor tratar de terminarlos enviando el mensaje WM_CLOSE a la ventana principal de la aplicación. Si te interesa como buscar y matar procesos a lo bruto te dejo esto que escribí hace unos años:

Código Delphi [-]
uses
  Windows, TLHelp32;

.................

function EnablePrivilege(name: String; Enable: boolean = true): boolean;
var
  hToken: Cardinal;
  priv: TOKEN_PRIVILEGES;
begin
  priv.PrivilegeCount:= 1;
  priv.Privileges[0].Attributes:= 0;
  if Enable then priv.Privileges[0].Attributes:= SE_PRIVILEGE_ENABLED;
  LookupPrivilegeValue(nil, PCHAR(name), priv.Privileges[0].Luid);
  OpenProcessToken(GetCurrentProcess, TOKEN_ADJUST_PRIVILEGES, hToken);
  AdjustTokenPrivileges (hToken, FALSE, priv, sizeof(priv), nil, PDWORD(nil)^);
  Result:= (GetLastError = ERROR_SUCCESS);
  CloseHandle (hToken);
end;

procedure KillProcess(FileName: String);
var
  Process, hSysSnapshot: THandle;
  PE: TPROCESSENTRY32;
begin
  EnablePrivilege('SeDebugPrivilege');
  PE.dwSize:= sizeof(TPROCESSENTRY32);
  hSysSnapshot:= CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if (hSysSnapshot <> INVALID_HANDLE_VALUE) and Process32First(hSysSnapshot, PE) then
    repeat
      if (lstrcmpi(PE.szExeFile, PAnsiChar(FileName)) = 0) and (GetCurrentProcessID <> PE.th32ProcessID) then
      begin
        Process:= OpenProcess(PROCESS_TERMINATE, false, PE.th32ProcessID);
        if Process <> 0 then
        begin
          TerminateProcess(Process, 0);
          CloseHandle(process);
        end;
      end;
    until not Process32Next(hSysSnapshot, PE);
  CloseHandle(hSysSnapshot);
  EnablePrivilege('SeDebugPrivilege', false);
end;

Saludos.

[MaxiDucoli]

La ventana que necesito cerrar no hace más que abrirse en primer plano maximizada, de fondo tener una imagen como para tapar todo lo que sucede detrás y la idea es que una vez que se ejecute el programa emulador que deseo, esta ventana se cierre, ya que todo esto lo ejecuto desde un archivo .bat que te describo acá abajo:

@echo START
set HOME="\RetroLife\emulators\retroarch"
START "LAUNCHIMG" /B /D "\RetroLife" "FrmClose.exe" %2
START "RUN-EMU" /W /B /D "\RetroLife\emulators\retroarch" "retroarch.exe" -L "\RetroLife\emulators\retroarch\cores\%3_libretro.dll" --config "\RetroLife\emulators\retroarch\config\retroarch.cfg" --appendconfig "\RetroLife\emulators\retroarch\config\RetroLife-override.cfg" %1 --log-file "\RetroLife\logs\%3-Logfile.txt" -v
@echo Done


Lo que pasa acá es así:

Estoy dentro de un frontend de emuladores (EmulationStation por si lo conoces o Recalbox, Batocera, Retropie lo usan también pero en Linux) ejecuto el bat y le paso 3 parámetros

1 - Ubicación del juegos (ROM)
2 - nombre del sistema (es acá donde carga FrmClose.exe y le paso como parámetro el segundo parámetro del BAT que le indicaría donde cargar la imagen de fondo.
3 - Nombre para que guarde el LOG de todo lo que hace el emulador y seguir sus fallos.


Por lo que esa ventana que quiero cerrar no hace más que eso, mostrarse hasta que se abra el emulador.

Si le pongo que esa ventana lance directamente el emulador sin usar un BAT, cuando cierro esa ventana el frontend "piensa" que ya cerré el emulador y se vuelve a mostrar, dejando el emulador corriendo y eso no sirve.
Cuando cierro el emulador, el frontend debe volver a su estado maximizado, para esperar que le pase la ruta de otro juego o sistema.

Tenés alguna idea de como hacer para esperar a "ver" esa ventana del emulador y ahí cerrar la ventana de la imagen?

Por eso se me había ocurrido saber si el proceso se estaba ejecutando y cerrarla así nomás sin enviar ningún CLOSE.

[[escafandra]]

El problema es que no entiendo lo que quieres decir.
No se que es "esa ventana" no a que proceso corresponde, si es del emulador, si es tu Bat o si es una aplicación tuya.


Una ventana se puede cerrar pero si cierras su proceso, se acabó. No volverá a abrirse.
Cuando una ventana es la ventana principal de un proceso, generalmente cerrarla supone cerrar el proceso.


La consola no representa una ventana de un proceso sino un proceso sobre el que se ejecuta otro, usando la consola como sistema de interface. Cerrar la consola implica cerrar el proceso.


Si quieres saber si un proceso se está ejecutando, puedes usar este código:

Código Delphi [-]
uses
  Windows, TLHelp32;

function IsRuning(FileName: PAnsiChar): boolean;
var
  PE: TPROCESSENTRY32;
  ProcessHandle: THandle;
begin
  Result:= false;
  PE.dwSize:= sizeof(TPROCESSENTRY32);
  ProcessHandle:= CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
  if Process32First(ProcessHandle, PE) then
    repeat
      if lstrcmpi(PE.szExeFile, FileName) = 0 then
      begin
        Result:= true;
        break;
      end;
    until not Process32Next(ProcessHandle, PE);
  CloseHandle(ProcessHandle);
end;

Puedes encontrar más información aquí y aquí.




Saludos.

[MaxiDucoli]

Es medio complicado todo esto para mi y por eso me complico al querer explicarlo.

A ver si puedo sin repetir lo que te dije antes jajajaja!!

Desde el frontend de emuladores yo lanzo mi bat.
En ese bat lanzo dos programas hechos por mi:

En el primer programa que se ejecuta con START lanzo el FRM que muestra la imagen del emulador, esa que tiene que estar un poco abierta tapando todo, hasta que el emulador esté en ejecución.

Ese emulador yo lo largo inmediatamente después de lanzar el FRM en el bat con START pero a este le pongo la opcion /W para que espere a que termine el preceso para cerrarse el bat y de esta manera el frontend no se cierre automáticamente y espere a que termine de ejecutar el emulador.

Con lo que me diste de IsRunning() voy a probar de ponerlo en un Timer dentro del primer programa (el lanzador de imagen) y que espere 5 segundos para ver si se lanzo el emulador y si da TRUE que se cierre.


Muchas gracias.

[[escafandra]]

¿El frontend es un programa de consola?
¿Porque dependes de un Bat y no lo haces todo con una APP?
¿Porqué quieres una ventana para tapar? ¿Tapar que?
¿Has pensado que tu ventana "Tapadora" no tiene porqué cerrarse, que puede esconderse?


Tu mecanismo es enrevesado, debes tratar de encontrar una estrategia clara, sencilla y limpia.


Saludos.