Minor fixes + Added all the RUTIS shit

Projects/RUTIS Wrappers/main.pas

@@ -29,7 +29,7 @@ type
   public
     { public declarations }
   end; 
-procedure ConvertRT(Input, Dbg, Output : TStrings);
+procedure ConvertRT(Input, Dbg, Output : TStrings; procnames : TStrings = nil);
 var
   frmMain: TfrmMain;
 
@@ -42,7 +42,7 @@ uses
 
 { TfrmMain }
 
-procedure ConvertRT(Input, Dbg, Output : TStrings);
+procedure ConvertRT(Input, Dbg, Output : TStrings; procnames : TStrings = nil);
   procedure Debug(s: string); overload;
   begin
     if (Trim(Output.Text) <> '') then
@@ -69,12 +69,29 @@ procedure ConvertRT(Input, Dbg, Output : TStrings);
     Write(string(v));
   end;
 
+  function FixName( str : string) : string;
+  begin
+    if (length(str) > 3) and (str[1] = 'p') and (str[2] = 's') and (str[3] = '_') then
+      result := Copy(str,4,length(str)-3);
+  end;
+
+  function PtrName ( str : string) : String;
+  begin
+    debug(str);
+    if (length(str) > 1) and (str[1] in ['T','t']) then
+      result := 'P' + copy(str,2,length(str)-1)
+    else
+      result := 'P' + str;
+    debug(result);
+  end;
+
 var
   p: TCodeParser;
   m: TMemoryStream;
   a, b, c: TDeclarationArray;
   i, ii, iii, pc: Integer;
   s: string;
+  rutiss,tmp : string;
   d: TDeclaration;
   Fail: Boolean;
 begin
@@ -106,19 +123,24 @@ begin
           Continue;
         end;
 
-        s := 'procedure _RUTIS_'+Name.ShortText+
+        s := 'procedure RUTIS_'+Name.ShortText+
-          '(Stack: TRutisStack; Params: PRutisParamInfoArray; Result: PRutisParamInfo);'+LineEnding+
+          '(Params: PRutisParamInfoArray; Result: PRutisParamInfo);'+LineEnding+
           'begin'+LineEnding+'  ';
 
         d := Items.GetFirstItemOfClass(TciReturnType);
         if (d <> nil) then
-          s := s+'P'+d.ShortText+'(Result^.Data)^ := ';
+        begin
+          s := s+PtrName(d.ShortText)+'(Result^.Data)^ := ';
+          rutiss := 'RutisEngine.RegExtMethod(''%s'',%s, [%s], '''+d.CleanText +''');';
+        end else
+          rutiss := 'RutisEngine.RegExtMethod(''%s'',%s, [%s], '''');';
 
         s := s+Name.ShortText+'(';
 
         pc := 0;
         Fail := False;
         b := GetParamDeclarations();
+        tmp := '';
         for ii := 0 to High(b) do
         begin
           d := b[ii].Items.GetFirstItemOfClass(TciParameterType);
@@ -141,10 +163,13 @@ begin
           begin
             if (pc > 0) then
               s := s+', ';
-            s := s+'P'+d.ShortText+'(Params^['+IntToStr(pc)+'].Data)^';
+            s := s+PtrName(d.ShortText)+'(Params^['+IntToStr(pc)+'].Data)^';
+            tmp := tmp + #39 + d.ShortText + #39 +',';
             Inc(pc);
           end;
         end;
+        if tmp <> '' then
+          setlength(tmp,length(tmp)-1);
 
         if Fail then
           Continue;
@@ -153,7 +178,11 @@ begin
         if (i > 0) then
           s := LineEnding+s;
         Write(s);
+        rutiss := Format(rutiss,[FixName(name.ShortText),'@RUTIS_' + name.ShortText,tmp]);
+        if procnames <> nil then
+          procnames.Add(rutiss);
         Debug('Done "'+Name.ShortText+'"!');
+        Debug('Prog-name "' + rutiss + '"');
       end;
   finally
     m.Free;

Projects/RUTIS Wrappers/wrapfiles.lfm

@@ -29,9 +29,9 @@ object WrapFilesForm: TWrapFilesForm
     TabOrder = 1
   end
   object SaveDirEdit: TDirectoryEdit
-    Left = 200
+    Left = 192
     Height = 21
-    Top = 16
+    Top = 20
     Width = 152
     ShowHidden = False
     ButtonWidth = 23
@@ -40,7 +40,7 @@ object WrapFilesForm: TWrapFilesForm
     TabOrder = 2
   end
   object SaveDirLabel: TLabel
-    Left = 120
+    Left = 104
     Height = 14
     Top = 20
     Width = 78
@@ -48,7 +48,7 @@ object WrapFilesForm: TWrapFilesForm
     ParentColor = False
   end
   object wrpBtn: TButton
-    Left = 472
+    Left = 568
     Height = 25
     Top = 16
     Width = 75
@@ -64,6 +64,27 @@ object WrapFilesForm: TWrapFilesForm
     Anchors = [akRight, akBottom]
     TabOrder = 4
   end
+  object FileNameEdit1: TFileNameEdit
+    Left = 448
+    Height = 21
+    Top = 20
+    Width = 80
+    DialogOptions = []
+    FilterIndex = 0
+    HideDirectories = False
+    ButtonWidth = 23
+    NumGlyphs = 0
+    MaxLength = 0
+    TabOrder = 5
+  end
+  object Label1: TLabel
+    Left = 383
+    Height = 14
+    Top = 25
+    Width = 57
+    Caption = 'MethodFile:'
+    ParentColor = False
+  end
   object FileDialog: TOpenDialog
     Filter = 'Include files (*.inc)|*.inc|All files (*.*)|*.*'
     Options = [ofAllowMultiSelect, ofFileMustExist, ofEnableSizing, ofViewDetail]

Projects/RUTIS Wrappers/wrapfiles.pas

@@ -14,6 +14,8 @@ type
 
   TWrapFilesForm = class(TForm)
     dbgMemo: TMemo;
+    FileNameEdit1: TFileNameEdit;
+    Label1: TLabel;
     wrpBtn: TButton;
     SaveDirEdit: TDirectoryEdit;
     FileButton: TButton;
@@ -62,7 +64,7 @@ procedure TWrapFilesForm.wrpBtnClick(Sender: TObject);
 
 var
   i : integer;
-  Input, Output : TStringList;
+  Input, Output,Procnames : TStringList;
   NewFile : string;
   YesToAll, NoToAll : boolean;
 begin
@@ -78,6 +80,7 @@ begin
     dbg('No files loaded');
     exit;
   end;
+  Procnames := TStringList.Create;
   for i := 0 to FileBox.Items.Count - 1 do
   begin
     if not FileExists(filebox.items[i]) then
@@ -99,13 +102,14 @@ begin
                     end;
         mrYesToAll : YesToAll:= true;
       end;
+      dbg(BoolToStr(YesToAll,true));
     end;
     dbg(NewFile);
     try
       Input := TStringList.Create;
       Input.LoadFromFile(filebox.items[i]);
       Output :=  TStringList.Create;
-      ConvertRT(Input,dbgMemo.Lines,Output);
+      ConvertRT(Input,dbgMemo.Lines,Output,Procnames);
       Output.SaveToFile(NewFile);
       Input.free;
       Output.free;
@@ -113,6 +117,10 @@ begin
       dbg('Something went wrong');
     end;
   end;
+  dbg(Procnames.Text);
+  if FileNameEdit1.Text <> '' then
+    Procnames.SaveToFile(FileNameEdit1.text);
+  Procnames.Free;
 end;
 
 end.

Projects/Simba/simbaunit.lfm

@@ -2995,15 +2995,15 @@ object SimbaForm: TSimbaForm
       OnUpdate = ActionExtensionsUpdate
     end
     object ActionPascalScript: TAction
-      Caption = 'ActionPascalScript'
+      Caption = 'PascalScript'
       OnExecute = ActionPascalScriptExecute
     end
     object ActionRUTIS: TAction
-      Caption = 'ActionRUTIS'
+      Caption = 'RUTIS'
       OnExecute = ActionRUTISExecute
     end
     object ActionCPascal: TAction
-      Caption = 'ActionCPascal'
+      Caption = 'CPascal'
       Enabled = False
       OnExecute = ActionCPascalExecute
     end

Units/MMLAddon/PSInc/psexportedmethods.inc

@@ -22,6 +22,7 @@
 }
 
 {$IFNDEF MML_EXPORT_THREADSAFE}
+AddFunction(@CallProc,'function CallProc(ProcName: string; var V: TVariantArray): Variant;');
 AddFunction(@ThreadSafeCall,'function ThreadSafeCall(ProcName: string; var V: TVariantArray): Variant;');
 AddFunction(@pswriteln,'procedure Writeln(x: string);'); //PS defines a special, keep this for CPascal
 AddFunction(@ps_debugln,'procedure DebugLn(str : string);');

Units/MMLAddon/RTInc/bitmap.inc

@@ -0,0 +1,254 @@
+procedure RUTIS_ps_CreateBitmapString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_CreateBitmapString(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetMufasaBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PMufasaBitmap(Result^.Data)^ := ps_GetMufasaBitmap(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_CreateBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_CreateBitmap(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_FreeBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FreeBitmap(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SaveBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SaveBitmap(Pinteger(Params^[0].Data)^, Pstring(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_BitmapFromString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_BitmapFromString(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pstring(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_LoadBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_LoadBitmap(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SetBitmapSize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetBitmapSize(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_StretchBitmapResize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_StretchBitmapResize(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_GetBitmapSize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_GetBitmapSize(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_SetBitmapName(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetBitmapName(Pinteger(Params^[0].Data)^, Pstring(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_CreateMirroredBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_CreateMirroredBitmap(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_CreateMirroredBitmapEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_CreateMirroredBitmapEx(Pinteger(Params^[0].Data)^, PBmpMirrorStyle(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_FastGetPixel(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PLongWord(Result^.Data)^ := ps_FastGetPixel(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_FastGetPixels(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PIntegerArray(Result^.Data)^ := ps_FastGetPixels(Pinteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_GetBitmapAreaColors(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  P2DIntArray(Result^.Data)^ := ps_GetBitmapAreaColors(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_FastSetPixel(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FastSetPixel(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, PColor(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_FastSetPixels(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FastSetPixels(Pinteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PIntegerArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_DrawTPABitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_DrawTPABitmap(Pinteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_DrawATPABitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_DrawATPABitmap(Pinteger(Params^[0].Data)^, P2DPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_DrawATPABitmapEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_DrawATPABitmapEx(Pinteger(Params^[0].Data)^, P2DPointArray(Params^[1].Data)^, PIntegerArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_FastDrawClear(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FastDrawClear(Pinteger(Params^[0].Data)^, PColor(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_DrawBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_DrawBitmap(PInteger(Params^[0].Data)^, PCanvas(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_FastDrawTransparent(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FastDrawTransparent(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_SetTransparentColor(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetTransparentColor(Pinteger(Params^[0].Data)^, PColor(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_GetTransparentColor(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PColor(Result^.Data)^ := ps_GetTransparentColor(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_FastReplaceColor(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FastReplaceColor(PInteger(Params^[0].Data)^, PColor(Params^[1].Data)^, PColor(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_CopyClientToBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_CopyClientToBitmap(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_BitmapFromClient(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_BitmapFromClient(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_FindBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindBitmap(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_FindBitmapIn(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindBitmapIn(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+end;
+
+procedure RUTIS_ps_FindBitmapToleranceIn(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindBitmapToleranceIn(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^);
+end;
+
+procedure RUTIS_ps_FindBitmapSpiral(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindBitmapSpiral(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+end;
+
+procedure RUTIS_ps_FindBitmapsSpiralTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindBitmapsSpiralTolerance(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+end;
+
+procedure RUTIS_ps_FindBitmapSpiralTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindBitmapSpiralTolerance(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^, Pinteger(Params^[7].Data)^);
+end;
+
+procedure RUTIS_ps_RotateBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_RotateBitmap(PInteger(Params^[0].Data)^, PExtended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_Desaturate(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_Desaturate(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_InvertBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_InvertBitmap(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_CopyBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_CopyBitmap(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GreyScaleBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_GreyScaleBitmap(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_BrightnessBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_BrightnessBitmap(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ContrastBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_ContrastBitmap(Pinteger(Params^[0].Data)^, Pextended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_PosterizeBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_PosterizeBitmap(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_CreateMaskFromBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PMask(Result^.Data)^ := ps_CreateMaskFromBitmap(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_FindMaskTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindMaskTolerance(PMask(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+end;
+
+procedure RUTIS_ps_FindBitmapMaskTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindBitmapMaskTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+end;
+
+procedure RUTIS_ps_FindDeformedBitmapToleranceIn(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindDeformedBitmapToleranceIn(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^, PBoolean(Params^[9].Data)^, PExtended(Params^[10].Data)^);
+end;
+
+procedure RUTIS_ps_RectangleBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_RectangleBitmap(Pinteger(Params^[0].Data)^, PBox(Params^[1].Data)^, PColor(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_FloodFillBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FloodFillBitmap(Pinteger(Params^[0].Data)^, PPoint(Params^[1].Data)^, PColor(Params^[2].Data)^, PColor(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_CalculatePixelShift(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_CalculatePixelShift(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PBox(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_CalculatePixelTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pextended(Result^.Data)^ := ps_CalculatePixelTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PBox(Params^[2].Data)^, Pinteger(Params^[3].Data)^);
+end;

Units/MMLAddon/RTInc/colour.inc

@@ -0,0 +1,104 @@
+procedure RUTIS_ps_GetColor(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PColor(Result^.Data)^ := ps_GetColor(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_GetColorsWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_GetColorsWrap(PPointArray(Params^[0].Data)^, PIntegerArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_GetColors(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PIntegerArray(Result^.Data)^ := ps_GetColors(PPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_findcolor(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_findcolor(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^);
+end;
+
+procedure RUTIS_ps_findcolortoleranceOptimised(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_findcolortoleranceOptimised(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^, Pinteger(Params^[7].Data)^);
+end;
+
+procedure RUTIS_ps_findcolortolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_findcolortolerance(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pinteger(Params^[5].Data)^, Pinteger(Params^[6].Data)^, Pinteger(Params^[7].Data)^);
+end;
+
+procedure RUTIS_ps_FindColors(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindColors(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^);
+end;
+
+procedure RUTIS_ps_SetColorToleranceSpeed(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetColorToleranceSpeed(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetToleranceSpeed(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_GetToleranceSpeed();
+end;
+
+procedure RUTIS_ps_SetToleranceSpeed2Modifiers(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetToleranceSpeed2Modifiers(PExtended(Params^[0].Data)^, PExtended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_GetToleranceSpeed2Modifiers(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_GetToleranceSpeed2Modifiers(PExtended(Params^[0].Data)^, PExtended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_SimilarColors(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_SimilarColors(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_CountColor(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_CountColor(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_CountColorTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_CountColorTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^);
+end;
+
+procedure RUTIS_ps_FindColorsToleranceOptimised(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindColorsToleranceOptimised(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+end;
+
+procedure RUTIS_ps_FindColorsTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindColorsTolerance(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+end;
+
+procedure RUTIS_ps_FindColorSpiral(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindColorSpiral(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+end;
+
+procedure RUTIS_ps_FindColorSpiralTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindColorSpiralTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^);
+end;
+
+procedure RUTIS_ps_FindColorsSpiralTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_FindColorsSpiralTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PPointArray(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+end;
+
+procedure RUTIS_ps_FindColoredArea(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindColoredArea(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^);
+end;
+
+procedure RUTIS_ps_FindColoredAreaTolerance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindColoredAreaTolerance(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PInteger(Params^[7].Data)^, PInteger(Params^[8].Data)^);
+end;

Units/MMLAddon/RTInc/colourconv.inc

@@ -0,0 +1,4 @@
+procedure RUTIS_ps_ColorToRGB(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ColorToRGB(Pinteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^);
+end;

Units/MMLAddon/RTInc/dtm.inc

@@ -0,0 +1,79 @@
+procedure RUTIS_ps_FindDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindDTM(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+end;
+
+procedure RUTIS_ps_FindDTMs(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindDTMs(PInteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^);
+end;
+
+procedure RUTIS_ps_FindDTMRotatedAlternating(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindDTMRotatedAlternating(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, PExtended(Params^[9].Data)^, PExtended(Params^[10].Data)^);
+end;
+
+procedure RUTIS_ps_FindDTMRotatedSE(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindDTMRotatedSE(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, PExtended(Params^[9].Data)^, PExtended(Params^[10].Data)^);
+end;
+
+procedure RUTIS_ps_FindDTMsRotatedAlternating(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindDTMsRotatedAlternating(PInteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PExtended(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, P2DExtendedArray(Params^[9].Data)^);
+end;
+
+procedure RUTIS_ps_FindDTMsRotatedSE(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindDTMsRotatedSE(PInteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^, PInteger(Params^[5].Data)^, PExtended(Params^[6].Data)^, PExtended(Params^[7].Data)^, PExtended(Params^[8].Data)^, P2DExtendedArray(Params^[9].Data)^);
+end;
+
+procedure RUTIS_ps_SetDTMName(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetDTMName(Pinteger(Params^[0].Data)^, Pstring(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_DTMFromString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_DTMFromString(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_FreeDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FreeDTM(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PMDTM(Result^.Data)^ := ps_GetDTM(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_AddTSDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_AddTSDTM(PSDTM(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_AddDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_AddDTM(PMDTM(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_PrintDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_PrintDTM(PMDTM(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_MDTMToSDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PSDTM(Result^.Data)^ := ps_MDTMToSDTM(PMDTM(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SDTMToMDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PMDTM(Result^.Data)^ := ps_SDTMToMDTM(PSDTM(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_CreateDTMPoint(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PMDTMPoint(Result^.Data)^ := ps_CreateDTMPoint(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^, Pinteger(Params^[4].Data)^, Pboolean(Params^[5].Data)^);
+end;

Units/MMLAddon/RTInc/extensions.inc

@@ -0,0 +1,34 @@
+procedure RUTIS_ext_UnTar(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ext_UnTar(Pstring(Params^[0].Data)^, PStringArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ext_UnTarEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ext_UnTarEx(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^, Pboolean(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ext_DecompressBZip2(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ext_DecompressBZip2(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^, PCardinal(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ext_GetPage(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ext_GetPage(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ext_MessageDlg(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ext_MessageDlg(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^, PMsgDlgType(Params^[2].Data)^, PMsgDlgButtons(Params^[3].Data)^, PLongint(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ext_SDTMToMDTM(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PMDTM(Result^.Data)^ := ext_SDTMToMDTM(PSDTM(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ext_InputQuery(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ext_InputQuery(PString(Params^[0].Data)^, PString(Params^[1].Data)^, PString(Params^[2].Data)^);
+end;

Units/MMLAddon/RTInc/file.inc

@@ -0,0 +1,89 @@
+procedure RUTIS_ps_CreateFile(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_CreateFile(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_OpenFile(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_OpenFile(Pstring(Params^[0].Data)^, PBoolean(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_RewriteFile(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_RewriteFile(Pstring(Params^[0].Data)^, PBoolean(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_AppendFile(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_AppendFile(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_CloseFile(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_CloseFile(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_EndOfFile(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_EndOfFile(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_FileSize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PLongInt(Result^.Data)^ := ps_FileSize(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_ReadFileString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_ReadFileString(PInteger(Params^[0].Data)^, Pstring(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_WriteFileString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_WriteFileString(PInteger(Params^[0].Data)^, Pstring(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_SetFileCharPointer(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_SetFileCharPointer(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_FilePointerPos(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_FilePointerPos(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_FileExists(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FileExists(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_DirectoryExists(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_DirectoryExists(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_CreateDirectory(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_CreateDirectory(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_ForceDirectores(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_ForceDirectores(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetFiles(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PStringArray(Result^.Data)^ := ps_GetFiles(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_GetDirectories(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PStringArray(Result^.Data)^ := ps_GetDirectories(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_WriteINI(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_WriteINI(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^, Pstring(Params^[2].Data)^, Pstring(Params^[3].Data)^);
+end;

Units/MMLAddon/RTInc/internets.inc

@@ -0,0 +1,59 @@
+procedure RUTIS_ps_OpenWebPage(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_OpenWebPage(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetPage(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PString(Result^.Data)^ := ps_GetPage(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_InitializeHTTPClient(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_InitializeHTTPClient(PBoolean(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_FreeHTTPClient(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FreeHTTPClient(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetHTTPPage(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_GetHTTPPage(PInteger(Params^[0].Data)^, Pstring(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_SetHTTPUserAgent(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetHTTPUserAgent(PInteger(Params^[0].Data)^, Pstring(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_PostHTTPPage(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_PostHTTPPage(PInteger(Params^[0].Data)^, Pstring(Params^[1].Data)^, Pstring(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_PostHTTPPageEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_PostHTTPPageEx(PInteger(Params^[0].Data)^, Pstring(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ClearPostData(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ClearPostData(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_AddPostVariable(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_AddPostVariable(PInteger(Params^[0].Data)^, Pstring(Params^[1].Data)^, Pstring(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_GetRawHeaders(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_GetRawHeaders(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SetProxy(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetProxy(PInteger(Params^[0].Data)^, PString(Params^[1].Data)^, PString(Params^[2].Data)^);
+end;

Units/MMLAddon/RTInc/keyboard.inc

@@ -0,0 +1,29 @@
+procedure RUTIS_ps_KeyDown(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_KeyDown(PWord(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_KeyUp(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_KeyUp(PWord(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SendKeys(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SendKeys(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_PressKey(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_PressKey(PWord(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_isKeyDown(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_isKeyDown(PWord(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetKeyCode(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_GetKeyCode(Pchar(Params^[0].Data)^);
+end;

Units/MMLAddon/RTInc/math.inc

@@ -0,0 +1,84 @@
+procedure RUTIS_ps_round(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_round(Pextended(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_iAbs(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_iAbs(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_ceil(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_ceil(Pextended(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_pow(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pextended(Result^.Data)^ := ps_pow(Pextended(Params^[0].Data)^, Pextended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_Max(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_Max(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_Min(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_Min(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_MinE(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pextended(Result^.Data)^ := ps_MinE(Pextended(Params^[0].Data)^, Pextended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_MaxE(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pextended(Result^.Data)^ := ps_MaxE(Pextended(Params^[0].Data)^, Pextended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_Sqr(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pextended(Result^.Data)^ := ps_Sqr(Pextended(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_Point(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPoint(Result^.Data)^ := ps_Point(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_Distance(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_Distance(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pinteger(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_Hypot(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PExtended(Result^.Data)^ := ps_Hypot(PExtended(Params^[0].Data)^, PExtended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_RandomRange(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_RandomRange(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ArcTan2(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pextended(Result^.Data)^ := ps_ArcTan2(Pextended(Params^[0].Data)^, Pextended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_IncEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_IncEx(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_DecEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_DecEx(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_Factorial(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInt64(Result^.Data)^ := ps_Factorial(Plongword(Params^[0].Data)^);
+end;

Units/MMLAddon/RTInc/mouse.inc

@@ -0,0 +1,39 @@
+procedure RUTIS_ps_MoveMouse(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_MoveMouse(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ScrollMouse(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ScrollMouse(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_GetMousePos(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_GetMousePos(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ConvIntClickType(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PClickType(Result^.Data)^ := ConvIntClickType(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_HoldMouse(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_HoldMouse(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_ReleaseMouse(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ReleaseMouse(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_ClickMouse(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ClickMouse(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_IsMouseButtonDown(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_IsMouseButtonDown(Pinteger(Params^[0].Data)^);
+end;

Units/MMLAddon/RTInc/ocr.inc

@@ -0,0 +1,14 @@
+procedure RUTIS_ps_rs_GetUpText(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PString(Result^.Data)^ := ps_rs_GetUpText();
+end;
+
+procedure RUTIS_ps_rs_GetUpTextAt(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_rs_GetUpTextAt(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_BitmapFromText(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_BitmapFromText(PString(Params^[0].Data)^, PString(Params^[1].Data)^);
+end;

Units/MMLAddon/RTInc/other.inc

@@ -0,0 +1,34 @@
+{procedure RUTIS_MakeString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := MakeString(PPSVariantIFC(Params^[0].Data)^);
+end;}
+
+procedure RUTIS_writeln_(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  psWriteln(PString(Params^[0].Data)^);
+end;
+
+{procedure RUTIS_swap_(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := swap_(PPSExec(Params^[0].Data)^, PPSExternalProcRec(Params^[1].Data)^, PPSStack(Params^[2].Data)^, PPSStack(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ToStr_(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ToStr_(PPSExec(Params^[0].Data)^, PPSExternalProcRec(Params^[1].Data)^, PPSStack(Params^[2].Data)^, PPSStack(Params^[3].Data)^);
+end;}
+
+procedure RUTIS_ps_SetScriptProp(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_SetScriptProp(PSP_Property(Params^[0].Data)^, PVariantArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_GetScriptProp(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_GetScriptProp(PSP_Property(Params^[0].Data)^, PVariantArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_Wait(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_Wait(PInteger(Params^[0].Data)^);
+end;

Units/MMLAddon/RTInc/rtexportedmethods.inc

@@ -0,0 +1,280 @@
+RutisEngine.RegExtMethod('CreateBitmapString',@RUTIS_ps_CreateBitmapString, ['integer'], 'string');
+RutisEngine.RegExtMethod('GetMufasaBitmap',@RUTIS_ps_GetMufasaBitmap, ['integer'], 'TMufasaBitmap');
+RutisEngine.RegExtMethod('CreateBitmap',@RUTIS_ps_CreateBitmap, ['integer','integer'], 'integer');
+RutisEngine.RegExtMethod('FreeBitmap',@RUTIS_ps_FreeBitmap, ['integer'], '');
+RutisEngine.RegExtMethod('SaveBitmap',@RUTIS_ps_SaveBitmap, ['integer','string'], '');
+RutisEngine.RegExtMethod('BitmapFromString',@RUTIS_ps_BitmapFromString, ['integer','integer','string'], 'integer');
+RutisEngine.RegExtMethod('LoadBitmap',@RUTIS_ps_LoadBitmap, ['String'], 'integer');
+RutisEngine.RegExtMethod('SetBitmapSize',@RUTIS_ps_SetBitmapSize, ['integer','integer','integer'], '');
+RutisEngine.RegExtMethod('StretchBitmapResize',@RUTIS_ps_StretchBitmapResize, ['integer','integer','integer'], '');
+RutisEngine.RegExtMethod('GetBitmapSize',@RUTIS_ps_GetBitmapSize, ['integer','integer','integer'], '');
+RutisEngine.RegExtMethod('SetBitmapName',@RUTIS_ps_SetBitmapName, ['integer','string'], '');
+RutisEngine.RegExtMethod('CreateMirroredBitmap',@RUTIS_ps_CreateMirroredBitmap, ['integer'], 'integer');
+RutisEngine.RegExtMethod('CreateMirroredBitmapEx',@RUTIS_ps_CreateMirroredBitmapEx, ['integer','TBmpMirrorStyle'], 'integer');
+RutisEngine.RegExtMethod('FastGetPixel',@RUTIS_ps_FastGetPixel, ['integer','integer','integer'], 'LongWord');
+RutisEngine.RegExtMethod('FastGetPixels',@RUTIS_ps_FastGetPixels, ['integer','TPointArray'], 'TIntegerArray');
+RutisEngine.RegExtMethod('GetBitmapAreaColors',@RUTIS_ps_GetBitmapAreaColors, ['Integer','Integer','Integer','Integer','Integer'], 'T2DIntArray');
+RutisEngine.RegExtMethod('FastSetPixel',@RUTIS_ps_FastSetPixel, ['integer','integer','integer','TColor'], '');
+RutisEngine.RegExtMethod('FastSetPixels',@RUTIS_ps_FastSetPixels, ['integer','TPointArray','TIntegerArray'], '');
+RutisEngine.RegExtMethod('DrawTPABitmap',@RUTIS_ps_DrawTPABitmap, ['integer','TPointArray','integer'], '');
+RutisEngine.RegExtMethod('DrawATPABitmap',@RUTIS_ps_DrawATPABitmap, ['integer','T2DPointArray'], '');
+RutisEngine.RegExtMethod('DrawATPABitmapEx',@RUTIS_ps_DrawATPABitmapEx, ['integer','T2DPointArray','TIntegerArray'], '');
+RutisEngine.RegExtMethod('FastDrawClear',@RUTIS_ps_FastDrawClear, ['integer','TColor'], '');
+RutisEngine.RegExtMethod('DrawBitmap',@RUTIS_ps_DrawBitmap, ['Integer','TCanvas','Integer','Integer'], '');
+RutisEngine.RegExtMethod('FastDrawTransparent',@RUTIS_ps_FastDrawTransparent, ['Integer','Integer','Integer','Integer'], '');
+RutisEngine.RegExtMethod('SetTransparentColor',@RUTIS_ps_SetTransparentColor, ['integer','TColor'], '');
+RutisEngine.RegExtMethod('GetTransparentColor',@RUTIS_ps_GetTransparentColor, ['integer'], 'TColor');
+RutisEngine.RegExtMethod('FastReplaceColor',@RUTIS_ps_FastReplaceColor, ['Integer','TColor','TColor'], '');
+RutisEngine.RegExtMethod('CopyClientToBitmap',@RUTIS_ps_CopyClientToBitmap, ['Integer','Integer','Integer','Integer','Integer'], '');
+RutisEngine.RegExtMethod('BitmapFromClient',@RUTIS_ps_BitmapFromClient, ['Integer','Integer','Integer','Integer'], 'Integer');
+RutisEngine.RegExtMethod('FindBitmap',@RUTIS_ps_FindBitmap, ['integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapIn',@RUTIS_ps_FindBitmapIn, ['integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapToleranceIn',@RUTIS_ps_FindBitmapToleranceIn, ['integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapSpiral',@RUTIS_ps_FindBitmapSpiral, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapsSpiralTolerance',@RUTIS_ps_FindBitmapsSpiralTolerance, ['integer','Integer','Integer','TPointArray','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapSpiralTolerance',@RUTIS_ps_FindBitmapSpiralTolerance, ['integer','Integer','Integer','integer','integer','integer','integer','integer'], 'Boolean');
+RutisEngine.RegExtMethod('RotateBitmap',@RUTIS_ps_RotateBitmap, ['Integer','Extended'], 'Integer');
+RutisEngine.RegExtMethod('Desaturate',@RUTIS_ps_Desaturate, ['integer'], 'integer');
+RutisEngine.RegExtMethod('InvertBitmap',@RUTIS_ps_InvertBitmap, ['integer'], '');
+RutisEngine.RegExtMethod('CopyBitmap',@RUTIS_ps_CopyBitmap, ['integer'], 'integer');
+RutisEngine.RegExtMethod('GreyScaleBitmap',@RUTIS_ps_GreyScaleBitmap, ['integer'], 'integer');
+RutisEngine.RegExtMethod('BrightnessBitmap',@RUTIS_ps_BrightnessBitmap, ['integer','integer'], 'integer');
+RutisEngine.RegExtMethod('ContrastBitmap',@RUTIS_ps_ContrastBitmap, ['integer','extended'], 'integer');
+RutisEngine.RegExtMethod('PosterizeBitmap',@RUTIS_ps_PosterizeBitmap, ['integer','integer'], 'integer');
+RutisEngine.RegExtMethod('CreateMaskFromBitmap',@RUTIS_ps_CreateMaskFromBitmap, ['integer'], 'TMask');
+RutisEngine.RegExtMethod('FindMaskTolerance',@RUTIS_ps_FindMaskTolerance, ['TMask','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindBitmapMaskTolerance',@RUTIS_ps_FindBitmapMaskTolerance, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindDeformedBitmapToleranceIn',@RUTIS_ps_FindDeformedBitmapToleranceIn, ['integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Boolean','Extended'], 'Boolean');
+RutisEngine.RegExtMethod('RectangleBitmap',@RUTIS_ps_RectangleBitmap, ['integer','TBox','TColor'], '');
+RutisEngine.RegExtMethod('FloodFillBitmap',@RUTIS_ps_FloodFillBitmap, ['integer','TPoint','TColor','TColor'], '');
+RutisEngine.RegExtMethod('CalculatePixelShift',@RUTIS_ps_CalculatePixelShift, ['Integer','Integer','TBox'], 'integer');
+RutisEngine.RegExtMethod('CalculatePixelTolerance',@RUTIS_ps_CalculatePixelTolerance, ['Integer','Integer','TBox','integer'], 'extended');
+RutisEngine.RegExtMethod('GetColor',@RUTIS_ps_GetColor, ['integer','integer'], 'TColor');
+RutisEngine.RegExtMethod('GetColorsWrap',@RUTIS_ps_GetColorsWrap, ['TPointArray','TIntegerArray'], '');
+RutisEngine.RegExtMethod('GetColors',@RUTIS_ps_GetColors, ['TPointArray'], 'TIntegerArray');
+RutisEngine.RegExtMethod('findcolor',@RUTIS_ps_findcolor, ['integer','integer','integer','integer','integer','integer','integer'], 'boolean');
+RutisEngine.RegExtMethod('findcolortoleranceOptimised',@RUTIS_ps_findcolortoleranceOptimised, ['integer','integer','integer','integer','integer','integer','integer','integer'], 'boolean');
+RutisEngine.RegExtMethod('findcolortolerance',@RUTIS_ps_findcolortolerance, ['integer','integer','integer','integer','integer','integer','integer','integer'], 'boolean');
+RutisEngine.RegExtMethod('FindColors',@RUTIS_ps_FindColors, ['TPointArray','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('SetColorToleranceSpeed',@RUTIS_ps_SetColorToleranceSpeed, ['Integer'], '');
+RutisEngine.RegExtMethod('GetToleranceSpeed',@RUTIS_ps_GetToleranceSpeed, [], 'Integer');
+RutisEngine.RegExtMethod('SetToleranceSpeed2Modifiers',@RUTIS_ps_SetToleranceSpeed2Modifiers, ['Extended','Extended'], '');
+RutisEngine.RegExtMethod('GetToleranceSpeed2Modifiers',@RUTIS_ps_GetToleranceSpeed2Modifiers, ['Extended','Extended'], '');
+RutisEngine.RegExtMethod('SimilarColors',@RUTIS_ps_SimilarColors, ['integer','integer','integer'], 'boolean');
+RutisEngine.RegExtMethod('CountColor',@RUTIS_ps_CountColor, ['Integer','Integer','Integer','Integer','Integer'], 'Integer');
+RutisEngine.RegExtMethod('CountColorTolerance',@RUTIS_ps_CountColorTolerance, ['Integer','Integer','Integer','Integer','Integer','Integer'], 'Integer');
+RutisEngine.RegExtMethod('FindColorsToleranceOptimised',@RUTIS_ps_FindColorsToleranceOptimised, ['TPointArray','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColorsTolerance',@RUTIS_ps_FindColorsTolerance, ['TPointArray','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColorSpiral',@RUTIS_ps_FindColorSpiral, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColorSpiralTolerance',@RUTIS_ps_FindColorSpiralTolerance, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColorsSpiralTolerance',@RUTIS_ps_FindColorsSpiralTolerance, ['Integer','Integer','TPointArray','Integer','Integer','Integer','Integer','Integer','Integer'], 'boolean');
+RutisEngine.RegExtMethod('FindColoredArea',@RUTIS_ps_FindColoredArea, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindColoredAreaTolerance',@RUTIS_ps_FindColoredAreaTolerance, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('ColorToRGB',@RUTIS_ps_ColorToRGB, ['integer','Integer','Integer','Integer'], '');
+RutisEngine.RegExtMethod('FindDTM',@RUTIS_ps_FindDTM, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMs',@RUTIS_ps_FindDTMs, ['Integer','TPointArray','Integer','Integer','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMRotatedAlternating',@RUTIS_ps_FindDTMRotatedAlternating, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Extended','Extended','Extended','Extended'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMRotatedSE',@RUTIS_ps_FindDTMRotatedSE, ['Integer','Integer','Integer','Integer','Integer','Integer','Integer','Extended','Extended','Extended','Extended'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMsRotatedAlternating',@RUTIS_ps_FindDTMsRotatedAlternating, ['Integer','TPointArray','Integer','Integer','Integer','Integer','Extended','Extended','Extended','T2DExtendedArray'], 'Boolean');
+RutisEngine.RegExtMethod('FindDTMsRotatedSE',@RUTIS_ps_FindDTMsRotatedSE, ['Integer','TPointArray','Integer','Integer','Integer','Integer','Extended','Extended','Extended','T2DExtendedArray'], 'Boolean');
+RutisEngine.RegExtMethod('SetDTMName',@RUTIS_ps_SetDTMName, ['integer','string'], '');
+RutisEngine.RegExtMethod('DTMFromString',@RUTIS_ps_DTMFromString, ['String'], 'Integer');
+RutisEngine.RegExtMethod('FreeDTM',@RUTIS_ps_FreeDTM, ['Integer'], '');
+RutisEngine.RegExtMethod('GetDTM',@RUTIS_ps_GetDTM, ['Integer'], 'TMDTM');
+RutisEngine.RegExtMethod('AddTSDTM',@RUTIS_ps_AddTSDTM, ['TSDTM'], 'Integer');
+RutisEngine.RegExtMethod('AddDTM',@RUTIS_ps_AddDTM, ['TMDTM'], 'Integer');
+RutisEngine.RegExtMethod('PrintDTM',@RUTIS_ps_PrintDTM, ['TMDTM'], '');
+RutisEngine.RegExtMethod('MDTMToSDTM',@RUTIS_ps_MDTMToSDTM, ['TMDTM'], 'TSDTM');
+RutisEngine.RegExtMethod('SDTMToMDTM',@RUTIS_ps_SDTMToMDTM, ['TSDTM'], 'TMDTM');
+RutisEngine.RegExtMethod('CreateDTMPoint',@RUTIS_ps_CreateDTMPoint, ['integer','integer','integer','integer','integer','boolean'], 'TMDTMPoint');
+RutisEngine.RegExtMethod('CreateFile',@RUTIS_ps_CreateFile, ['string'], 'Integer');
+RutisEngine.RegExtMethod('OpenFile',@RUTIS_ps_OpenFile, ['string','Boolean'], 'Integer');
+RutisEngine.RegExtMethod('RewriteFile',@RUTIS_ps_RewriteFile, ['string','Boolean'], 'Integer');
+RutisEngine.RegExtMethod('AppendFile',@RUTIS_ps_AppendFile, ['string'], 'Integer');
+RutisEngine.RegExtMethod('CloseFile',@RUTIS_ps_CloseFile, ['Integer'], '');
+RutisEngine.RegExtMethod('EndOfFile',@RUTIS_ps_EndOfFile, ['Integer'], 'Boolean');
+RutisEngine.RegExtMethod('FileSize',@RUTIS_ps_FileSize, ['Integer'], 'LongInt');
+RutisEngine.RegExtMethod('ReadFileString',@RUTIS_ps_ReadFileString, ['Integer','string','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('WriteFileString',@RUTIS_ps_WriteFileString, ['Integer','string'], 'Boolean');
+RutisEngine.RegExtMethod('SetFileCharPointer',@RUTIS_ps_SetFileCharPointer, ['Integer','Integer','Integer'], 'Integer');
+RutisEngine.RegExtMethod('FilePointerPos',@RUTIS_ps_FilePointerPos, ['Integer'], 'Integer');
+RutisEngine.RegExtMethod('FileExists',@RUTIS_ps_FileExists, ['string'], 'Boolean');
+RutisEngine.RegExtMethod('DirectoryExists',@RUTIS_ps_DirectoryExists, ['string'], 'Boolean');
+RutisEngine.RegExtMethod('CreateDirectory',@RUTIS_ps_CreateDirectory, ['string'], 'boolean');
+RutisEngine.RegExtMethod('ForceDirectores',@RUTIS_ps_ForceDirectores, ['string'], 'boolean');
+RutisEngine.RegExtMethod('GetFiles',@RUTIS_ps_GetFiles, ['string','string'], 'TStringArray');
+RutisEngine.RegExtMethod('GetDirectories',@RUTIS_ps_GetDirectories, ['string'], 'TStringArray');
+RutisEngine.RegExtMethod('WriteINI',@RUTIS_ps_WriteINI, ['string','string','string','string'], '');
+RutisEngine.RegExtMethod('OpenWebPage',@RUTIS_ps_OpenWebPage, ['string'], '');
+RutisEngine.RegExtMethod('GetPage',@RUTIS_ps_GetPage, ['String'], 'String');
+RutisEngine.RegExtMethod('InitializeHTTPClient',@RUTIS_ps_InitializeHTTPClient, ['Boolean'], 'Integer');
+RutisEngine.RegExtMethod('FreeHTTPClient',@RUTIS_ps_FreeHTTPClient, ['Integer'], '');
+RutisEngine.RegExtMethod('GetHTTPPage',@RUTIS_ps_GetHTTPPage, ['Integer','string'], 'string');
+RutisEngine.RegExtMethod('SetHTTPUserAgent',@RUTIS_ps_SetHTTPUserAgent, ['Integer','string'], '');
+RutisEngine.RegExtMethod('PostHTTPPage',@RUTIS_ps_PostHTTPPage, ['Integer','string','string'], 'string');
+RutisEngine.RegExtMethod('PostHTTPPageEx',@RUTIS_ps_PostHTTPPageEx, ['Integer','string'], 'string');
+RutisEngine.RegExtMethod('ClearPostData',@RUTIS_ps_ClearPostData, ['Integer'], '');
+RutisEngine.RegExtMethod('AddPostVariable',@RUTIS_ps_AddPostVariable, ['Integer','string','string'], '');
+RutisEngine.RegExtMethod('GetRawHeaders',@RUTIS_ps_GetRawHeaders, ['Integer'], 'string');
+RutisEngine.RegExtMethod('SetProxy',@RUTIS_ps_SetProxy, ['Integer','String','String'], '');
+RutisEngine.RegExtMethod('KeyDown',@RUTIS_ps_KeyDown, ['Word'], '');
+RutisEngine.RegExtMethod('KeyUp',@RUTIS_ps_KeyUp, ['Word'], '');
+RutisEngine.RegExtMethod('SendKeys',@RUTIS_ps_SendKeys, ['string'], '');
+RutisEngine.RegExtMethod('PressKey',@RUTIS_ps_PressKey, ['Word'], '');
+RutisEngine.RegExtMethod('isKeyDown',@RUTIS_ps_isKeyDown, ['Word'], 'boolean');
+RutisEngine.RegExtMethod('GetKeyCode',@RUTIS_ps_GetKeyCode, ['char'], 'integer');
+RutisEngine.RegExtMethod('round',@RUTIS_ps_round, ['extended'], 'integer');
+RutisEngine.RegExtMethod('iAbs',@RUTIS_ps_iAbs, ['integer'], 'integer');
+RutisEngine.RegExtMethod('ceil',@RUTIS_ps_ceil, ['extended'], 'integer');
+RutisEngine.RegExtMethod('pow',@RUTIS_ps_pow, ['extended','extended'], 'extended');
+RutisEngine.RegExtMethod('Max',@RUTIS_ps_Max, ['integer','integer'], 'integer');
+RutisEngine.RegExtMethod('Min',@RUTIS_ps_Min, ['Integer','Integer'], 'Integer');
+RutisEngine.RegExtMethod('MinE',@RUTIS_ps_MinE, ['extended','extended'], 'extended');
+RutisEngine.RegExtMethod('MaxE',@RUTIS_ps_MaxE, ['extended','extended'], 'extended');
+RutisEngine.RegExtMethod('Sqr',@RUTIS_ps_Sqr, ['extended'], 'extended');
+RutisEngine.RegExtMethod('Point',@RUTIS_ps_Point, ['integer','integer'], 'TPoint');
+RutisEngine.RegExtMethod('Distance',@RUTIS_ps_Distance, ['integer','integer','integer','integer'], 'integer');
+RutisEngine.RegExtMethod('Hypot',@RUTIS_ps_Hypot, ['Extended','Extended'], 'Extended');
+RutisEngine.RegExtMethod('RandomRange',@RUTIS_ps_RandomRange, ['Integer','Integer'], 'Integer');
+RutisEngine.RegExtMethod('ArcTan2',@RUTIS_ps_ArcTan2, ['extended','extended'], 'extended');
+RutisEngine.RegExtMethod('IncEx',@RUTIS_ps_IncEx, ['integer','integer'], '');
+RutisEngine.RegExtMethod('DecEx',@RUTIS_ps_DecEx, ['integer','integer'], '');
+RutisEngine.RegExtMethod('Factorial',@RUTIS_ps_Factorial, ['longword'], 'Int64');
+RutisEngine.RegExtMethod('MoveMouse',@RUTIS_ps_MoveMouse, ['integer','integer'], '');
+RutisEngine.RegExtMethod('ScrollMouse',@RUTIS_ps_ScrollMouse, ['integer','integer','integer'], '');
+RutisEngine.RegExtMethod('GetMousePos',@RUTIS_ps_GetMousePos, ['integer','integer'], '');
+RutisEngine.RegExtMethod('Writeln',@RUTIS_writeln_, ['String'], '');
+RutisEngine.RegExtMethod('HoldMouse',@RUTIS_ps_HoldMouse, ['integer','integer','integer'], '');
+RutisEngine.RegExtMethod('ReleaseMouse',@RUTIS_ps_ReleaseMouse, ['integer','integer','integer'], '');
+RutisEngine.RegExtMethod('ClickMouse',@RUTIS_ps_ClickMouse, ['integer','integer','integer'], '');
+RutisEngine.RegExtMethod('IsMouseButtonDown',@RUTIS_ps_IsMouseButtonDown, ['integer'], 'boolean');
+RutisEngine.RegExtMethod('rs_GetUpText',@RUTIS_ps_rs_GetUpText, [], 'String');
+RutisEngine.RegExtMethod('rs_GetUpTextAt',@RUTIS_ps_rs_GetUpTextAt, ['integer','integer'], 'string');
+RutisEngine.RegExtMethod('BitmapFromText',@RUTIS_ps_BitmapFromText, ['String','String'], 'integer');
+RutisEngine.RegExtMethod('SetScriptProp',@RUTIS_ps_SetScriptProp, ['TSP_Property','TVariantArray'], 'boolean');
+RutisEngine.RegExtMethod('GetScriptProp',@RUTIS_ps_GetScriptProp, ['TSP_Property','TVariantArray'], 'boolean');
+RutisEngine.RegExtMethod('Wait',@RUTIS_ps_Wait, ['Integer'], '');
+RutisEngine.RegExtMethod('SetSettingValue',@RUTIS_ps_SetSettingValue, ['string','string'], 'boolean');
+RutisEngine.RegExtMethod('KeyIsSetting',@RUTIS_ps_KeyIsSetting, ['String'], 'Boolean');
+RutisEngine.RegExtMethod('KeyIsDirectory',@RUTIS_ps_KeyIsDirectory, ['String'], 'Boolean');
+RutisEngine.RegExtMethod('GetSettingValue',@RUTIS_ps_GetSettingValue, ['String'], 'String');
+RutisEngine.RegExtMethod('GetSettingValueDef',@RUTIS_ps_GetSettingValueDef, ['String','String'], 'String');
+RutisEngine.RegExtMethod('ListSettings',@RUTIS_ps_ListSettings, ['String','TStringArray'], 'boolean');
+RutisEngine.RegExtMethod('DeleteSetting',@RUTIS_ps_DeleteSetting, ['String'], 'Boolean');
+RutisEngine.RegExtMethod('DeleteSubSettings',@RUTIS_ps_DeleteSubSettings, ['String'], 'Boolean');
+RutisEngine.RegExtMethod('Capitalize',@RUTIS_ps_Capitalize, ['string'], 'string');
+RutisEngine.RegExtMethod('CompressString',@RUTIS_ps_CompressString, ['string'], 'string');
+RutisEngine.RegExtMethod('DecompressString',@RUTIS_ps_DecompressString, ['string'], 'string');
+RutisEngine.RegExtMethod('Base64Encode',@RUTIS_ps_Base64Encode, ['string'], 'string');
+RutisEngine.RegExtMethod('Base64Decode',@RUTIS_ps_Base64Decode, ['string'], 'string');
+RutisEngine.RegExtMethod('BoolToStr',@RUTIS_ps_BoolToStr, ['boolean'], 'string');
+RutisEngine.RegExtMethod('Replace',@RUTIS_ps_Replace, ['string','string','string','TReplaceFlags'], 'string');
+RutisEngine.RegExtMethod('IntToStr',@RUTIS_ps_IntToStr, ['integer'], 'string');
+RutisEngine.RegExtMethod('FloatToStr',@RUTIS_ps_FloatToStr, ['extended'], 'string');
+RutisEngine.RegExtMethod('StrToInt',@RUTIS_ps_StrToInt, ['String'], 'Integer');
+RutisEngine.RegExtMethod('StrToIntDef',@RUTIS_ps_StrToIntDef, ['String','Integer'], 'Integer');
+RutisEngine.RegExtMethod('StrToFloat',@RUTIS_ps_StrToFloat, ['String'], 'Extended');
+RutisEngine.RegExtMethod('StrToFloatDef',@RUTIS_ps_StrToFloatDef, ['String','Extended'], 'Extended');
+RutisEngine.RegExtMethod('StrToBool',@RUTIS_ps_StrToBool, ['String'], 'Boolean');
+RutisEngine.RegExtMethod('StrToBoolDef',@RUTIS_ps_StrToBoolDef, ['String','Boolean'], 'Boolean');
+RutisEngine.RegExtMethod('Between',@RUTIS_ps_Between, ['string','string','string'], 'string');
+RutisEngine.RegExtMethod('Quicksort',@RUTIS_ps_Quicksort, ['TIntegerArray'], '');
+RutisEngine.RegExtMethod('tSwap',@RUTIS_ps_tSwap, ['TPoint','TPoint'], '');
+RutisEngine.RegExtMethod('tpaSwap',@RUTIS_ps_tpaSwap, ['TPointArray','TPointArray'], '');
+RutisEngine.RegExtMethod('SwapE',@RUTIS_ps_SwapE, ['Extended','Extended'], '');
+RutisEngine.RegExtMethod('RAaSTPAEx',@RUTIS_ps_RAaSTPAEx, ['TPointArray','Integer','Integer'], '');
+RutisEngine.RegExtMethod('RAaSTPA',@RUTIS_ps_RAaSTPA, ['TPointArray','Integer'], '');
+RutisEngine.RegExtMethod('NearbyPointInArrayEx',@RUTIS_ps_NearbyPointInArrayEx, ['TPoint','Integer','Integer','TPointArray'], 'Boolean');
+RutisEngine.RegExtMethod('NearbyPointInArray',@RUTIS_ps_NearbyPointInArray, ['TPoint','Integer','TPointArray'], 'Boolean');
+RutisEngine.RegExtMethod('QuickTPASort',@RUTIS_ps_QuickTPASort, ['TIntegerArray','TPointArray','Integer','Integer','Boolean'], '');
+RutisEngine.RegExtMethod('QuickATPASort',@RUTIS_ps_QuickATPASort, ['TIntegerArray','T2DPointArray','Integer','Integer','Boolean'], '');
+RutisEngine.RegExtMethod('SortTPAFrom',@RUTIS_ps_SortTPAFrom, ['TPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('SortATPAFrom',@RUTIS_ps_SortATPAFrom, ['T2DPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('SortATPAFromFirstPoint',@RUTIS_ps_SortATPAFromFirstPoint, ['T2DPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('InvertTPA',@RUTIS_ps_InvertTPA, ['TPointArray'], '');
+RutisEngine.RegExtMethod('InvertATPA',@RUTIS_ps_InvertATPA, ['T2DPointArray'], '');
+RutisEngine.RegExtMethod('MiddleTPAEx',@RUTIS_ps_MiddleTPAEx, ['TPointArray','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('MiddleTPA',@RUTIS_ps_MiddleTPA, ['TPointArray'], 'TPoint');
+RutisEngine.RegExtMethod('SortATPASize',@RUTIS_ps_SortATPASize, ['T2DPointArray','Boolean'], '');
+RutisEngine.RegExtMethod('SortATPAFromSize',@RUTIS_ps_SortATPAFromSize, ['T2DPointArray','Integer','Boolean'], '');
+RutisEngine.RegExtMethod('InIntArrayEx',@RUTIS_ps_InIntArrayEx, ['TIntegerArray','Integer','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('InIntArray',@RUTIS_ps_InIntArray, ['TIntegerArray','Integer'], 'Boolean');
+RutisEngine.RegExtMethod('ClearSameIntegers',@RUTIS_ps_ClearSameIntegers, ['TIntegerArray'], '');
+RutisEngine.RegExtMethod('ClearSameIntegersAndTPA',@RUTIS_ps_ClearSameIntegersAndTPA, ['TIntegerArray','TPointArray'], '');
+RutisEngine.RegExtMethod('SplitTPAEx',@RUTIS_ps_SplitTPAEx, ['TPointArray','Integer','Integer'], 'T2DPointArray');
+RutisEngine.RegExtMethod('SplitTPA',@RUTIS_ps_SplitTPA, ['TPointArray','Integer'], 'T2DPointArray');
+RutisEngine.RegExtMethod('FloodFillTPA',@RUTIS_ps_FloodFillTPA, ['TPointArray'], 'T2DPointArray');
+RutisEngine.RegExtMethod('FilterPointsPie',@RUTIS_ps_FilterPointsPie, ['TPointArray','Extended','Extended','Extended','Extended','Integer','Integer'], '');
+RutisEngine.RegExtMethod('FilterPointsDist',@RUTIS_ps_FilterPointsDist, ['TPointArray','Extended','Extended','Integer','Integer'], '');
+RutisEngine.RegExtMethod('FilterPointsLine',@RUTIS_ps_FilterPointsLine, ['TPointArray','Extended','Integer','Integer','Integer'], '');
+RutisEngine.RegExtMethod('GetATPABounds',@RUTIS_ps_GetATPABounds, ['T2DPointArray'], 'TBox');
+RutisEngine.RegExtMethod('GetTPABounds',@RUTIS_ps_GetTPABounds, ['TPointArray'], 'TBox');
+RutisEngine.RegExtMethod('FindTPAinTPA',@RUTIS_ps_FindTPAinTPA, ['TPointArray','TPointArray','TPointArray'], 'Boolean');
+RutisEngine.RegExtMethod('GetSamePointsATPA',@RUTIS_ps_GetSamePointsATPA, ['T2DPointArray','TPointArray'], 'boolean');
+RutisEngine.RegExtMethod('FindTextTPAinTPA',@RUTIS_ps_FindTextTPAinTPA, ['integer','TPointArray','TPointArray','TPointArray'], 'Boolean');
+RutisEngine.RegExtMethod('SortCircleWise',@RUTIS_ps_SortCircleWise, ['TPointArray','Integer','Integer','Integer','Boolean','Boolean'], '');
+RutisEngine.RegExtMethod('LinearSort',@RUTIS_ps_LinearSort, ['TPointArray','Integer','Integer','Integer','Boolean'], '');
+RutisEngine.RegExtMethod('RotatePoint',@RUTIS_ps_RotatePoint, ['TPoint','Extended','Extended','Extended'], 'TPoint');
+RutisEngine.RegExtMethod('ChangeDistPT',@RUTIS_ps_ChangeDistPT, ['TPoint','integer','integer','extended'], 'TPoint');
+RutisEngine.RegExtMethod('ChangeDistTPA',@RUTIS_ps_ChangeDistTPA, ['TPointArray','integer','integer','extended'], 'boolean');
+RutisEngine.RegExtMethod('FindGapsTPA',@RUTIS_ps_FindGapsTPA, ['TPointArray','Integer'], 'T2DPointArray');
+RutisEngine.RegExtMethod('RemoveDistTPointArray',@RUTIS_ps_RemoveDistTPointArray, ['Integer','Integer','Integer','TPointArray','Boolean'], 'TPointArray');
+RutisEngine.RegExtMethod('CombineTPA',@RUTIS_ps_CombineTPA, ['TPointArray','TPointArray'], 'TPointArray');
+RutisEngine.RegExtMethod('ReArrangeandShortenArrayEx',@RUTIS_ps_ReArrangeandShortenArrayEx, ['TPointArray','Integer','Integer'], 'TPointArray');
+RutisEngine.RegExtMethod('ReArrangeandShortenArray',@RUTIS_ps_ReArrangeandShortenArray, ['TPointArray','Integer'], 'TPointArray');
+RutisEngine.RegExtMethod('TPAtoATPAEx',@RUTIS_ps_TPAtoATPAEx, ['TPointArray','Integer','Integer'], 'T2DPointArray');
+RutisEngine.RegExtMethod('TPAtoATPA',@RUTIS_ps_TPAtoATPA, ['TPointArray','Integer'], 'T2DPointArray');
+RutisEngine.RegExtMethod('CombineIntArray',@RUTIS_ps_CombineIntArray, ['TIntegerArray','TIntegerArray'], 'TIntegerArray');
+RutisEngine.RegExtMethod('MergeATPA',@RUTIS_ps_MergeATPA, ['T2DPointArray'], 'TPointArray');
+RutisEngine.RegExtMethod('AppendTPA',@RUTIS_ps_AppendTPA, ['TPointArray','TPointArray'], '');
+RutisEngine.RegExtMethod('TPAFromBox',@RUTIS_ps_TPAFromBox, ['TBox'], 'TPointArray');
+RutisEngine.RegExtMethod('RotatePoints',@RUTIS_ps_RotatePoints, ['TPointArray','Extended','Extended','Extended'], 'TPointArray');
+RutisEngine.RegExtMethod('FindTPAEdges',@RUTIS_ps_FindTPAEdges, ['TPointArray'], 'TPointArray');
+RutisEngine.RegExtMethod('ClearTPAFromTPA',@RUTIS_ps_ClearTPAFromTPA, ['TPointArray','TPointArray'], 'TPointArray');
+RutisEngine.RegExtMethod('ReturnPointsNotInTPA',@RUTIS_ps_ReturnPointsNotInTPA, ['TPointArray','TBox'], 'TPointArray');
+RutisEngine.RegExtMethod('PointInTPA',@RUTIS_ps_PointInTPA, ['TPoint','TPointArray'], 'Boolean');
+RutisEngine.RegExtMethod('ClearDoubleTPA',@RUTIS_ps_ClearDoubleTPA, ['TPointArray'], '');
+RutisEngine.RegExtMethod('TPACountSort',@RUTIS_ps_TPACountSort, ['TPointArray','TPoint','Boolean'], '');
+RutisEngine.RegExtMethod('TPACountSortBase',@RUTIS_ps_TPACountSortBase, ['TPointArray','TPoint','TPoint','Boolean'], '');
+RutisEngine.RegExtMethod('InvertTIA',@RUTIS_ps_InvertTIA, ['TIntegerArray'], '');
+RutisEngine.RegExtMethod('SumIntegerArray',@RUTIS_ps_SumIntegerArray, ['TIntegerArray'], 'Integer');
+RutisEngine.RegExtMethod('AverageTIA',@RUTIS_ps_AverageTIA, ['TIntegerArray'], 'Integer');
+RutisEngine.RegExtMethod('AverageExtended',@RUTIS_ps_AverageExtended, ['TExtendedArray'], 'Extended');
+RutisEngine.RegExtMethod('SplitTPAExWrap',@RUTIS_ps_SplitTPAExWrap, ['TPointArray','Integer','Integer','T2DPointArray'], '');
+RutisEngine.RegExtMethod('SplitTPAWrap',@RUTIS_ps_SplitTPAWrap, ['TPointArray','Integer','T2DPointArray'], '');
+RutisEngine.RegExtMethod('FindGapsTPAWrap',@RUTIS_ps_FindGapsTPAWrap, ['TPointArray','Integer','T2DPointArray'], '');
+RutisEngine.RegExtMethod('RemoveDistTPointArrayWrap',@RUTIS_ps_RemoveDistTPointArrayWrap, ['Integer','Integer','Integer','TPointArray','Boolean','TPointArray'], '');
+RutisEngine.RegExtMethod('CombineTPAWrap',@RUTIS_ps_CombineTPAWrap, ['TPointArray','TPointArray','TPointArray'], '');
+RutisEngine.RegExtMethod('ReArrangeandShortenArrayExWrap',@RUTIS_ps_ReArrangeandShortenArrayExWrap, ['TPointArray','Integer','Integer','TPointArray'], '');
+RutisEngine.RegExtMethod('ReArrangeandShortenArrayWrap',@RUTIS_ps_ReArrangeandShortenArrayWrap, ['TPointArray','Integer','TPointArray'], '');
+RutisEngine.RegExtMethod('TPAtoATPAExWrap',@RUTIS_ps_TPAtoATPAExWrap, ['TPointArray','Integer','Integer','T2DPointArray'], '');
+RutisEngine.RegExtMethod('TPAtoATPAWrap',@RUTIS_ps_TPAtoATPAWrap, ['TPointArray','Integer','T2DPointArray'], '');
+RutisEngine.RegExtMethod('CombineIntArrayWrap',@RUTIS_ps_CombineIntArrayWrap, ['TIntegerArray','TIntegerArray','TIntegerArray'], '');
+RutisEngine.RegExtMethod('MergeATPAWrap',@RUTIS_ps_MergeATPAWrap, ['T2DPointArray','TPointArray'], '');
+RutisEngine.RegExtMethod('TPAFromBoxWrap',@RUTIS_ps_TPAFromBoxWrap, ['TBox','TPointArray'], '');
+RutisEngine.RegExtMethod('RotatePointsWrap',@RUTIS_ps_RotatePointsWrap, ['TPointArray','Extended','Extended','Extended','TPointArray'], '');
+RutisEngine.RegExtMethod('FindTPAEdgesWrap',@RUTIS_ps_FindTPAEdgesWrap, ['TPointArray','TPointArray'], '');
+RutisEngine.RegExtMethod('ClearTPAFromTPAWrap',@RUTIS_ps_ClearTPAFromTPAWrap, ['TPointArray','TPointArray','TPointArray'], '');
+RutisEngine.RegExtMethod('ReturnPointsNotInTPAWrap',@RUTIS_ps_ReturnPointsNotInTPAWrap, ['TPointArray','TBox','TPointArray'], '');
+RutisEngine.RegExtMethod('SameTPA',@RUTIS_ps_SameTPA, ['TPointArray','TPointArray'], 'Boolean');
+RutisEngine.RegExtMethod('TPAInATPA',@RUTIS_ps_TPAInATPA, ['TPointArray','T2DPointArray','LongInt'], 'Boolean');
+RutisEngine.RegExtMethod('OffsetTPA',@RUTIS_ps_OffsetTPA, ['TPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('OffsetATPA',@RUTIS_ps_OffsetATPA, ['T2DPointArray','TPoint'], '');
+RutisEngine.RegExtMethod('CopyTPA',@RUTIS_ps_CopyTPA, ['TPointArray'], 'TPointArray');
+RutisEngine.RegExtMethod('CopyATPA',@RUTIS_ps_CopyATPA, ['T2DPointArray'], 'T2DPointArray');
+RutisEngine.RegExtMethod('SetDesktopAsClient',@RUTIS_ps_SetDesktopAsClient, [], '');
+RutisEngine.RegExtMethod('SetTargetArray',@RUTIS_ps_SetTargetArray, ['Integer','integer','integer'], 'integer');
+RutisEngine.RegExtMethod('SetTargetBitmap',@RUTIS_ps_SetTargetBitmap, ['Integer'], 'integer');
+RutisEngine.RegExtMethod('SetEIOSTarget',@RUTIS_ps_SetEIOSTarget, ['string','Variant'], 'integer');
+RutisEngine.RegExtMethod('SetImageTarget',@RUTIS_ps_SetImageTarget, ['integer'], '');
+RutisEngine.RegExtMethod('SetKeyMouseTarget',@RUTIS_ps_SetKeyMouseTarget, ['integer'], '');
+RutisEngine.RegExtMethod('GetImageTarget',@RUTIS_ps_GetImageTarget, [], 'integer');
+RutisEngine.RegExtMethod('GetKeyMouseTarget',@RUTIS_ps_GetKeyMouseTarget, [], 'integer');
+RutisEngine.RegExtMethod('ExportImageTarget',@RUTIS_ps_ExportImageTarget, [], 'TTarget_Exported');
+RutisEngine.RegExtMethod('ExportKeyMouseTarget',@RUTIS_ps_ExportKeyMouseTarget, [], 'TTarget_Exported');
+RutisEngine.RegExtMethod('FreeTarget',@RUTIS_ps_FreeTarget, ['integer'], '');
+RutisEngine.RegExtMethod('GetClientDimensions',@RUTIS_ps_GetClientDimensions, ['integer','integer'], '');
+RutisEngine.RegExtMethod('Freeze',@RUTIS_ps_Freeze, [], 'boolean');
+RutisEngine.RegExtMethod('Unfreeze',@RUTIS_ps_Unfreeze, [], 'boolean');
+RutisEngine.RegExtMethod('ActivateClient',@RUTIS_ps_ActivateClient, [], '');
+RutisEngine.RegExtMethod('IsTargetValid',@RUTIS_ps_IsTargetValid, [], 'boolean');

Units/MMLAddon/RTInc/settings.inc

@@ -0,0 +1,39 @@
+procedure RUTIS_ps_SetSettingValue(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_SetSettingValue(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_KeyIsSetting(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_KeyIsSetting(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_KeyIsDirectory(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_KeyIsDirectory(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetSettingValue(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PString(Result^.Data)^ := ps_GetSettingValue(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetSettingValueDef(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PString(Result^.Data)^ := ps_GetSettingValueDef(PString(Params^[0].Data)^, PString(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ListSettings(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_ListSettings(PString(Params^[0].Data)^, PStringArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_DeleteSetting(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_DeleteSetting(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_DeleteSubSettings(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_DeleteSubSettings(PString(Params^[0].Data)^);
+end;

Units/MMLAddon/RTInc/strings.inc

@@ -0,0 +1,89 @@
+{procedure RUTIS_ps_Format(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_Format(Pstring(Params^[0].Data)^, Parray of const(Params^[1].Data)^);
+end;}
+
+procedure RUTIS_ps_Capitalize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_Capitalize(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_CompressString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_CompressString(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_DecompressString(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_DecompressString(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_Base64Encode(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_Base64Encode(Pstring(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_Base64Decode(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_Base64Decode(Pstring(Params^[0].Data)^);
+end;
+
+{procedure RUTIS_ps_ExtractFromStr(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_ExtractFromStr(Pstring(Params^[0].Data)^, PStrExtr(Params^[1].Data)^);
+end;}
+
+procedure RUTIS_ps_BoolToStr(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_BoolToStr(Pboolean(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_Replace(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_Replace(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^, Pstring(Params^[2].Data)^, PReplaceFlags(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_IntToStr(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_IntToStr(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_FloatToStr(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_FloatToStr(Pextended(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_StrToInt(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_StrToInt(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_StrToIntDef(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_StrToIntDef(PString(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_StrToFloat(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PExtended(Result^.Data)^ := ps_StrToFloat(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_StrToFloatDef(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PExtended(Result^.Data)^ := ps_StrToFloatDef(PString(Params^[0].Data)^, PExtended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_StrToBool(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_StrToBool(PString(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_StrToBoolDef(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_StrToBoolDef(PString(Params^[0].Data)^, PBoolean(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_Between(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pstring(Result^.Data)^ := ps_Between(Pstring(Params^[0].Data)^, Pstring(Params^[1].Data)^, Pstring(Params^[2].Data)^);
+end;

Units/MMLAddon/RTInc/tpa.inc

@@ -0,0 +1,419 @@
+procedure RUTIS_ps_Quicksort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_Quicksort(PIntegerArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_tSwap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_tSwap(PPoint(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_tpaSwap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_tpaSwap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_SwapE(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SwapE(PExtended(Params^[0].Data)^, PExtended(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_RAaSTPAEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_RAaSTPAEx(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_RAaSTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_RAaSTPA(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_NearbyPointInArrayEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_NearbyPointInArrayEx(PPoint(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_NearbyPointInArray(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_NearbyPointInArray(PPoint(Params^[0].Data)^, PInteger(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_QuickTPASort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_QuickTPASort(PIntegerArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_QuickATPASort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_QuickATPASort(PIntegerArray(Params^[0].Data)^, P2DPointArray(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_SortTPAFrom(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SortTPAFrom(PPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_SortATPAFrom(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SortATPAFrom(P2DPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_SortATPAFromFirstPoint(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SortATPAFromFirstPoint(P2DPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_InvertTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_InvertTPA(PPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_InvertATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_InvertATPA(P2DPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_MiddleTPAEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_MiddleTPAEx(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_MiddleTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPoint(Result^.Data)^ := ps_MiddleTPA(PPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SortATPASize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SortATPASize(P2DPointArray(Params^[0].Data)^, PBoolean(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_SortATPAFromSize(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SortATPAFromSize(P2DPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PBoolean(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_InIntArrayEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_InIntArrayEx(PIntegerArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_InIntArray(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_InIntArray(PIntegerArray(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ClearSameIntegers(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ClearSameIntegers(PIntegerArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_ClearSameIntegersAndTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ClearSameIntegersAndTPA(PIntegerArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_SplitTPAEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  P2DPointArray(Result^.Data)^ := ps_SplitTPAEx(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_SplitTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  P2DPointArray(Result^.Data)^ := ps_SplitTPA(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_FloodFillTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  P2DPointArray(Result^.Data)^ := ps_FloodFillTPA(PPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_FilterPointsPie(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FilterPointsPie(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PExtended(Params^[3].Data)^, PExtended(Params^[4].Data)^, PInteger(Params^[5].Data)^, PInteger(Params^[6].Data)^);
+end;
+
+procedure RUTIS_ps_FilterPointsDist(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FilterPointsDist(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_FilterPointsLine(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FilterPointsLine(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PInteger(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_GetATPABounds(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBox(Result^.Data)^ := ps_GetATPABounds(P2DPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetTPABounds(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBox(Result^.Data)^ := ps_GetTPABounds(PPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_FindTPAinTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindTPAinTPA(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_GetSamePointsATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_GetSamePointsATPA(P2DPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_FindTextTPAinTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_FindTextTPAinTPA(Pinteger(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(Params^[2].Data)^, PPointArray(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_SortCircleWise(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SortCircleWise(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^, PBoolean(Params^[5].Data)^);
+end;
+
+procedure RUTIS_ps_LinearSort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_LinearSort(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PInteger(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_RotatePoint(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPoint(Result^.Data)^ := ps_RotatePoint(PPoint(Params^[0].Data)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PExtended(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_ChangeDistPT(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPoint(Result^.Data)^ := ps_ChangeDistPT(PPoint(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pextended(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_ChangeDistTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_ChangeDistTPA(PPointArray(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^, Pextended(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_FindGapsTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  P2DPointArray(Result^.Data)^ := ps_FindGapsTPA(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_RemoveDistTPointArray(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_RemoveDistTPointArray(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(Params^[3].Data)^, PBoolean(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_CombineTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_CombineTPA(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ReArrangeandShortenArrayEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_ReArrangeandShortenArrayEx(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_ReArrangeandShortenArray(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_ReArrangeandShortenArray(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_TPAtoATPAEx(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  P2DPointArray(Result^.Data)^ := ps_TPAtoATPAEx(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_TPAtoATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  P2DPointArray(Result^.Data)^ := ps_TPAtoATPA(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_CombineIntArray(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PIntegerArray(Result^.Data)^ := ps_CombineIntArray(PIntegerArray(Params^[0].Data)^, PIntegerArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_MergeATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_MergeATPA(P2DPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_AppendTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_AppendTPA(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_TPAFromBox(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_TPAFromBox(PBox(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_RotatePoints(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_RotatePoints(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PExtended(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_FindTPAEdges(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_FindTPAEdges(PPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_ClearTPAFromTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_ClearTPAFromTPA(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ReturnPointsNotInTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_ReturnPointsNotInTPA(PPointArray(Params^[0].Data)^, PBox(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_PointInTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_PointInTPA(PPoint(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ClearDoubleTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ClearDoubleTPA(PPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_TPACountSort(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_TPACountSort(PPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^, PBoolean(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_TPACountSortBase(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_TPACountSortBase(PPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^, PPoint(Params^[2].Data)^, PBoolean(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_InvertTIA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_InvertTIA(PIntegerArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SumIntegerArray(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_SumIntegerArray(PIntegerArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_AverageTIA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PInteger(Result^.Data)^ := ps_AverageTIA(PIntegerArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_AverageExtended(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PExtended(Result^.Data)^ := ps_AverageExtended(PExtendedArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SplitTPAExWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SplitTPAExWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, P2DPointArray(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_SplitTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SplitTPAWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, P2DPointArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_FindGapsTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FindGapsTPAWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, P2DPointArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_RemoveDistTPointArrayWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_RemoveDistTPointArrayWrap(PInteger(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(Params^[3].Data)^, PBoolean(Params^[4].Data)^, PPointArray(Params^[5].Data)^);
+end;
+
+procedure RUTIS_ps_CombineTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_CombineTPAWrap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_ReArrangeandShortenArrayExWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ReArrangeandShortenArrayExWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, PPointArray(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_ReArrangeandShortenArrayWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ReArrangeandShortenArrayWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_TPAtoATPAExWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_TPAtoATPAExWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, PInteger(Params^[2].Data)^, P2DPointArray(Params^[3].Data)^);
+end;
+
+procedure RUTIS_ps_TPAtoATPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_TPAtoATPAWrap(PPointArray(Params^[0].Data)^, PInteger(Params^[1].Data)^, P2DPointArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_CombineIntArrayWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_CombineIntArrayWrap(PIntegerArray(Params^[0].Data)^, PIntegerArray(Params^[1].Data)^, PIntegerArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_MergeATPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_MergeATPAWrap(P2DPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_TPAFromBoxWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_TPAFromBoxWrap(PBox(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_RotatePointsWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_RotatePointsWrap(PPointArray(Params^[0].Data)^, PExtended(Params^[1].Data)^, PExtended(Params^[2].Data)^, PExtended(Params^[3].Data)^, PPointArray(Params^[4].Data)^);
+end;
+
+procedure RUTIS_ps_FindTPAEdgesWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FindTPAEdgesWrap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_ClearTPAFromTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ClearTPAFromTPAWrap(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_ReturnPointsNotInTPAWrap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ReturnPointsNotInTPAWrap(PPointArray(Params^[0].Data)^, PBox(Params^[1].Data)^, PPointArray(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_SameTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_SameTPA(PPointArray(Params^[0].Data)^, PPointArray(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_TPAInATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PBoolean(Result^.Data)^ := ps_TPAInATPA(PPointArray(Params^[0].Data)^, P2DPointArray(Params^[1].Data)^, PLongInt(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_OffsetTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_OffsetTPA(PPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_OffsetATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_OffsetATPA(P2DPointArray(Params^[0].Data)^, PPoint(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_CopyTPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PPointArray(Result^.Data)^ := ps_CopyTPA(PPointArray(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_CopyATPA(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  P2DPointArray(Result^.Data)^ := ps_CopyATPA(P2DPointArray(Params^[0].Data)^);
+end;

Units/MMLAddon/RTInc/window.inc

@@ -0,0 +1,79 @@
+procedure RUTIS_ps_SetDesktopAsClient(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetDesktopAsClient();
+end;
+
+procedure RUTIS_ps_SetTargetArray(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_SetTargetArray(PInteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^, Pinteger(Params^[2].Data)^);
+end;
+
+procedure RUTIS_ps_SetTargetBitmap(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_SetTargetBitmap(PInteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SetEIOSTarget(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_SetEIOSTarget(Pstring(Params^[0].Data)^, PVariant(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_SetImageTarget(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetImageTarget(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_SetKeyMouseTarget(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_SetKeyMouseTarget(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetImageTarget(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_GetImageTarget();
+end;
+
+procedure RUTIS_ps_GetKeyMouseTarget(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pinteger(Result^.Data)^ := ps_GetKeyMouseTarget();
+end;
+
+procedure RUTIS_ps_ExportImageTarget(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PTarget_Exported(Result^.Data)^ := ps_ExportImageTarget();
+end;
+
+procedure RUTIS_ps_ExportKeyMouseTarget(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  PTarget_Exported(Result^.Data)^ := ps_ExportKeyMouseTarget();
+end;
+
+procedure RUTIS_ps_FreeTarget(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_FreeTarget(Pinteger(Params^[0].Data)^);
+end;
+
+procedure RUTIS_ps_GetClientDimensions(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_GetClientDimensions(Pinteger(Params^[0].Data)^, Pinteger(Params^[1].Data)^);
+end;
+
+procedure RUTIS_ps_Freeze(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_Freeze();
+end;
+
+procedure RUTIS_ps_Unfreeze(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_Unfreeze();
+end;
+
+procedure RUTIS_ps_ActivateClient(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  ps_ActivateClient();
+end;
+
+procedure RUTIS_ps_IsTargetValid(Params: PRutisParamInfoArray; Result: PRutisParamInfo);
+begin
+  Pboolean(Result^.Data)^ := ps_IsTargetValid();
+end;

Units/MMLAddon/mmlpsthread.pas

@@ -488,6 +488,12 @@ begin
   end;
 end;
 
+function CallProc(ProcName: string; var V: TVariantArray): Variant; extdecl;
+begin
+  with TPSThread(currthread).PSScript do
+    Result := Exec.RunProcPVar(V,Exec.GetProc(Procname));
+end;
+
 {$I PSInc/Wrappers/other.inc}
 {$I PSInc/Wrappers/settings.inc}
 {$I PSInc/Wrappers/bitmap.inc}
@@ -994,8 +1000,47 @@ begin
     writeln(s);
 end;
 
+type
+  PBoolean = ^Boolean;
+  PStringArray = ^TStringArray;
+  PBmpMirrorStyle = ^TBmpMirrorStyle;
+  PPointArray = ^TPointArray;
+  P2DIntArray = ^T2DIntArray;
+  PCanvas = ^TCanvas;
+  P2DPointArray = ^T2DPointArray;
+  PMask = ^Tmask;
+  PBox = ^TBox;
+  PTarget_Exported = ^TTarget_Exported;
+  PIntegerArray = ^TIntegerArray;
+  PExtendedArray = ^TExtendedArray;
+//  PStrExtr = ^TStrExtr;
+  PReplaceFlags = ^TReplaceFlags;
+  PClickType = ^TClickType;
+  P2DExtendedArray = ^T2DExtendedArray;
+  PMDTM = ^TMDTM;
+  PSDTM = ^TSDTM;
+
+{$I RTInc/other.inc}
+{$I RTInc/settings.inc}
+{$I RTInc/bitmap.inc}
+{$I RTInc/window.inc}
+{$I RTInc/tpa.inc}
+{$I RTInc/strings.inc}
+{$I RTInc/colour.inc}
+{$I RTInc/colourconv.inc}
+{$I RTInc/math.inc}
+{$I RTInc/mouse.inc}
+{$I RTInc/file.inc}
+{$I RTInc/keyboard.inc}
+{$I RTInc/dtm.inc}
+{$I RTInc/ocr.inc}
+{$I RTInc/internets.inc}
+
+
 constructor TRTThread.Create(CreateSuspended: Boolean; TheSyncInfo: PSyncInfo;
   plugin_dir: string);
+var
+  RutisEngine  : TRutisEngine;
 begin
   inherited Create(CreateSuspended, TheSyncInfo, plugin_dir);
   RUTIS := TRutisEngine.Create;
@@ -1003,6 +1048,8 @@ begin
   RUTIS.OnError:= @RTOnError;
   RUTIS.OptProcessTimer:= false;
   RUTIS.Compiler.optArrayRangeCheck:= true;
+  RutisEngine := RUTIS;
+  {$I RTInc/rtexportedmethods.inc}
 end;
 
 destructor TRTThread.Destroy;

Units/MMLAddon/scriptproperties.pas

@@ -14,6 +14,7 @@ type
       SP_WriteTimeStamp, //Writes the time infront of a writeln
       SP_OnTerminate
     );
+    PSP_Property = ^TSP_Property;
     TSP_Properties = set of TSP_Property;