System.ClickRecorder.Screenshot.Provider.pas

unit System.ClickRecorder.Screenshot.Provider;

interface

uses
 {$IFDEF MSWINDOWS}
  Vcl.Graphics,
  Vcl.Forms,
  Winapi.Windows,
 {$ENDIF}
 {$IFDEF MACOS}
  FMX.Graphics
 {$ENDIF}
  System.SysUtils;

type
  IClickRecorderScreenshotProvider = interface(IInvokable)
    ['{DB538C33-2820-4230-AC0B-54DC20D0EA79}']
    function DrawCursor(ADrawCursor: Boolean): IClickRecorderScreenshotProvider; overload;
    function DrawCursor: Boolean overload;

    function Monitor(AMonitor: Integer): IClickRecorderScreenshotProvider; overload;
    function Monitor(): Integer; overload;

    function IsRecording: Boolean;

    function TakeAScreenshot(APoint: TPoint): Vcl.Graphics.TBitmap;
  end;

  TClickRecorderScreenshotProvider = class(TInterfacedObject, IClickRecorderScreenshotProvider)
  strict private
    FIsRecording: Boolean;
    FScreenShotDrawCursor: Boolean;
    FScreenShotMonitor: Integer;  //  AMonitor: 0 = ALL screens, 1 = MAIN screen, 2 = ADDITIONAL screen
    FMousePoint: TPoint;
  private
    procedure DrawScreenCursor(var ABMP: Vcl.Graphics.TBitmap; const AMonitorID: Integer);
    function TakeScreenshot(var ABMP: Vcl.Graphics.TBitmap; AMonitorNumber: Integer): Boolean;
    function ScreenShot(ABMP: Vcl.Graphics.TBitmap; const ADrawCursor: Boolean; const AAMonitor: Integer): Boolean;
  public
    constructor Create();
    destructor Destroy; override;

    function DrawCursor(ADrawCursor: Boolean): IClickRecorderScreenshotProvider; overload;
    function DrawCursor: Boolean overload;

    function Monitor(AMonitor: Integer): IClickRecorderScreenshotProvider; overload;
    function Monitor(): Integer; overload;

    function IsRecording: Boolean;

    function TakeAScreenshot(APoint: TPoint): Vcl.Graphics.TBitmap;
  end;

implementation

uses
  System.IOUtils,
  Winapi.Messages;

{ TClickRecorderScreenshotProvider }

constructor TClickRecorderScreenshotProvider.Create;
begin
  inherited Create();
  FScreenShotDrawCursor := True;
  FScreenShotMonitor := 0;
end;

destructor TClickRecorderScreenshotProvider.Destroy;
begin
  //...
  inherited;
end;

function TClickRecorderScreenshotProvider.DrawCursor: Boolean;
begin
  Result := FScreenShotDrawCursor;
end;

function TClickRecorderScreenshotProvider.DrawCursor(ADrawCursor: Boolean): IClickRecorderScreenshotProvider;
begin
  FScreenShotDrawCursor :=  ADrawCursor;
  Result := Self;
end;

function TClickRecorderScreenshotProvider.Monitor: Integer;
begin
  Result := FScreenShotMonitor;
end;

function TClickRecorderScreenshotProvider.Monitor(AMonitor: Integer): IClickRecorderScreenshotProvider;
begin
  FScreenShotMonitor := AMonitor;
  Result := Self;
end;

procedure TClickRecorderScreenshotProvider.DrawScreenCursor(var ABMP: Vcl.Graphics.TBitmap; const AMonitorID: Integer);
var
  CanvasClipRect: TRect;
  CursorInfo: TCursorInfo;
  Icon: TIcon;
  IconInfo: TIconInfo;

  Mon: TMonitor;
  CPOffset: TPoint;
begin
  //  Mon := Screen.Monitors[AMonitorID];
  Mon := Screen.MonitorFromPoint(FMousePoint);  //  Detect the monitor under mouse point...

  CanvasClipRect := ABMP.Canvas.ClipRect;
  Icon := TIcon.Create;
  try
    //  MonitorID: 0=ALL screens, 1=MAIN screen, 2=ADDITIONAL screen, etc....
    //  https://docwiki.embarcadero.com/RADStudio/Florence/en/Handling_the_Screen
    CursorInfo.cbSize := SizeOf(CursorInfo);

    if GetCursorInfo(CursorInfo) then
    begin
      if (CursorInfo.Flags = CURSOR_SHOWING) then
      begin
        Icon.Handle := CopyIcon(CursorInfo.hCursor);
        if GetIconInfo(Icon.Handle, IconInfo) then
        begin
          CPOffset := CursorInfo.ptScreenPos;  //  Get Point from GetCursorPos or MonitorFromPoint...

          //  This calculation need it, because the primary monitor are right and the secondary are left.
          //  Then has the secondary negative values. Sample:
          //      0 =====  Bitmap is  ===== 4480
          //  -2560 ========== 0 ========== 1920
          //        ========x============== mouse click -1460 on secondary monitor
          //  Abs(-2560) - Abs(1460) = 1100 from left point 0 at bitmap
          //
          //        =================x===== mouse click 200 on primary monitor
          //  Abs(-2560) + 200 = 2760 from left point 0 at bitmap
          if (Mon.Left < 0) then
          begin
              CPOffset.X := Abs(Mon.Left) - Abs(FMousePoint.X);
          end
          else
          begin
            if (FMousePoint.X > 0) then
            begin
              var SumWidth := 0;
              for var Idx := 0 to Screen.MonitorCount - 1 do
              begin
                if (Screen.Monitors[Idx].Left < 0) then
                begin
                  SumWidth := SumWidth  + Abs(Screen.Monitors[Idx].Width);
                end;
              end;

              CPOffset.X := SumWidth + FMousePoint.X;
            end;

            //  CPOffset.Y := CPOffset.Y + M.Top;
          end;
        end;

        //  ABMP.Canvas.Draw((CPOffset.X - Integer(IconInfo.xHotspot) - CanvasClipRect.Left), (CPOffset.Y - Integer(IconInfo.yHotspot) - CanvasClipRect.Top), Icon);
        //  ABMP.Canvas.Draw((CursorInfo.ptScreenPos.X - IconInfo.xHotspot - CanvasClipRect.Left), (CursorInfo.ptScreenPos.Y - IconInfo.yHotspot - CanvasClipRect.Top), Icon);
        //  Sample to see it: ABMP.Canvas.Draw(2700, 200, Icon);
        //  ABMP.Canvas.Draw(CursorInfo.ptScreenPos.x - Integer(IconInfo.xHotspot) - R.Left, CursorInfo.ptScreenPos.y - Integer(IconInfo.yHotspot) - R.Top, Icon);
        ABMP.Canvas.Draw(CPOffset.X, CPOffset.Y, Icon);
      end;
    end;
  finally
    Icon.Free;
  end;
end;

function TClickRecorderScreenshotProvider.IsRecording: Boolean;
begin
  Result := FIsRecording;
end;

function TClickRecorderScreenshotProvider.TakeScreenshot(var ABMP: Vcl.Graphics.TBitmap;  AMonitorNumber: Integer): Boolean;
const
  CAPTUREBLT = $40000000;
var
  DesktopCanvas: TCanvas;
  DC: HDC;
  Left, Top: Integer;
begin
  Result := False;
  if (AMonitorNumber > Screen.MonitorCount) then
    Exit;

  DC := GetDC(0);
  try
    if (DC = 0) then
      Exit;

    if (AMonitorNumber = 0) then
    begin
      ABMP.Width := Screen.DesktopWidth;
      ABMP.Height := Screen.DesktopHeight;
      Left := Screen.DesktopLeft;
      Top := Screen.DesktopTop;
    end
    else
    begin
      ABMP.Width := Screen.Monitors[AMonitorNumber - 1].Width;
      ABMP.Height := Screen.Monitors[AMonitorNumber - 1].Height;
      Left := Screen.Monitors[AMonitorNumber - 1].Left;
      Top := Screen.Monitors[AMonitorNumber - 1].Top;
    end;

    DesktopCanvas := TCanvas.Create;

    try
      DesktopCanvas.Handle := DC;
      Result := BitBlt(ABMP.Canvas.Handle, 0, 0, ABMP.Width, ABMP.Height, DesktopCanvas.Handle, Left, Top, SRCCOPY or CAPTUREBLT);
      Result := True;
    finally
      DesktopCanvas.Free;
    end;
  finally
    if (DC <> 0) then
      ReleaseDC(0, DC);
  end;
end;

function TClickRecorderScreenshotProvider.ScreenShot(ABMP: Vcl.Graphics.TBitmap; const ADrawCursor: Boolean; const AAMonitor: Integer): Boolean;
begin
  Result := TakeScreenshot(ABMP, AAMonitor);

  if Result then
  begin
    if FScreenShotDrawCursor then
    begin
      DrawScreenCursor(ABMP, AAMonitor);
    end;
  end;
end;

function TClickRecorderScreenshotProvider.TakeAScreenshot(APoint: TPoint): Vcl.Graphics.TBitmap;
begin
  FMousePoint := APoint;
  Result := Vcl.Graphics.TBitmap.Create;
  ScreenShot(Result, FScreenShotDrawCursor, FScreenShotMonitor);
end;

end.