Newsgroup: it.comp.lang.delphi
Titolo: Esecuzione di applicazioni in sequenza

Salve a tutti
Problema.
Ho una piccola applicazione, un loader, che deve lanciare, a sua volta,
alcune applicazioni IN SEQUENZA, cioè una applicazione child NON può partire
prima che la precedente applicazione child sia terminata correttamente.
Cosa posso utilizzare per lanciare le applicazioni child? Magari
"ShellExecute" ?
Grazie in anticipo a tutti.
Andrea

 prima che la precedente applicazione child sia terminata correttamente.
io scrivere una funzione di questo tipo ...
procedure ExecuteChilds(ListOfChilds: TStrings);
begin
    for variabile := 0 to High(ListOfChilds) do
        WaitForSingleObject(ShellExecute(...),INFINITE)
end;
la ho buttata li senza neppure testarla, ma come idea dovrebbe funzionare
... magari implementala con qualche controllo sugli errori.
Ciao
--
- Carlo -
cbertu81(at)libero(dot)it

 ... magari implementala con qualche controllo sugli errori.
Attenzione che l'handle che la ShellExecute ritorna ha valenza locale e non
a livello di SO (ovvero identifica il processo eseguito in modo univoco ma
solo all'interno del contesto del processo chiamante). Usa ShellExecuteEx
impostando il flag adeguato (non ricordo con precisione qual'è ma dovrebbe
saltare all'occhio).
HTH :-)
--
Andrea /\/\agni
e-mail: 
ama...@supereva.it

 solo all'interno del contesto del processo chiamante).
Giusta osservazione!
Purtroppo ho disinstallato temporaneamente Delphi e non posso fare test ...
comunque qualcosa di simile dovrebbe (spero) funzionare.
Procedure ExecuteChilds(ListOfChilds: TStringList);
var counter: Integer;
    p_info: ShellExecuteInfo;
begin
  p_info.cbSize := SizeOf(TShellExecuteInfo);
  p_info.fMask  := SEE_MASK_NOCLOSEPROCESS
  p_info.nShow  := SW_SHOWNORMAL;
  for Counter := 0 to ListOfChilds.Count - 1 do begin
     if FileExists(ListOfChilds[Counter]) then begin
        p_info.lpFile := PChar(ListOfChilds[Counter]);
        if ShellExecuteEx(@p_info) then begin
                if (WaitForSingleObject(p_info.hProcess, INFINITE) =
WAIT_FAILED) then
                    RaiseLastWin32eError();
                CloseHandle(p_info.hprocess);
        end else
            RaiseLastWin32Error();
     end else
        ShowMessage('il file ' + ListOfChilds[Counter] + ' non esiste')
  end;
end;


         WaitForSingleObject(ShellExecute(...),INFINITE)
WaitForSingleObject deve accettare come parametro l'handle del
processo che entrera' in stato segnalato, non il risultato di
ShellExecute.

Giusto giusto l'altro ieri ho fatto una domanda simile e a seguito
delle risposte ho fatto questa routine che lancia un programma
e ne attente la fine; usa ShellExecuteEx.
Eccola:
function ShellExecExAndWait(const FileName: string; const Param: string;
const Operation: string): Boolean;
var
  SEInfo: TShellExecuteInfo;
  ExitCode: DWORD;
  ExecuteFile, ParamString, StartInString: string;
begin
  ExecuteFile:= FileName;
  FillChar(SEInfo, SizeOf(SEInfo), 0);
  SEInfo.cbSize := SizeOf(TShellExecuteInfo);
  with SEInfo do begin
    fMask := SEE_MASK_NOCLOSEPROCESS;
    Wnd := Application.Handle;
    lpFile := PChar(ExecuteFile);
    lpVerb := PChar(Operation);
    lpParameters := PChar(Param);
    nShow := SW_SHOWNORMAL;
  end;
  if ShellExecuteEx(@SEInfo) then begin
    repeat
      Application.ProcessMessages;
      GetExitCodeProcess(SEInfo.hProcess, ExitCode);
    until (ExitCode <> STILL_ACTIVE) or
    Application.Terminated;
  end;
end;
Operation può essere "open" oppure per es. "print".
A me serviva appunto per far stampare in sequenza dei documenti .doc
Ciao
Mirko