Clipboard temporär speichern

[Codehunter]

Hallo alle zusammen!

Ich habe folgendes Problem: Eine ActiveX-Komponente kann ausschließlich über die Zwischenablage Text einfügen (hat kein Interface mit dem man Strings übergeben könnte). Beim Einfügen übernimmt die Komponente die Textformatierungen welche in der Zwischenablage enthalten sind. Um das zu umgehen hole ich mir zur Laufzeit erstmal mit Clipboard.AsText den unformatierten Text in eine String-Variable, leere dann mit Clipboard.Clear die Zwischenablage und füge dann mit Clipboard.AsText:= Variable den Klartext wieder ein. Dann wird die ActiveX-Komponente angewiesen, den Inhalt der Zwischenablage einzufügen.

Soweit funktioniert das auch ganz gut. Nur möchte ich, daß nach der ganzen Aktion der originale Inhalt der Zwischenablage wieder hergestellt wird. TClipboard hat (zumindest in D5) keine Methode wie z.B. SaveToFile oder .SaveToStream. Gibt es eine Möglichkeit, eine Zwischenablage komplett zwischenzuspeichern und wiederherzustellen? Quasi die Rohdaten, unabhängig der Format-Container die da enthalten sind?

Danke schon mal
Cody

[DeddyH]

Ich weiß nicht, ob es funktioniert, aber ich habe das hier gefunden.

Hth

[Codehunter]

Vielen Dank für die schnelle Hilfe. Vier Augen sehen eben mehr als zwei

Ich kann bestätigen daß der verlinkte Code funktioniert, auch mit Clipboard-Containerformaten die Delphi 5 noch nicht kennt. Ich habs nur noch dahingehend optimiert daß eine temporäre Datei mit zufallsgeneriertem Namen erzeugt wird die im System-Temp-Verzeichnis liegt (Vista/7-Kompatibilität) und die automatisch wieder gelöscht wird.

Frage beantwortet und Thread geschlossen.

[Luckie]

Sollte sie nicht besser im Temporärenverzeichnis des Benutzers liegen?

[Codehunter]

Mit System-Temp meinte ich das Verzeichnis das bei jeder Windows-Version in %TEMP% definiert ist. Das ist bei den neueren NTs eben das Temp-Verzeichnis im jeweiligen Profilpfad und bei den Win 9x das globale Verzeichnis. Bekommt man auch mit Windows.GetTempPath wenn man nicht mit den alten Variablen arbeiten will.

[handyotto]

Zitat von DeddyH:

Ich weiß nicht, ob es funktioniert, aber ich habe das hier gefunden.

Ja, alter Thread, ich weiß ja... aber leider hat der Link etwas Entscheidendes verloren... seinen Inhalt.
Und wo ich auch Suche, immer wieder werde ich dorthin verwiesen...

Hat das noch jemand parat?

Zitat von Codehunter:

Ich kann bestätigen daß der verlinkte Code funktioniert... nur noch ... optimiert ...

Natürlich gerne auch optimiert...


Danke!

[Der schöne Günther]

Etwas Geduld vorausgesetzt hilft die Internet Wayback Machine mit einer Zeitreise zurück ins selige Jahr 2005 als die Seite noch ging:

http://web.archive.org/web/200505141...ode.php?id=945

[Sherlock]

Und weil auch das Webarchiv irgendwann einmal den Weg alles irdischen gegangen sein könnte:

Zitat:

...copy the clipboard to a stream and restore it again?
Autor: P. Below
Homepage: http://www.teamb.com

Delphi-Quellcode:

uses
  clipbrd;

procedure CopyStreamToClipboard(fmt: Cardinal; S: TStream);
var
  hMem: THandle;
  pMem: Pointer;
begin
  Assert(Assigned(S));
  S.Position := 0;
  hMem       := GlobalAlloc(GHND or GMEM_DDESHARE, S.Size);
  if hMem <> 0 then
  begin
    pMem := GlobalLock(hMem);
    if pMem <> nil then
    begin
      try
        S.Read(pMem^, S.Size);
        S.Position := 0;
      finally
        GlobalUnlock(hMem);
      end;
      Clipboard.Open;
      try
        Clipboard.SetAsHandle(fmt, hMem);
      finally
        Clipboard.Close;
      end;
    end { If }
    else
    begin
      GlobalFree(hMem);
      OutOfMemoryError;
    end;
  end { If }
  else
    OutOfMemoryError;
end; { CopyStreamToClipboard }

procedure CopyStreamFromClipboard(fmt: Cardinal; S: TStream);
var
  hMem: THandle;
  pMem: Pointer;
begin
  Assert(Assigned(S));
  hMem := Clipboard.GetAsHandle(fmt);
  if hMem <> 0 then
  begin
    pMem := GlobalLock(hMem);
    if pMem <> nil then
    begin
      try
        S.Write(pMem^, GlobalSize(hMem));
        S.Position := 0;
      finally
        GlobalUnlock(hMem);
      end;
    end { If }
    else
      raise Exception.Create('CopyStreamFromClipboard: could not lock global handle ' +
        'obtained from clipboard!');
  end; { If }
end; { CopyStreamFromClipboard }

procedure SaveClipboardFormat(fmt: Word; writer: TWriter);
var
  fmtname: array[0..128] of Char;
  ms: TMemoryStream;
begin
  Assert(Assigned(writer));
  if 0 = GetClipboardFormatName(fmt, fmtname, SizeOf(fmtname)) then
    fmtname[0] := #0;
  ms := TMemoryStream.Create;
  try
    CopyStreamFromClipboard(fmt, ms);
    if ms.Size > 0 then
    begin
      writer.WriteInteger(fmt);
      writer.WriteString(fmtname);
      writer.WriteInteger(ms.Size);
      writer.Write(ms.Memory^, ms.Size);
    end; { If }
  finally
    ms.Free
  end; { Finally }
end; { SaveClipboardFormat }

procedure LoadClipboardFormat(reader: TReader);
var
  fmt: Integer;
  fmtname: string;
  Size: Integer;
  ms: TMemoryStream;
begin
  Assert(Assigned(reader));
  fmt     := reader.ReadInteger;
  fmtname := reader.ReadString;
  Size    := reader.ReadInteger;
  ms      := TMemoryStream.Create;
  try
    ms.Size := Size;
    reader.Read(ms.memory^, Size);
    if Length(fmtname) > 0 then
      fmt := RegisterCLipboardFormat(PChar(fmtname));
    if fmt <> 0 then
      CopyStreamToClipboard(fmt, ms);
  finally
    ms.Free;
  end; { Finally }
end; { LoadClipboardFormat }

procedure SaveClipboard(S: TStream);
var
  writer: TWriter;
  i: Integer;
begin
  Assert(Assigned(S));
  writer := TWriter.Create(S, 4096);
  try
    Clipboard.Open;
    try
      writer.WriteListBegin;
      for i := 0 to Clipboard.formatcount - 1 do
        SaveClipboardFormat(Clipboard.Formats[i], writer);
      writer.WriteListEnd;
    finally
      Clipboard.Close;
    end; { Finally }
  finally
    writer.Free
  end; { Finally }
end; { SaveClipboard }

procedure LoadClipboard(S: TStream);
var
  reader: TReader;
begin
  Assert(Assigned(S));
  reader := TReader.Create(S, 4096);
  try
    Clipboard.Open;
    try
      clipboard.Clear;
      reader.ReadListBegin;
      while not reader.EndOfList do
        LoadClipboardFormat(reader);
      reader.ReadListEnd;
    finally
      Clipboard.Close;
    end; { Finally }
  finally
    reader.Free
  end; { Finally }
end; { LoadClipboard }


// Examples:


{ Save Clipboard }

procedure TForm1.Button1Click(Sender: TObject);
var
  ms: TMemoryStream;
begin
  ms := TMemoryStream.Create;
  try
    SaveClipboard(ms);
    ms.SaveToFile('c:\temp\ClipBrdSaved.dat');
  finally
    ms.Free;
  end; { Finally }
end;

{ Clear Clipboard }

procedure TForm1.Button2Click(Sender: TObject);
begin
  clipboard.Clear;
end;

{ Restore Clipboard }

procedure TForm1.Button3Click(Sender: TObject);
var
  fs: TfileStream;
begin
  fs := TFilestream.Create('c:\temp\ClipBrdSaved.dat',
    fmopenread or fmsharedenynone);
  try
    LoadClipboard(fs);
  finally
    fs.Free;
  end; { Finally }
end;

Sherlock
- bevor Fragen aufkommen: Die Delphipraxis ist ewig...