x11rotation.pas

unit x11rotation;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, xlib, x, xrandr, unixtype;

type
  PXRRScreenChangeNotifyEvent = ^TXRRScreenChangeNotifyEvent;
  TXRRScreenChangeNotifyEvent = record
    _type: cint;
    serial: culong;
    send_event: TBool;
    display: PDisplay;
    window: TWindow;
    root: TWindow;
    timestamp: TTime;
    config_timestamp: TTime;
    size_index: cint;
    subpixel_order: cint;
    rotation: cuint;
    width: cint;
    height: cint;
    mwidth: cint;
    mheight: cint;
  end;

  TRotationEvent = procedure(Sender: TObject; IsPortrait: Boolean) of object;

  TX11Rotation = class;

  TRotationThread = class(TThread)
  private
    FOwner: TX11Rotation;
  protected
    procedure Execute; override;
  public
    constructor Create(AOwner: TX11Rotation);
  end;

  TX11Rotation = class
  private
    FDisplay: PDisplay;
    FWindow: TWindow;
    FScreen: cint;
    FRootWindow: TWindow;
    FRunning: Boolean;
    FRotationAtom: culong; // Use culong for Atom
    FOnRotation: TRotationEvent;
    FThread: TRotationThread;
    procedure HandleScreenChangeEvent(const Event: PXRRScreenChangeNotifyEvent);
  public
    constructor Create(AWindow: TWindow);
    destructor Destroy; override;
    procedure Start;
    procedure Stop;
    procedure SetRotationAtom(IsPortrait: Boolean);
    property OnRotation: TRotationEvent read FOnRotation write FOnRotation;
  end;

implementation

const
  XA_CARDINAL = 6;

constructor TX11Rotation.Create(AWindow: TWindow);
begin
  FDisplay := XOpenDisplay(nil);
  if FDisplay = nil then
    raise Exception.Create('Unable to open X display');

  FWindow := AWindow;
  FScreen := DefaultScreen(FDisplay);
  FRootWindow := RootWindow(FDisplay, FScreen);
  //FRotationAtom := XInternAtom(FDisplay, '_HILDON_PORTRAIT_MODE_SUPPORT', False);
  WriteLn('Initialized TX11Rotation');
end;

destructor TX11Rotation.Destroy;
begin
  Stop;
  inherited Destroy;
end;

procedure TX11Rotation.HandleScreenChangeEvent(const Event: PXRRScreenChangeNotifyEvent);
var
  IsPortrait: Boolean;
begin
  IsPortrait := Event^.rotation in [RR_Rotate_90, RR_Rotate_270];
  if Assigned(FOnRotation) then
    FOnRotation(Self, IsPortrait);
  //SetRotationAtom(IsPortrait);
  WriteLn('Rotation detected: ', IsPortrait);
end;

procedure TX11Rotation.SetRotationAtom(IsPortrait: Boolean);
var
  Value: LongInt;
begin
  if IsPortrait then
    Value := 1
  else
    Value := 0;
  //XChangeProperty(FDisplay, FRootWindow, FRotationAtom, XA_CARDINAL, 32, PropModeReplace, @Value, 1);
  WriteLn('Set rotation atom: ', Value);
end;

procedure TX11Rotation.Start;
begin
  if not FRunning then
  begin
    FRunning := True;
    FThread := TRotationThread.Create(Self);
    FThread.Start;
    WriteLn('Started listening for screen change events');
  end;
end;

procedure TX11Rotation.Stop;
begin
  if FRunning then
  begin
    FRunning := False;
    if Assigned(FThread) then
    begin
      FThread.Terminate; // Request thread to terminate
      FThread.WaitFor;
      FreeAndNil(FThread);
    end;
    XCloseDisplay(FDisplay);
    WriteLn('Stopped listening for screen change events');
  end;
end;

constructor TRotationThread.Create(AOwner: TX11Rotation);
begin
  inherited Create(True);
  FOwner := AOwner;
  FreeOnTerminate := False;
end;

procedure TRotationThread.Execute;
var
  Event: TXEvent;
  XRRNotifyEvent: PXRRScreenChangeNotifyEvent;
begin
  XRRSelectInput(FOwner.FDisplay, FOwner.FRootWindow, RRScreenChangeNotifyMask);
  WriteLn('Waiting for screen change events...');
  while not Terminated do
  begin
    if XPending(FOwner.FDisplay) > 0 then
    begin
      writeln ('aaaaaaa');
      XNextEvent(FOwner.FDisplay, @Event);
      if Event._type = RRScreenChangeNotify then
      begin
        writeln ('bbbbbbb');
        XRRNotifyEvent := PXRRScreenChangeNotifyEvent(@Event);
        FOwner.HandleScreenChangeEvent(XRRNotifyEvent);
      end;
    end;
    Sleep(100); // Add a small sleep to avoid busy waiting
  end;
end;

end.