unit Unit1;

SysUtils, Classes,

Windows, Messages, Graphics, Controls, Forms, Dialogs,

StdCtrls, ExtCtrls, ComCtrls,

PythonEngine, PythonGUIInputOutput, WrapDelphi, ActnList, System.Actions;

TForm1 = class(TForm)

Splitter1: TSplitter;

Memo1: TMemo;

PyEngine: TPythonEngine;

PythonModule: TPythonModule;

Panel1: TPanel;

Button1: TButton;

PythonGUIInputOutput1: TPythonGUIInputOutput;

Memo2: TMemo;

ActionList1: TActionList;

actTest: TAction;

procedure Button1Click(Sender: TObject);

procedure FormCreate(Sender: TObject);

procedure PythonModuleEvents0Execute(Sender: TObject; PSelf,

Args: PPyObject; var Result: PPyObject);

procedure actTestExecute(Sender: TObject);

private

public

PyDelphiWrapper : TPyDelphiWrapper;

end;

Form1: TForm1;

TypInfo,

ObjAuto,

Variants,

VarPyth,

WrapDelphiVCL;

TTestBase = class

fdouble : double;

function DoubleDValue : double; // not visible in subclasses

property DValue : Double read fdouble write fdouble; // will be visible in subclasses

end;

function TTestBase.DoubleDValue : double;

Result := 2 * fdouble;

end;

TTestClass = class(TTestBase, IFreeNotification, IInterface)

fSValue : string;

fIValue : integer;

fSL : TStrings;

fOnChange: TNotifyEvent;

fFreeNotifImpl : IFreeNotification;

// implementation of interface IUnknown

function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;

function _AddRef: Integer; stdcall;

function _Release: Integer; stdcall;

property FreeNotifImpl : IFreeNotification read fFreeNotifImpl implements IFreeNotification;

constructor Create;

destructor Destroy; override;

procedure SetMeUp(S: string; I : Integer);

function DescribeMe(): string;

procedure TriggerChange;

property SL : TStrings read fSL;

property SValue : string read fSValue write fSValue;

property IValue : integer read fIValue write fIValue;

property OnChange : TNotifyEvent read fOnChange write fOnChange;

end;

constructor TTestClass.Create;

inherited;

fFreeNotifImpl := TFreeNotificationImpl.Create(Self);

fSL := TStringList.Create;

fSL.AddObject('Form1', Form1);

fSL.AddObject('Form1.Button1', Form1.Button1);

end;

destructor TTestClass.Destroy;

fSL.Free;

inherited;

end;

procedure TTestClass.SetMeUp(S: string; I : Integer);

SValue := S;

IValue := I;

end;

function TTestClass.Describeme() : string;

Result := fSValue + ' : ' + IntToStr(IValue);

end;

procedure TTestClass.TriggerChange;

if Assigned(fOnChange) then

fOnChange(Self);

end;

function TTestClass._AddRef: Integer;

Result := -1; // we don't want reference counting

end;

function TTestClass._Release: Integer;

Result := -1; // we don't want reference counting

end;

function TTestClass.QueryInterface(const IID: TGUID; out Obj): HResult;

if GetInterface(IID, Obj) then

Result := 0

else

Result := E_NOINTERFACE;

end;

TFruit = (Apple, Banana, Orange);

TFruits = set of TFruit;

TTestRTTIAccess = class

FFruit: TFruit;

FFruits: TFruits;

FruitField :TFruit;

FruitsField: TFruits;

StringField: string;

DoubleField: double;

ObjectField : TObject;

procedure BuyFruits(AFruits: TFruits);

procedure SetFormCaption(Form: TForm; ACaption: string);

property Fruit: TFruit read FFruit write FFruit;

property Fruits: TFruits read FFruits write FFruits;

end;

procedure TForm1.Button1Click(Sender: TObject);

p : PPyObject;

actTest.OnExecute := actTestExecute;

// Wrap the Form itself.

p := PyDelphiWrapper.Wrap(Self);

PythonModule.SetVar( 'MainForm', p );

PyEngine.Py_DecRef(p);

// Now wrap the an instance our TestClass

// This time we would like the object to be destroyed when the PyObject

// is destroyed, so we need to set its Owned property to True;

p := PyDelphiWrapper.Wrap(TTestClass.Create, soOwned);

PythonModule.SetVar( 'DVar', p );

PyEngine.Py_DecRef(p);

// Then wrap the an instance our TTestRTTIAccess

// It will allow us to to test access to public fields and methods as well

// public (as well as published) properties.

// This time we would like the object to be destroyed when the PyObject

// is destroyed, so we need to set its Owned property to True;

p := PyDelphiWrapper.Wrap(TTestRTTIAccess.Create, soOwned);

PythonModule.SetVar( 'rtti_var', p );

PyEngine.Py_DecRef(p);

p := PyEngine.PyInt_FromLong(Trunc(System.CompilerVersion));

PythonModule.SetVar( 'DelphiVersion', p );

PyEngine.Py_DecRef(p);

// Excecute the script

PyEngine.CheckError;

PyEngine.ExecStrings( memo1.Lines );

end;

procedure TForm1.FormCreate(Sender: TObject);

PyDelphiWrapper := TPyDelphiWrapper.Create(Self); // no need to destroy

PyDelphiWrapper.Engine := PyEngine;

PyDelphiWrapper.Module := PythonModule;

PyDelphiWrapper.Initialize; // Should only be called if PyDelphiWrapper is created at run time

end;

procedure TForm1.PythonModuleEvents0Execute(Sender: TObject; PSelf,

Args: PPyObject; var Result: PPyObject);

ShowMessage(VarPythonCreate(Args).GetItem(0));

Result := PyEngine.ReturnNone;

end;

procedure TForm1.actTestExecute(Sender: TObject);

Memo2.Lines.Add('Delphi event actTestExecute fired');

Import('spam').DVar.IValue := 1;

end;

procedure TTestRTTIAccess.BuyFruits(AFruits: TFruits);

Fruits := AFruits;

end;

procedure TTestRTTIAccess.SetFormCaption(Form: TForm; ACaption: string);

Form.Caption := 'From TTestRTTIAccess';

end;

ReportMemoryLeaksOnShutdown := DebugHook <> 0;

end.