Datei mit Standard-App öffnen und auf Beendigung warten

[RaSoWa1]

Zitat von Bambini:

Zitat von RaSoWa1:

Ich bin nur ein Hobby-Programmierer und verdiene damit kein Geld, deshalb scheiden kostenpflichtige Komponeneten aus

Die Raize Komponenten gibt es zur zeit kostenlos zu Delphi 10.1 Berlin.
Laut Roadmap kommen die Zukünftig als Standard ins Delphi.
Ich habe noch nicht geschaut wie diese Komponente es macht, aber ich denke das läuft genauso über die hier beschriebenen API's

Eine neue Delphi-Version kostet noch viel viel mehr. Soviel will ich nicht für mein Hobby ausgeben. Für neue Projekt werde ich wahrscheinlich Visual Studio verwenden. Ich schnuppere gerade mal. Aber wir schweifen ab.

Gruß
Klaus

[hoika]

Hallo,
ShellExecuteEx liefert dir das Prozess-Handle (Feld hProcess) der Standard-App.
Danach weiter mit deinem WaitForXXX


Heiko

[RaSoWa1]

Zitat von himitsu:

Erstmal schauen was die Standard-Anwendung ist. (HKEY_CLASSES_ROOT)
z.B. in der Registry die Dateiendung suchen und prüfen ob es etwas zum OPEN gibt

Wenn du "Glück" hast, dann ist da eine EXE verlinkt und wie man diese ausruft (meistens "xxxxx.exe %1")

Das kannst du dann mit ShellExecute ausführen.

Dies funktioniert nur bei einer normalen EXE. Da liefert mir ShellExecute auch das entsprechende .hProcess für WaitForSingleObject.
Bei einer WindowsApp (z.B.: Foto-App) funktioniert dies leider nicht. Auch in der Registry finde ich nichts, wie ich die App erkennen und starten kann.

Zitat:

Ist ein DDE-Server verlinkt, dann startest du Diesen (FindExecutable)
und zu dem sollte dann auch geschrieben stehen mit welcher Aktion darin dann das Document übergeben wird.

FindExecutable findet leider auch nur EXE-Dateien, keine Apps.

Zitat:

PROBLEMe wird es immer geben, wenn die gewünschte Anwendung nicht direkt gestartet wird, sondern "nur" ein Launcher, denn diese starten dann die eigentlich Anwendung, übergeben die Daten und beenden sich vorzeitig.
z.B. siehe MS Office, OpenOffice oder Delphi (das nutzt aktuell einen DDE-Server in der bdsLauncher.exe der die bds.exe startet)

Da hast du natürlich Recht.
Mir ist deshalb folgende Idee gekommen, für die ich gerade ein Testprogramm schreibe:
Ich schreibe unmittelbar vor und nach dem Aufruf mit ShellExecute alle ProzessID in jeweils eine Liste. Die Differenz beider Listen müsste mit hoher wahrscheinlichkeit die ProzessID der gestarteten Anwendung sein. Ich kann dann darauf reagieren. Ich kann dies aber erst am Wochenende weiter testen und prüfen ob und wie mir Windows dazwischen funkt.
Ich melde mich dann wieder.

Danke,
Gruß Klaus.

[RaSoWa1]

Hallo,
ich viel probiert und getestet und verwende jetzt folgenden Code:

Delphi-Quellcode:

function ExecAndWait2(Filename, Params: String; WindowState: Word = SW_SHOWNORMAL): Integer;
const
  cError     = -1;
  cWait      =  0;
  cNoWait    = -2;
var
  ShExecInfoW : SHELLEXECUTEINFOW;
  ExitInfo    : PExitThreadDebugInfo;
  wndLstAll,
  wndLst      : TStringList;
  i, a        : Integer;
  procedure AllProcessToLst(Lst: TStringList);
    function EnumWindowsProcA(Wnd: HWND; LParam: TStringList): BOOL; stdcall;
    begin
      result := True;
      if IsWindowVisible(Wnd) then
      begin
        LParam.Add(IntToStr(Wnd));
      end;
    end;
  begin
    EnumWindows(@EnumWindowsProcA, integer(Lst));
  end;
begin
  Result := cError;
  if (Filename <> '') and FileExists(FileName) then
  begin
    ShExecInfoW.Wnd          := GetForegroundWindow;
    ShExecInfoW.cbSize       := SizeOf(SHELLEXECUTEINFOW);
    ShExecInfoW.fMask        := SEE_MASK_NOCLOSEPROCESS;
    ShExecInfoW.lpVerb       := 'open';
    ShExecInfoW.lpFile       := PWideChar(WideString(Filename));
    ShExecInfoW.lpParameters := PWideChar(WideString(Params));
    ShExecInfoW.lpDirectory  := PWideChar(WideString(ExtractFileDir(Filename)));
    ShExecInfoW.nShow        := WindowState;
    wndLstAll                := TStringList.Create;
    try
      AllProcessToLst(wndLstAll);   
      if  ShellExecuteExW(@ShExecInfoW) then
      begin
        result := cNoWait;
        try
          if ShExecInfoW.hProcess <> 0 then
          begin
            WaitForInputIdle(ShExecInfoW.hProcess, INFINITE);
            New(ExitInfo);
            FillChar(ExitInfo.dwExitCode, SizeOf(ExitInfo.dwExitCode), 0);
            repeat
              Application.ProcessMessages;
              sleep(500);
              GetExitCodeProcess(ShExecInfoW.hProcess, ExitInfo.dwExitCode);
            until not(ExitInfo.dwExitCode = STILL_ACTIVE);
            Dispose(ExitInfo);
            Result := cWait;
          end
          else
          // neues Handle ermitteln und auf dessen Beendigung warten:
          begin
            wndLst := TStringList.Create;
            try
              sleep(500);           // warten bis App geöffnet ist
              AllProcessToLst(wndLst);
              for i := wndLst.Count - 1  downto 0 do
                if wndLstAll.IndexOf(wndLst[i]) > -1 then
                  wndLst.Delete(i);
              if wndLst.Count > 0 then
               // auf Beendigung warten:
              begin
                repeat
                  Application.ProcessMessages;
                  sleep(500);
                  wndLstAll.Clear;
                  AllProcessToLst(wndLstAll);
                  a := 0;
                  for i := 0 to wndLst.Count - 1 do
                    if wndLstAll.IndexOf(wndLst[i]) > -1 then
                      inc(a);
                until a < wndLst.Count;
                result := cWait;
              end;
            finally
              wndLst.Free
            end;
          end;
        finally
           CloseHandle(ShExecInfoW.hProcess);
        end;
      end;
    finally
      wndLstAll.Free;
    end;
  end;
end;

Die bisherigen Tests auf meinem Rechner liefen alle erfolgreich. Die Funktion wartet immer (auch bei Windows10-Apps) auf deren Beendigung.

Danke an alle Helfer.
Ein schönes Wochenende.
Gruß Klaus.