Legal question

[andre2007]

Dear Embarcadero,
Similiar to DelphiFMX4Python I build an API to make use of Delphi FMX from the D Programming Language

https://github.com/andre2007/delta-core-10-2-1
https://github.com/andre2007/delta-fmx-10-2-1

Sample

import delta.core;
import System.Classes, System.UITypes, System.Types, FMX.Forms, FMX.Memo, FMX.Types;

void main()
{
    deltaLibrary.load(`.\views\Win32\Debug\Project1.dll`);
    
    Application.Initialize;
    Application.MainForm = TCustomForm.CreateNew(Application);
    Application.MainForm.Caption = "Sample";
    
    auto memo = TMemo.Create(Application.MainForm);
    memo.Lines.Add("Hello World!");
    memo.Align = TAlignLayout.Client;
    memo.Parent = Application.MainForm;

    Application.MainForm.Show();
    Application.Run();
}

No binary artifact (Dll containing FMX code) is distributed on the Github repository but an user of the repository needs to compile itself a DLL using an official Delphi IDE.

Dll sample source

library Project1;

{$STRONGLINKTYPES ON}

uses
  System.SysUtils,
  System.Classes,
  System.Types,
  System.UiTypes,
  FMX.Forms,
  FMX.Types,
  FMX.Memo,
  FMX.Graphics,
  Delta.Methods,
  Delta.Properties,
  Delta.System.Classes,
  Delta.FMX.Forms,
  Delta.FMX.Objects,
  Delta.FMX.Controls;

{$R *.res}

begin
end.

But the repository contains D wrapper classes for Delphi classes like
https://github.com/andre2007/delta-core-10-2-1/blob/master/source/System/Classes.d
https://github.com/andre2007/delta-fmx-10-2-1/blob/master/source/FMX/Graphics.d

module FMX.ActnList;

import delta.core;
import System.Actions;
import System.Classes: TComponent;

class TCustomActionList: TContainedActionList
{
 mixin!DelphiClass("FMX.ActnList.TCustomActionList");
}

class TActionList: TCustomActionList
{
	mixin!DelphiClass("FMX.ActnList.TActionList")
	
	static TActionList Create(TComponent owner);
}

The mixin template generates the method bodies automatically based on the signatures.

Do you see any legal issue with providing this API and especially providing D wrapper classes for Delphi System/FMX classes on the Github repository?

Also the question when I want to ship an application, I have to distribute the compiled Delphi DLL as part of my application (like https://github.com/andre2007/delta-fmx-10-2-1/blob/master/examples/gui_custom_form/views/Project1.dpr). Do you see any legal issue here?

Kind regards
Andre

[lmbelo]

Check out the "2.2.6.4 - Restrictions" and any further section:

https://www.embarcadero.com/products/rad-studio/rad-studio-eula

[andre2007]

Is my understanding right, that I should not open source the 2 repositories but it is OK to use the approach for the closed source applications I want to sell?

My goal is to use Delphi (registered version) for creating the UI, while writing the majority of the application coding in D.

[andre2007]

I set the repositories to private access to avoid any legal issues until clarification.

[pointermess]

Hi @andre2007,
your project sounds really interesting. Would you be willing to share at least how you achieved this? I would be very interested to try using the Firemonkey UI Framework in a small project written in Rust. Kind regards and happy new year! :)

[andre2007]

Hi @pointermess,
Thanks, I wish you also a happy new year. Currently I cutting the repositories into a pure framework repository, containing only uncritical source code (from a licence point of view). This repository will be publically available on github. I will leave a comment here, when I am finished.

The idea is, that you have a Delphi dll, containing only System/FMX uses statements. In addition you add 3 Delta units which exposes generic extern C functions to access Extended RTTI. This functions can be used to call instance/static methods (including constructors and destructors) and properties of Delphi components.

The Dll can be used from almost any language. Therefore on Rust side you just need wrapper classes for all Delphi components you want to use. The wrapper classes forwards the calls to the right Dll functions.
In sample above (TActionList) the code for calling the Dll functions is generated by the Mixin Template by introspecting the class.

But as already said by @lmbelo, publishing the FMX/System wrapper classes (Rust) is a legal issue. Therefore I keep this part closed source.

Unfortunately Embarcadero currently opened the door only for python, it would be great if it could be allowed for other languages too.

Kind regards
Andre

[lmbelo]

@andre2007 I really like the idea to take FMX to Rust.
I'll try to get you in touch with someone else that can help.

[andre2007]

@lmbelo
That sounds great. I assume in the end there will be a Delphi FMX Dll / SO with C interfaces which will be used by the Rust wrapper classes.
It would be great if you would allow that I create also wrapper classes for the D Programming Language and publish it under a license you are comfortable with.

You can find the source code of my 2 repositories here. The source code is under BSL, therefore you can do whatever you like with the code. The source code has some obvious issues, like it is architecture dependent (x86).

delta-fmx-10-2-1-master.zip
delta-core-10-2-1-master.zip

The interesting part for you in the source code are likely the Delphi units.
If you have questions, just ask.

[jimmckeeth]

I am interested in both D and Rust support with FMX and VCL..... I need to do some more research on how we can support you in these projects.

[andre2007]

In case your research is succesful, I have following proposal we can discuss. In the Embarcadero Github Organization a new repository e.g. DelphiFMXLib is created.

This repository has following content:

1. The shared library files for the different operation systems and architectures to be supported (win64 dll, win32 dll, linux 64 so, osx64 dylib, ...). This is the dynamic library file which contains stdcall functions/procedures to call static / instance methods and properties of Delphi classes. By specifying the units to be included (System.Classes, FMX.Forms, ...) you decide what should go in and what not.

2. You decide whether you want also to include the Delphi Source code of the DLL. The benefit of including it, is that it serves as technical information for the persons creating the Rust / D / ... wrapper coding. If you not including it, a small documentation file describing the DLL stdcall functions / procedures will also do it.

3. It would be fantastic if you could also add a machine readable file (preferable JSON) containing the Delphi classes for each unit with its public interfaces. That means, what is the super class of a class, which interfacess are implemented, what are the public properties (including its types and whether they are read / write or both). Also the public functions / producedures and its arguments...
   My assumption is you have s.th. like that and already used it for DelphiFMX4Python. In the end the language dependent wrapper coding needs to create for each Delphi class to be used, some wrapper code:
   e.g.

enum TShiftState {ssShift, ssAlt, ssCtrl, ssLeft, ssRight, ssMidldle, ssDouble, ssTouch, ssPen, ssCommand, ssHorizontal};

class TStrings: TPersistent
{
	mixin PascalClass!("System.Classes.TStrings");
	@property string Text();
	@property void Text(string value);
	
	int Add(string value);
	
	int AddObject(string value, TObject aObject);
	
	void Clear();
}

If there isn't something like that, it is not bad, but it would avoid a lot of manual work.

4. License file

Based on this repository wrapper for Rust and other languages could be easily build. In a separate Github repository I could then create the D wrapper coding. I copy the dynamic libraries and the API specification JSON into it. A generator script will create based on the API specification JSON the wrapper coding for D. Using a package manager and the online package repository (code.dlang.org) the package can be easily used by the community.
The same thing can be done by a Rust developer. To be precise, by having the dynamic libraries and the API specification JSON it could be used for any language.
You can decide whether you want to have the language dependent repositories (for Rust and D) in your Github Repository or if you want to have it Community driven and they are in there own organizations.

[lmbelo]

@andre2007 can we schedule a review of these projects next week?

[Priyatham10]

Yes, @andre2007 , Let us schedule a meet to review these projects once..

[andre2007]

@lmbelo @Priyatham10
Yes, we can schedule a meeting. My time zone is Berlin (UTC+1). Is your time zone Texas (UTC-6)?
Would be 9 am or 10 am Texas time ok for you?

[Priyatham10]

@andre2007, Yeah, I'll be available during the times you mentioned. We'll think of the day, and we can schedule a meeting.