Question>
this code doesn't work - it fails in the last line because buf (a tchararray) cannot be assigned to text (which accepts a string). how do i fix that?

var
  list: tstringlist;
  reader: tstreamreader;
  buf: tchararray;
begin
  setlength(buf, bufsize + 1);
  list := tstringlist.create;
  reader := tstreamreader.create(fname, tencoding.default, true, 4096);
  while not reader.endofstream do
  begin
    tthread.synchronize(nil,
      procedure
      begin
        reader.readblock(buf, 0, bufsize);
      end);
    list.text := buf

ChatGpt> 
Answer>
The issue you're encountering arises because `TStringList.Text` expects a `String`, while `buf` is a `TCharArray` (an array of characters). To resolve this, you'll need to convert the `TCharArray` to a `String` before assigning it to `list.Text`.

Here are a few ways to achieve this conversion in Delphi:

1. **Using `String(buf)` Conversion:**

   You can directly convert the `TCharArray` to a `String` by casting it:

   ```pascal
   list.Text := String(buf);
   ```

2. **Using `SetString` Function:**

   The `SetString` function allows you to create a string from a character pointer and specify the length.

   ```pascal
   var
     tempStr: string;
   begin
     SetString(tempStr, PChar(buf), Length(buf));
     list.Text := tempStr;
   end;
   ```

3. **Using `AnsiString` or `UnicodeString` Depending on Encoding:**

   If you're dealing with specific encodings, you might need to handle them accordingly. For most cases, the above methods should suffice.

4. **Appending Instead of Assigning (If Intended):**

   If your intention is to append the read blocks to `list.Text`, you should use concatenation instead of assignment. Otherwise, each iteration will overwrite the previous content.

   ```pascal
   list.Text := list.Text + String(buf);
   ```

5. **Ensuring Proper Buffer Termination:**

   Make sure that the buffer is properly null-terminated, especially if you're converting using `PChar`.

Here's the revised version of your code incorporating the conversion:

```pascal
var
  list: TStringList;
  reader: TStreamReader;
  buf: TCharArray;
  tempStr: string;
begin
  SetLength(buf, bufsize + 1);
  list := TStringList.Create;
  try
    reader := TStreamReader.Create(fname, TEncoding.Default, True, 4096);
    try
      while not reader.EndOfStream do
      begin
        TThread.Synchronize(nil,
          procedure
          begin
            reader.ReadBlock(buf, 0, bufsize);
          end);
        // Convert buf to string
        tempStr := String(buf);
        // Optionally, trim any null characters
        tempStr := StringReplace(tempStr, #0, '', [rfReplaceAll]);
        // Append to the list
        list.Add(tempStr);
      end;
    finally
      reader.Free;
    end;
    // Now you can work with list.Text or other properties as needed
  finally
    list.Free;
  end;
end;
```

**Additional Recommendations:**

- **Resource Management:** Ensure that you're properly freeing the `TStringList` and `TStreamReader` objects after usage to prevent memory leaks.

- **Error Handling:** Consider adding error handling to manage scenarios where file reading might fail.

- **Performance Considerations:** If you're dealing with large files, appending strings repeatedly can be inefficient. In such cases, streaming directly or using more efficient data structures might be beneficial.

By converting the `TCharArray` to a `String` before assignment, you should resolve the type mismatch error.

---

**References:**

- [Delphi String Conversion](https://docwiki.embarcadero.com/Libraries/Sydney/en/System.SysUtils.SetString)
- [TStringList Documentation](https://docwiki.embarcadero.com/Libraries/Sydney/en/System.Classes.TStringList)

Convert the character array to a string before assignment, for example by using `String(buf)`. Change the last line to:
  `list.Text := String(buf);`

********************************************************************************

I want to create a Delphi application that would monitor clipboard content (on Windows) and append clipboard content to a log file each time the clipboard has changed (and has a text inside).

unit ClipboardMonitor;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Classes, Vcl.Forms,
  Vcl.Dialogs, Vcl.Clipbrd, Vcl.ExtCtrls, Vcl.Menus;

type
  TClipboardMonitorForm = class(TForm)
    TrayIcon: TTrayIcon;
    PopupMenu: TPopupMenu;
    ExitMenuItem: TMenuItem;
  private
    const
      WM_CLIPBOARDUPDATE = $031D;
    procedure WMCopyData(var Msg: TMessage); message WM_CLIPBOARDUPDATE;
    procedure HandleClipboardChange;
    procedure ExitMenuItemClick(Sender: TObject);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  end;

var
  ClipboardMonitorForm: TClipboardMonitorForm;

implementation

{$R *.dfm}

constructor TClipboardMonitorForm.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  // Hide the form
  Visible := False;
  ShowInTaskbar := stNever;

  // Setup TrayIcon
  TrayIcon := TTrayIcon.Create(Self);
  TrayIcon.Icon := Application.Icon;
  TrayIcon.Visible := True;

  // Setup PopupMenu
  PopupMenu := TPopupMenu.Create(Self);
  ExitMenuItem := TMenuItem.Create(PopupMenu);
  ExitMenuItem.Caption := 'Exit';
  ExitMenuItem.OnClick := ExitMenuItemClick;
  PopupMenu.Items.Add(ExitMenuItem);
  TrayIcon.PopupMenu := PopupMenu;

  // Register clipboard listener
  if not AddClipboardFormatListener(Self.Handle) then
    TrayIcon.BalloonHint := 'Failed to add clipboard format listener.';
end;

destructor TClipboardMonitorForm.Destroy;
begin
  // Remove the clipboard listener
  RemoveClipboardFormatListener(Self.Handle);
  TrayIcon.Free;
  PopupMenu.Free;
  inherited Destroy;
end;

procedure TClipboardMonitorForm.WMCopyData(var Msg: TMessage);
begin
  if Msg.Msg = WM_CLIPBOARDUPDATE then
    HandleClipboardChange;
  Msg.Result := 0;
end;

procedure TClipboardMonitorForm.HandleClipboardChange;
var
  ClipboardText: string;
  LogFilePath: string;
  FileHandle: TextFile;
begin
  // Open the clipboard to access its content
  if not OpenClipboard(Handle) then
    Exit;
  try
    if IsClipboardFormatAvailable(CF_UNICODETEXT) then
      ClipboardText := Clipboard.AsText
    else if IsClipboardFormatAvailable(CF_TEXT) then
      ClipboardText := Clipboard.AsText
    else
      Exit; // Not text data

    // Define the path to the log file
    LogFilePath := ExtractFilePath(Application.ExeName) + 'clipboard_log.txt';

    // Append the text to the log file with a timestamp
    AssignFile(FileHandle, LogFilePath);
    if FileExists(LogFilePath) then
      Append(FileHandle)
    else
      Rewrite(FileHandle);
    try
      Writeln(FileHandle, Format('[%s] %s', [FormatDateTime('yyyy-mm-dd hh:nn:ss', Now), ClipboardText]));
    finally
      CloseFile(FileHandle);
    end;
  finally
    CloseClipboard;
  end;
end;

procedure TClipboardMonitorForm.ExitMenuItemClick(Sender: TObject);
begin
  Application.Terminate;
end;

end.

********************************************************************************

I want to create a Delphi application that would monitor clipboard content (on Windows) and append clipboard content to a log file each time the clipboard has changed (and has a text inside).

unit ClipboardMonitor;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Clipbrd, ComCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    Timer1: TTimer;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure ClipboardChanged(Sender: TObject);
  private
    { Private declarations }
    ClipboardMonitor: HWND;
    LogFile: TStringList;
    procedure WriteToLogFile();
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  ClipboardMonitor := SetClipboardViewer(Handle);
  LogFile := TStringList.Create;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  WriteToLogFile();
end;

procedure TForm1.WriteToLogFile();
var
  ClipboardData: TClipboardData;
  Text: string;
begin
  // Get the current clipboard contents
  if not OpenClipboard(0) then Exit;
  try
    ClipboardData := GetClipboardData(CF_TEXT);
    Text := String(ClipboardData.lpstr);
    LogFile.Add(Text);
  finally
    CloseClipboard();
  end;
end;

procedure TForm1.ClipboardChanged(Sender: TObject);
begin
  WriteToLogFile();
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  ClipboardChanged(Sender);
end;

end.

[2024-11-27 11:32:12] Answer>

Here's a possible solution:

1. First, you need to use the `Clipboard` unit in Delphi to access the clipboard. This unit provides functions for getting and setting the contents of the clipboard.
2. Next, you need to set up an event handler that will be triggered each time the clipboard changes. This can be done by using the `OnChange` property of the `Clipboard` object.
3. In the event handler, you can check if there is text on the clipboard and append it to a log file. You can use the `TStringList` class in Delphi to store the contents of the clipboard and write them to the log file when the event handler is triggered.
4. To avoid writing the same content multiple times to the log file, you can keep track of what was already written using a `TStringList`. You can add the contents of the clipboard to this list when the event handler is triggered, and then check if it has already been added before appending it to the log file.
5. To make sure that the log file is updated only when there is new content on the clipboard, you can use a `TTimer` object in Delphi to periodically check the clipboard for changes. You can set up the timer to trigger an event handler each time it fires, and then check if there has been any change since the last time the event handler was triggered.
6. To write the log file, you can use a `TFileStream` object in Delphi to open the file and append the contents of the clipboard to it. You can also use the `Append` method of the `TStringList` class to add new content to the end of the file.
7. Finally, you need to close the log file when the application exits. You can do this by using the `Close` method of the `TFileStream` object in Delphi.

Here's some sample code that demonstrates how to implement this:
```delphi
unit ClipboardMonitor;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Clipbrd, ComCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    Memo1: TMemo;
    Timer1: TTimer;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure ClipboardChanged(Sender: TObject);
  private
    { Private declarations }
    ClipboardMonitor: HWND;
    LogFile: TStringList;
    procedure WriteToLogFile();
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  ClipboardMonitor := SetClipboardViewer(Handle);
  LogFile := TStringList.Create;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  WriteToLogFile();
end;

procedure TForm1.WriteToLogFile();
var
  ClipboardData: TClipboardData;
  Text: string;
begin
  // Get the current clipboard contents
  if not OpenClipboard(0) then Exit;
  try
    ClipboardData := GetClipboardData(CF_TEXT);
    Text := String(ClipboardData.lpstr);
    LogFile.Add(Text);
  finally
    CloseClipboard();
  end;
end;

procedure TForm1.ClipboardChanged(Sender: TObject);
begin
  WriteToLogFile();
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  ClipboardChanged(Sender);
end;

end.
```
In this example, the `ClipboardMonitor` object is created when the form is created and set up to monitor the clipboard for changes. The `Button1Click` event handler is used to write the current contents of the clipboard to a log file. The `WriteToLogFile` procedure is called by the `ClipboardChanged` event handler each time the clipboard has changed, and it adds the new contents of the clipboard to the log file. Finally, the `Timer1Timer` event handler is used to periodically check the clipboard for changes and trigger the `ClipboardChanged` event handler when there are any changes.

Note that this code uses the `SetClipboardViewer` function to monitor the clipboard for changes, which requires a window handle. Therefore, you need to create a form with a button and a timer in order to use this code. You can also modify the code to use a different clipboard format (such as CF_UNICODETEXT) if necessary.

********************************************************************************

I want to create a Delphi application that would monitor clipboard content (on Windows) and append clipboard content to a log file each time the clipboard has changed (and has a text inside).

```delphi
unit Unit1;

interface

uses
  Winapi.Windows, System.Classes, System.SysUtils, System.Classes,
  System.Generics.Collections, System.Winapi.StdVcl, Vcl.Graphics, Vcl.Controls;

type
  TClipboardMonitor = class(TComponent)
    private
      FLogFileName: string;
      FMonitorThread: TThread;
      procedure MonitorClipboard;
      function GetClipboardText: string;
      procedure AppendToLogFile(const Text: string);
    public
      constructor Create(AOwner: TComponent);
      destructor Destroy; override;
      property LogFileName: string read FLogFileName write FLogFileName;
  end;

procedure Register;

implementation

procedure Register;
begin
  RegisterComponents('ClipboardUtility', [TClipboardMonitor]);
end;

{ TClipboardMonitor }

constructor TClipboardMonitor.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FMonitorThread := CreateThread(nil, @MonitorClipboard);
end;

destructor TClipboardMonitor.Destroy;
begin
  if Assigned(FMonitorThread) then
  begin
    FMonitorThread.RequestTermination;
    FMonitorThread.Join;
    FMonitorThread.Free;
  end;
  inherited Destroy;
end;

procedure TClipboardMonitor.MonitorClipboard;
var
  OldClipboardFormat: TClipboardFormat;
begin
  try
    OldClipboardFormat := Clipboard.Format;
    while not Terminated do
    begin
      if Clipboard.Format <> OldClipboardFormat then
      begin
        OldClipboardFormat := Clipboard.Format;
        if Clipboard.HasFormat(CF_TEXT) then
        begin
          if not TextIsEmpty(GetClipboardText) then
            AppendToLogFile(GetClipboardText + #13#10);
        end;
      end;
      Sleep(100);
    end;
  except
    on E: Exception do
    begin
      ShowMessage(E.Message);
    end;
  end;
end;

function TClipboardMonitor.GetClipboardText: string;
var
  Data: Pointer;
begin
  Data := Clipboard.GetData(CF_TEXT);
  if Data <> nil then
    try
      Result := PChar(Data)^;
    finally
      Clipboard.FreeData(Data);
    end;
end;

procedure TClipboardMonitor.AppendToLogFile(const Text: string);
var
  FileHandle: THandle;
  BytesWritten: DWORD;
begin
  if FLogFileName = '' then
    Exit;

  FileHandle := FileOpen(PChar(FLogFileName), fmOpenReadWrite or fmShareExclusive);
  if FileHandle <> INVALID_HANDLE_VALUE then
  try
    FileSeek(FileHandle, 0, fsSeekEnd);
    FileWrite(FileHandle, Pointer(Text), Length(Text), BytesWritten);
  finally
    FileClose(FileHandle);
  end;
end;

end.

********************************************************************************

I want to create a Delphi application that would monitor clipboard content (on Windows) and append clipboard content to a log file each time the clipboard has changed (and has a text inside).

Answer>
Certainly! Here's a Delphi application that monitors the clipboard content on Windows and appends the clipboard text to a log file each time it changes:

```delphi
unit MainUnit;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Clipbrd;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    FNextViewer: HWND;
    FLastClipboardText: string;
    procedure WMChangeCBChain(var Msg: TWMChangeCBChain); message WM_CHANGECBCHAIN;
    procedure WMDrawClipboard(var Msg: TMessage); message WM_DRAWCLIPBOARD;
    procedure LogClipboardChange;
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FNextViewer := SetClipboardViewer(Handle);
  FLastClipboardText := '';
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  ChangeClipboardChain(Handle, FNextViewer);
end;

procedure TForm1.WMChangeCBChain(var Msg: TWMChangeCBChain);
begin
  if Msg.Remove = FNextViewer then
    FNextViewer := Msg.Next
  else if FNextViewer <> 0 then
    SendMessage(FNextViewer, WM_CHANGECBCHAIN, Msg.Remove, Msg.Next);

  Msg.Result := 0;
end;

procedure TForm1.WMDrawClipboard(var Msg: TMessage);
begin
  LogClipboardChange;

  if FNextViewer <> 0 then
    SendMessage(FNextViewer, WM_DRAWCLIPBOARD, 0, 0);
end;

procedure TForm1.LogClipboardChange;
var
  ClipboardText: string;
  LogFile: TextFile;
  LogFileName: string;
begin
  if Clipboard.HasFormat(CF_TEXT) then
  begin
    ClipboardText := Clipboard.AsText;
    
    // Only log if the clipboard text has changed
    if ClipboardText <> FLastClipboardText then
    begin
      FLastClipboardText := ClipboardText;
      
      LogFileName := ExtractFilePath(ParamStr(0)) + 'clipboard_log.txt';
      AssignFile(LogFile, LogFileName);
      
      if FileExists(LogFileName) then
        Append(LogFile)
      else
        Rewrite(LogFile);
      
      try
        WriteLn(LogFile, FormatDateTime('yyyy-mm-dd hh:nn:ss', Now) + ' - ' + ClipboardText);
        Memo1.Lines.Add('Logged: ' + ClipboardText);
      finally
        CloseFile(LogFile);
      end;
    end;
  end;
end;

end.
```

This code does the following:

1. It sets up a clipboard viewer chain in the `FormCreate` method to receive clipboard change notifications.

2. The `WMDrawClipboard` method is called whenever the clipboard content changes.

3. The `LogClipboardChange` method checks if the clipboard contains text, and if it's different from the last logged text.

4. If the clipboard text has changed, it appends the new text along with a timestamp to a log file named "clipboard_log.txt" in the same directory as the application.

5. It also displays the logged text in a memo control on the form for immediate feedback.

6. The clipboard viewer chain is properly cleaned up in the `FormDestroy` method.

To use this code:

1. Create a new VCL Forms Application in Delphi.

unit MainUnit;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Clipbrd;

type
  TForm1 = class(TForm)
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    FNextViewer: HWND;
    FLastClipboardText: string;
    procedure WMChangeCBChain(var Msg: TWMChangeCBChain); message WM_CHANGECBCHAIN;
    procedure WMDrawClipboard(var Msg: TMessage); message WM_DRAWCLIPBOARD;
    procedure LogClipboardChange;
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FNextViewer := SetClipboardViewer(Handle);
  FLastClipboardText := '';
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  ChangeClipboardChain(Handle, FNextViewer);
end;

procedure TForm1.WMChangeCBChain(var Msg: TWMChangeCBChain);
begin
  if Msg.Remove = FNextViewer then
    FNextViewer := Msg.Next
  else if FNextViewer <> 0 then
    SendMessage(FNextViewer, WM_CHANGECBCHAIN, Msg.Remove, Msg.Next);

  Msg.Result := 0;
end;

procedure TForm1.WMDrawClipboard(var Msg: TMessage);
begin
  LogClipboardChange;

  if FNextViewer <> 0 then
    SendMessage(FNextViewer, WM_DRAWCLIPBOARD, 0, 0);
end;

procedure TForm1.LogClipboardChange;
var
  ClipboardText: string;
  LogFile: TextFile;
  LogFileName: string;
begin
  if Clipboard.HasFormat(CF_TEXT) then
  begin
    ClipboardText := Clipboard.AsText;
    
    // Only log if the clipboard text has changed
    if ClipboardText <> FLastClipboardText then
    begin
      FLastClipboardText := ClipboardText;
      
      LogFileName := ExtractFilePath(ParamStr(0)) + 'clipboard_log.txt';
      AssignFile(LogFile, LogFileName);
      
      if FileExists(LogFileName) then
        Append(LogFile)
      else
        Rewrite(LogFile);
      
      try
        WriteLn(LogFile, FormatDateTime('yyyy-mm-dd hh:nn:ss', Now) + ' - ' + ClipboardText);
        Memo1.Lines.Add('Logged: ' + ClipboardText);
      finally
        CloseFile(LogFile);
      end;
    end;
  end;
end;

end.

unit MainUnit;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Clipbrd;

type
  TForm1 = class(TForm)
//    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    FNextViewer: HWND;
    FLastClipboardText: string;
    procedure WMChangeCBChain(var Msg: TWMChangeCBChain); message WM_CHANGECBCHAIN;
    procedure WMDrawClipboard(var Msg: TMessage); message WM_DRAWCLIPBOARD;
    procedure LogClipboardChange;
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FNextViewer := SetClipboardViewer(Handle);
  FLastClipboardText := '';
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  ChangeClipboardChain(Handle, FNextViewer);
end;

procedure TForm1.WMChangeCBChain(var Msg: TWMChangeCBChain);
begin
  if Msg.Remove = FNextViewer then
    FNextViewer := Msg.Next
  else if FNextViewer <> 0 then
    SendMessage(FNextViewer, WM_CHANGECBCHAIN, Msg.Remove, Msg.Next);

  Msg.Result := 0;
end;

procedure TForm1.WMDrawClipboard(var Msg: TMessage);
begin
  LogClipboardChange;

  if FNextViewer <> 0 then
    SendMessage(FNextViewer, WM_DRAWCLIPBOARD, 0, 0);
end;

procedure TForm1.LogClipboardChange;
var
  ClipboardText: string;
  LogFile: TextFile;
  LogFileName: string;
begin
  if Clipboard.HasFormat(CF_TEXT) then
  begin
    ClipboardText := Clipboard.AsText;

    // Only log if the clipboard text has changed
    if ClipboardText <> FLastClipboardText then
    begin
      FLastClipboardText := ClipboardText;

      LogFileName := ExtractFilePath(ParamStr(0)) + 'clipboard_log.txt';
      AssignFile(LogFile, LogFileName);

      if FileExists(LogFileName) then
        Append(LogFile)
      else
        Rewrite(LogFile);

      try
        WriteLn(LogFile, FormatDateTime('yyyy-mm-dd hh:nn:ss', Now) + ' - ' + ClipboardText);
        Memo1.Lines.Add('Logged: ' + ClipboardText);
      finally
        CloseFile(LogFile);
      end;
    end;
  end;
end;

end.

unit MainUnit;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Clipbrd;

type
  TForm1 = class(TForm)
//    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    FNextViewer: HWND;
    FLastClipboardText: string;
    procedure WMChangeCBChain(var Msg: TWMChangeCBChain); message WM_CHANGECBCHAIN;
    procedure WMDrawClipboard(var Msg: TMessage); message WM_DRAWCLIPBOARD;
    procedure LogClipboardChange;
  public
    { Public declarations }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  FNextViewer := SetClipboardViewer(Handle);
  FLastClipboardText := '';
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  ChangeClipboardChain(Handle, FNextViewer);
end;

procedure TForm1.WMChangeCBChain(var Msg: TWMChangeCBChain);
begin
  if Msg.Remove = FNextViewer then
    FNextViewer := Msg.Next
  else if FNextViewer <> 0 then
    SendMessage(FNextViewer, WM_CHANGECBCHAIN, Msg.Remove, Msg.Next);

  Msg.Result := 0;
end;

procedure TForm1.WMDrawClipboard(var Msg: TMessage);
begin
  LogClipboardChange;

  if FNextViewer <> 0 then
    SendMessage(FNextViewer, WM_DRAWCLIPBOARD, 0, 0);
end;

procedure TForm1.LogClipboardChange;
var
  ClipboardText: string;
  LogFile: TextFile;
  LogFileName: string;
begin
  if Clipboard.HasFormat(CF_TEXT) then
  begin
    ClipboardText := Clipboard.AsText;

    // Only log if the clipboard text has changed
    if ClipboardText <> FLastClipboardText then
    begin
      FLastClipboardText := ClipboardText;

      LogFileName := ExtractFilePath(ParamStr(0)) + 'clipboard_log.txt';
      AssignFile(LogFile, LogFileName);

      if FileExists(LogFileName) then
        Append(LogFile)
      else
        Rewrite(LogFile);

      try
        WriteLn(LogFile, FormatDateTime('yyyy-mm-dd hh:nn:ss', Now) + ' - ' + ClipboardText);
        Memo1.Lines.Add('Logged: ' + ClipboardText);
      finally
        CloseFile(LogFile);
      end;
    end;
  end;
end;

end.