Normally one would use

git diff > todo.patch

But with Lazarus Pascal this would come with unwanted PO and POT (translation) files, and (under macOS anyway) lazarus.app and startlazarus.app (exclude sections).
Sometimes it also coms with unwanted white space which we'd like to exclude as well (-w option).

All options together this would make

git diff -- . ':(exclude)*.po' ':(exclude)*.pot' ':(exclude)lazarus.app' ':(exclude)startlazarus.app' -w > mychanges.patch

Running this in the Lazarus directory will create a nice and clean Diff file (for small changes).

Hope this is useful for others, at least a nice reminder for myself.

1. Check if the screen is locked or not with a simple one time call
2. With the system notifying my application that the lock state changed (so we do not have to poll if a screen is locked or not)

So for this I made a little unit - feel free to use/modify/etc:

unit t4a_macOS_ScreenLocked;

{$mode ObjFPC}{$H+}
{$modeswitch objectivec1}

interface

uses
  Classes, SysUtils, MacOSAll, Forms, process, CocoaAll, CocoaUtils;


type
  TScreenLockUnlockCallback = procedure(isScreenLocked:boolean) of object;

{ T4ALIB - Check if the screen is locked or not (eg. Login screen shows). }
function CheckIfScreenLocked: Boolean;


{ Use Notifications by system}
procedure ScreenLockCallback(Center: CFNotificationCenterRef;
                             Observer: Pointer;
                             Name: CFStringRef;
                             Object_: Pointer;
                             UserInfo: CFDictionaryRef); mwpascal;
procedure RegisterScreenLockNotifications(OptionalCallbackProcedure:TScreenLockUnlockCallback = nil);
procedure UnregisterScreenLockNotifications;

var
  ScreenIsLocked    : boolean; // used for notifications
  CallbackProcedure : TScreenLockUnlockCallback;

implementation

// Onetime call/check
function CheckIfScreenLocked: Boolean;
var
  SessionDict: CFDictionaryRef;
  ValueRef: CFTypeRef;
begin
  Result := False;

  SessionDict := CGSessionCopyCurrentDictionary;
  if SessionDict <> nil then
  begin
    if CFDictionaryGetValueIfPresent(
         SessionDict,
         CFSTR('CGSSessionScreenIsLocked'),
         @ValueRef
       ) then
    begin
      if CFGetTypeID(ValueRef) = CFBooleanGetTypeID then
        Result := CFBooleanGetValue(CFBooleanRef(ValueRef));
    end;

    CFRelease(SessionDict);
  end;

  ScreenIsLocked := Result;
end;

// Notification by system
procedure ScreenLockCallback(Center: CFNotificationCenterRef;
                             Observer: Pointer;
                             Name: CFStringRef;
                             Object_: Pointer;
                             UserInfo: CFDictionaryRef); mwpascal;
var
  NotificationName: String;
begin
  NotificationName := CFStringToString(Name);

  ScreenIsLocked := (NotificationName =  'com.apple.screenIsLocked') and
                    (NotificationName <> 'com.apple.screenIsUnlocked');

  if Assigned(CallbackProcedure) then CallbackProcedure(ScreenIsLocked);
end;

procedure RegisterScreenLockNotifications(OptionalCallbackProcedure:TScreenLockUnlockCallback = nil);
var
  Center: CFNotificationCenterRef;
begin
  CallbackProcedure := OptionalCallbackProcedure;

  Center := CFNotificationCenterGetDistributedCenter;

  CFNotificationCenterAddObserver(
    Center,
    nil, // observer
    @ScreenLockCallback,
    CFSTR('com.apple.screenIsLocked'),
    nil,
    CFNotificationSuspensionBehaviorDeliverImmediately
  );

  CFNotificationCenterAddObserver(
    Center,
    nil,
    @ScreenLockCallback,
    CFSTR('com.apple.screenIsUnlocked'),
    nil,
    CFNotificationSuspensionBehaviorDeliverImmediately
  );
end;

procedure UnregisterScreenLockNotifications;
var
  Center: CFNotificationCenterRef;
begin
  Center := CFNotificationCenterGetDistributedCenter;
  CFNotificationCenterRemoveObserver(Center, nil, nil, nil);
end;

finalization

  UnregisterScreenLockNotifications;

end.

Use:

1. One time check:

Just call "CheckIfScreenLocked", which returns TRUE if the screen is locked.

2. Using notifications:

- define a public function that can be called when the screen locked state changes:

// your own procedure
procdure TForm1.ScreenLockChanged(locked:boolean);   { public! }
begin
  if locked the writeln('locked');
end;  

- In the onCreate event of your form, activate the notification observer

procedure TForm1.FormCreate(Sender: TObject);
begin
   RegisterScreenLockNotifications(@ScreenLockChanged);
end;

(the observer will be unregistered automatically when your application closes, or you can call "UnregisterScreenLockNotifications")

Hope this is of use to someone out there 😉 

procedure BetterScaleImage(AWidth, AHeight: Integer; sourceImage:Timage);
var
  srcImg, destImg: TLazIntfImage;
  cnv: TLazCanvas;
  interp: TFPBaseInterpolation;
begin
  if sourceImage.Picture.Bitmap = nil then Exit;

  srcImg := sourceImage.Picture.Bitmap.CreateIntfImage;
  destImg := TLazIntfImage.CreateCompatible(srcImg, AWidth, AHeight);

  try
    cnv := TLazCanvas.Create(destImg);
    try
      interp := TFPBaseInterpolation.Create;
      try
        cnv.Interpolation := interp;
        cnv.StretchDraw(0, 0, AWidth, AHeight, srcImg);

        sourceImage.Picture.Bitmap.LoadFromIntfImage(destImg);

      finally
        interp.Free;
      end;
    finally
      cnv.Free;
    end;
  finally
    destImg.Free;
    srcImg.Free;
  end;
end;                        

After loading an image in your TImage, simply call BetterScaleImage(width,height,TImage) to scale it better.
Under Windows this will be a world of difference. 

Enjoy!

Preconditions:
Make sure you have assigned an icon to your application, in Project Options!
As a target I used a regular Timage, and the unit I'm working in does not need to be the main unit.

Code:

Image1.Picture.LoadFromResourceName(HINSTANCE, 'MAINICON'); // Grab icon from Application

This will load the main icon into "Image1".

So the project would still open under Windows correctly.
Opening it under macOS (not simultaneously of course) would give an error and the option to retry which then would crash the IDE.

In an attempt to debug this I used the Lazarus debug option:

./lazarus --debug-log=~/lazaruslog.txt

Note that I'm starting Lazarus from Terminal, and am using the "lazarus" binary - not the lazarus.app, and not startlazarus!

The resulting log file was rather useless, but ... Lazarus did open and fixed the LPI file once I saved and closed Lazarus again.

Now this is obviously not what the debug function is for, but it saved my project.
Just posting it here in case it is of use to anyone.

Note: this does not always work of course!

For example, let's say we have this list:

file 3.txt
file 2.txt
file 10.txt
file 9.txt
file 1.txt

Regular sorting would produce this:

file 1.txt
file 10.txt
file 2.txt
file 3.txt
file 9.txt

But that is not how we humans sort, we'd like to see (called "natural sort"):

file 1.txt
file 2.txt
file 3.txt
file 9.txt
file 10.txt

In case you have seen my QuickSort examples (for example this one - I'll add the code below), you'll see that we often use "StrIcomp" to compare 2 strings to see which one goes first. Unfortunately results in the wrong output I just showed. So I wrote a "drop in" replacement for this "NaturalCompare". Simply replace the StrIcomp with NaturalCompare and the QuickSort will now produce a natural sorted list.

function NaturalCompare(const S1, S2: string): Integer;
var
  I, J: Integer;
  N1, N2: Int64;
  C1, C2: Char;
begin
  I := 1;
  J := 1;

  while (I <= Length(S1)) and (J <= Length(S2)) do
  begin
    C1 := S1;
    C2 := S2;

    // If both characters are digits, compare numbers
    if (C1 in ) and (C2 in ) then
    begin
      N1 := 0;
      while (I <= Length(S1)) and (S1 in ) do
      begin
        N1 := N1 * 10 + Ord(S1) - Ord('0');
        Inc(I);
      end;

      N2 := 0;
      while (J <= Length(S2)) and (S2 in ) do
      begin
        N2 := N2 * 10 + Ord(S2) - Ord('0');
        Inc(J);
      end;

      if N1 <> N2 then
        Exit(N1 - N2);
    end
    else
    begin
      // Case-insensitive character compare
      C1 := UpCase(C1);
      C2 := UpCase(C2);

      if C1 <> C2 then
        Exit(Ord(C1) - Ord(C2));

      Inc(I);
      Inc(J);
    end;
  end;

  // If all equal so far, shorter string comes first
  Result := Length(S1) - Length(S2);
end;                                                           

Example QuickStort procedure:

procedure QuickSort(var A: TStringList);
  procedure Sort(L, R: Integer);
  var
    I, J: Integer;
    Y, X:string;
  begin
    I:= L; J:= R; X:= A;

    repeat
      // was:  while StrIcomp(pchar(A),pchar(X))<0 do inc(I);
      // was:  while StrIComp(pchar(X),pchar(A))<0 do dec(J); 

      while NaturalCompare(pchar(A),pchar(X))<0 do inc(I);
      while NaturalCompare(pchar(X),pchar(A))<0 do dec(J); 

      if I <= J then
        begin
          Y:= A; A:= A; A:= Y;
          inc(I); dec(J);
        end;
    until I > J;

    if L < J then Sort(L,J);
    if I < R then Sort(I,R);
  end;
begin
  Sort(0,A.Count-1);
end;

After having gone through numerous options, I found this to work under macOS/Cocoa (using FPC Trunk);

Originally this only worked under Windows, but it seems to work with Cocoa (with Lazarus 4.99 or newer - I am using trunk)

YourPanel.ControlStyle := YourPanel.ControlStyle -  + ;

As it took me quite a while to figure this one out: I hope this is helpful to someone 😊 

An About dialog is generated on the fly and called like so (assuming your application has Info.plist file in the .app bundle);

...
{$modeswitch objectivec1}
...
Uses ..., CocoaAll, ... ;
...

// Opendialog like so:
NSApp.orderFrontStandardAboutPanel(Nil);

...

Example:

There are a few requirements and options to make it work nice which require a proper Info.plist file in your App bundle (myapplication.app/Contents/Info.plist)

Things that go in the Info.plist file:

CFBundleIconFile - defines the Icon you'll see in the About dialog. This is also the icon used by your application, typically located in the Resources dir (something like: myapplication.app/Contents/Resources/myapplication.icns -> use "myapplication.icns"). If not defined, a generic icon will be displayed.

CFBundleName - which represents the Application Name as shown in the About dialof.

CFBundleShortVersionString - holds the version number (Version 1.2.3), and if missing it will probably display something generic like "1.0".

CFBundleVersion - Displays the build number between parentheses.

NSHumanReadableCopyright - holds the copyright name, eg. John Doe.

Something like this

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  ...
  <key>CFBundleIconFile</key>
  <string>TinyHTMLEditor.icns</string>
  <key>CFBundleName</key>
  <string>TinyHTMLEditor</string>
  <key>CFBundleShortVersionString</key>
  <string>1.0.0</string>
  <key>CFBundleVersion</key>
  <string>1</string>
  <key>NSHumanReadableCopyright</key>
  <string>Copyright 2025, Hans Luijten</string>
  ...
</dict>
</plist>

Optional Credits text:

Optionally you can create a Credits file in myapplication.app/Contents/Resources/.
This can be html (Credits.html), or RichText (Credits.rtf or Credits.rtfd - see documentation).

The file needs to sit in the Resources directory and this file can be capital sensitive (depending on the filesystem your Mac uses).

The Credits.html file can even hold links (unlike RichText files), something simple like this:

<center>
<p>
Developed with <a href="https://www.lazarus-ide.org/">Lazarus Pascal</a>
</p>
<strong>Support</strong>
<p>
Contact us for support at<br>
<a href="https://www.tweaking4all.com">www.Tweaking4All.com</a>
</p>
</center>

Note that at runtime, you can close the dialog, change the HTML and re-open the dialog again to see the changes.
No need to recompile or restart your Lazarus application 😊 

A simple unit I created for my own purposes, but maybe someone can use it as well:

unit t4a_macOS_XAttr;

{$mode ObjFPC}{$H+}

interface

uses
  SysUtils, ctypes, unixtype;

const
  // macOS extended attribute functions are in libc
  libc = 'c';

  function ReadXAttrInt(const FileName, AttrName: String): Integer;
  function WriteXAttrInt(const FileName, AttrName: String; const Value: Integer): Boolean;

function getxattr(path: PChar; name: PChar; value: Pointer; size: size_t; position: cuint; options: cint): ssize_t; cdecl; external libc name 'getxattr';
function setxattr(path: PChar; name: PChar; value: Pointer; size: size_t; position: cuint; options: cint): cint; cdecl; external libc name 'setxattr';

implementation

// Reads an integer extended attribute. Returns 0 if not found.
function ReadXAttrInt(const FileName, AttrName: String): Integer;
var
  Value: Integer;
  BytesRead: ssize_t;
begin
  FillChar(Value, SizeOf(Value), 0);
  BytesRead := getxattr(PChar(FileName), PChar(AttrName), @Value, SizeOf(Value), 0, 0);
  if BytesRead = -1 then
    Result := 0 // Attribute missing or error
  else
    Result := Value;
end;

// Writes an integer extended attribute.
function WriteXAttrInt(const FileName, AttrName: String; const Value: Integer): Boolean;
var
  Ret: cint;
begin
  Ret := setxattr(PChar(FileName), PChar(AttrName), @Value, SizeOf(Value), 0, 0);
  Result := (Ret = 0);
end;

end.  

Example on how to use this:

procedure TForm1.Button1Click(Sender: TObject);
var
  AttributeName: string;
  AttributeNumber, ReadBack: integer;
  Filename: string;
begin
  AttributeName := 'user.myattributename'; // usually starts with "user."
  AttributeNumber := 100;
  Filename := '/path/to/mydirectory'; // can be a directory or a file

  if WriteXAttrInt(Filename, AttributeName, AttributeNumber) then
    ShowMessage('Wrote attribute '+ AttributeName+ ' = '+ IntToStr(AttributeNumber))
  else
    ShowMessage('Failed to write attribute');

  ReadBack := ReadXAttrInt(Filename, AttributeName);
  ShowMessage('Read attribute '+ AttributeName+ ' = '+ IntToStr(ReadBack));
end;

Enjoy ....

// QuickSort array of string by string length
procedure QuickSortByLength(ListOfStrings: array of string; Start: integer = -1; Stop: Integer = -1);
var
  i, j, PivotLen: Integer;
  Pivot: string;
  Temp: string;
begin
  if (Start=-1) or (Stop=-1) then
    begin
      Start := 0;
      Stop  := Length(ListOfStrings)-1;
    end;

  i := Start;
  j := Stop;
  Pivot := ListOfStrings;
  PivotLen := Length(Pivot);

  repeat
    while Length(ListOfStrings) < PivotLen do Inc(i);
    while Length(ListOfStrings) > PivotLen do Dec(j);

    if i <= j then
      begin
        Temp := ListOfStrings;
        ListOfStrings := ListOfStrings;
        ListOfStrings := Temp;
        Inc(i);
        Dec(j);
      end;
  until i > j;

  if Start < j then QuickSortByLength(ListOfStrings, Start, j);
  if i < Stop then QuickSortByLength(ListOfStrings, i, Stop);
end;    

I did write it so that when you pass only an array, it will sort the entire array.

Calling this function:

...
var
   MyStrings : array of string;
...

// sort entire list automatically
QuickSortByLength(MyStrings);
...

// sort entire list manually
QuickSortByLength(MyStrings, 0, length(MyStrings)-1);
...

// sort only a section
QuickSortByLength(MyStrings, 5, 10);
...