Hallo,

ich möchte die windows konsole aufrufen und die ausgabe in einer memo ausgeben. Das funktioniert auch ohne Probleme, aber die Umlaute werden nicht richtig dargestellt.

Folgenden Code habe ich dafür aus dem Forum verwendet.

http://www.delphipraxis.net/169697-c...t-ausgabe.html

Hat jemand einen Tip für mich?

die Ausgabe sieht dann so aus.

markieren

Code:

Datentr„ger in Laufwerk C: ist....

Öffne ein CMD-Fenster,
Eigenschaften aufrufen,
Schriftart Lucida Console wählen,
man kann auch die Farben ändern.

Im Memo Schriftart MSLineDraw wählen.

Stichwort ASCII- bzw. ANSI-Codierung.

@hathor: Was hat das mit der Frage zu tun?

MfG Dalai

@dalai

Das ist mir schon klar, aber ich weiß gerade nicht wo ich ansetzen soll. Bin leider noch ein ziemlicher Frischling in der Programmierung.

Ich habe schon versucht den "buffer" mit OemToAnsi(buffer, buffer) zu konvertieren, aber da spuckt der Compiler leider einen Fehler aus.

markieren

Code:

´[dcc32 Error] IBDMain.pas(212): E2010 Incompatible types: 'PAnsiChar' and 'array[0..255] of PWideChar'

EDIT:

Habe nun ne Möglichkeit gefunden. Es lebe google!!!

Hier die Lösung:

markieren

Code:

OEMToAnsiBuff(Stream.Memory, Stream.Memory, Stream.Size);

Bevor man also den Stream in die StringList kopiert, kann man mit hilfe von OEMToAnsiBuff den stream zu ANSI konvertieren.

Hier noch die Webseite durch welche ich auf die Lösung gekommen bin. (ich hoffe das ist erlaubt)

http://www.swissdelphicenter.ch/torr...ode.php?id=723

Bevor ich frage, wo Du das hinein kopierst, schreibe ich gleich die ganze
Funktion:

zusammenfalten · markieren

Delphi-Quellcode:

function GetConsoleOutput(Command : string;
                          Output, Errors : TStringList) : Boolean;
var
  Buffer : array[0..255] of Char;
  CreationFlags : DWORD;
  NumberOfBytesRead : DWORD;
  PipeErrorsRead : THandle;
  PipeErrorsWrite : THandle;
  PipeOutputRead : THandle;
  PipeOutputWrite : THandle;
  ProcessInfo : TProcessInformation;
  SecurityAttr : TSecurityAttributes;
  StartupInfo : TStartupInfo;
  Stream : TMemoryStream;
begin
  //Initialisierung ProcessInfo
  FillChar(ProcessInfo, SizeOf(TProcessInformation), 0);

  //Initialisierung SecurityAttr
  FillChar(SecurityAttr, SizeOf(TSecurityAttributes), 0);
  SecurityAttr.nLength := SizeOf(TSecurityAttributes);
  SecurityAttr.bInheritHandle := True;
  SecurityAttr.lpSecurityDescriptor := nil;

  //Pipes erzeugen
  CreatePipe(PipeOutputRead, PipeOutputWrite, @SecurityAttr, 0);
  CreatePipe(PipeErrorsRead, PipeErrorsWrite, @SecurityAttr, 0);

  //Initialisierung StartupInfo
  FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
  StartupInfo.cb := SizeOf(TStartupInfo);
  StartupInfo.hStdInput := 0;
  StartupInfo.hStdOutput := PipeOutputWrite;
  StartupInfo.hStdError := PipeErrorsWrite;
  StartupInfo.wShowWindow := SW_HIDE;
  StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;

  CreationFlags := CREATE_DEFAULT_ERROR_MODE or
                   CREATE_NEW_CONSOLE or
                   NORMAL_PRIORITY_CLASS;

  // Folgende Zeile ist nur für Delphi ab 2009 erforderlich:
  UniqueString(Command);

  if CreateProcess(nil,
                   PChar(Command),
                   nil,
                   nil,
                   True,
                   CreationFlags,
                   nil,
                   nil,
                   StartupInfo,
                   ProcessInfo) then
  begin
    Result := True;
    //Write-Pipes schließen
    CloseHandle(PipeOutputWrite);
    CloseHandle(PipeErrorsWrite);

    //Ausgabe Read-Pipe auslesen
    Stream := TMemoryStream.Create;
    try
      while ReadFile(PipeOutputRead, Buffer, 255, NumberOfBytesRead, nil) do
      begin
         Stream.Write(Buffer, NumberOfBytesRead);
      end;
      OEMToAnsiBuff(Stream.Memory, Stream.Memory, Stream.Size); //<--------------
      Stream.Position := 0;
      Output.LoadFromStream(Stream);
    finally
      Stream.Free;
    end;
    CloseHandle(PipeOutputRead);

    //Fehler Read-Pipe auslesen
    Stream := TMemoryStream.Create;
    try
      while ReadFile(PipeErrorsRead, Buffer, 255, NumberOfBytesRead, nil) do
      begin
         Stream.Write(Buffer, NumberOfBytesRead);
      end;
      OEMToAnsiBuff(Stream.Memory, Stream.Memory, Stream.Size); //<--------------
      Stream.Position := 0;
      Errors.LoadFromStream(Stream);
    finally
      Stream.Free;
    end;
    CloseHandle(PipeErrorsRead);

    WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
    CloseHandle(ProcessInfo.hProcess);
  end
  else
  begin
    Result := False;
    CloseHandle(PipeOutputRead);
    CloseHandle(PipeOutputWrite);
    CloseHandle(PipeErrorsRead);
    CloseHandle(PipeErrorsWrite);
  end;
end;

Danke! Genau so habe ich es auch gemacht, aber du hast es weiter unten bei der Fehlerausgabe vergessen. Es gibts ja zwei StringsLists "Output" und "Error".

Zitat von EinsteinXXL:

Danke! Genau so habe ich es auch gemacht, aber du hast es weiter unten bei der Fehlerausgabe vergessen. Es gibts ja zwei StringsLists "Output" und "Error".

Er hat sowohl Output als auch Error verarbeitet!

Gruß
K-H

Danke für den Hinweis!
Ich habe zwar keine Ahnung, was in die "Fehler Read-Pipe" hineingeschrieben wird, aber ich habe die OEMToAnsiBuff-Function hinzugefügt. Schaden tut's nicht.