From 9deb9a1b67d97215d22bbe132d625ea7e9faa363 Mon Sep 17 00:00:00 2001 From: Merlijn Wajer Date: Wed, 3 Aug 2011 20:29:48 +0200 Subject: [PATCH] Lape: Add wrappers. --- Units/MMLAddon/LPInc/Wrappers/bitmap.inc | 259 +++++++++++ Units/MMLAddon/LPInc/Wrappers/colour.inc | 104 +++++ Units/MMLAddon/LPInc/Wrappers/colourconv.inc | 4 + Units/MMLAddon/LPInc/Wrappers/crypto.inc | 4 + Units/MMLAddon/LPInc/Wrappers/dtm.inc | 79 ++++ Units/MMLAddon/LPInc/Wrappers/extensions.inc | 64 +++ Units/MMLAddon/LPInc/Wrappers/file.inc | 89 ++++ Units/MMLAddon/LPInc/Wrappers/internets.inc | 124 +++++ Units/MMLAddon/LPInc/Wrappers/keyboard.inc | 29 ++ Units/MMLAddon/LPInc/Wrappers/math.inc | 114 +++++ Units/MMLAddon/LPInc/Wrappers/mouse.inc | 39 ++ Units/MMLAddon/LPInc/Wrappers/ocr.inc | 19 + Units/MMLAddon/LPInc/Wrappers/other.inc | 19 + Units/MMLAddon/LPInc/Wrappers/settings.inc | 39 ++ Units/MMLAddon/LPInc/Wrappers/strings.inc | 84 ++++ Units/MMLAddon/LPInc/Wrappers/tpa.inc | 424 ++++++++++++++++++ Units/MMLAddon/LPInc/Wrappers/window.inc | 84 ++++ Units/MMLAddon/LPInc/lpexportedmethods.inc | 3 +- Units/MMLAddon/LPInc/lpexportedmethodsinc.inc | 319 +++++++++++++ Units/MMLAddon/mmlpsthread.pas | 32 +- 20 files changed, 1915 insertions(+), 17 deletions(-) create mode 100644 Units/MMLAddon/LPInc/Wrappers/bitmap.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/colour.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/colourconv.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/crypto.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/dtm.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/extensions.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/file.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/internets.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/keyboard.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/math.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/mouse.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/ocr.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/other.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/settings.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/strings.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/tpa.inc create mode 100644 Units/MMLAddon/LPInc/Wrappers/window.inc create mode 100644 Units/MMLAddon/LPInc/lpexportedmethodsinc.inc diff --git a/Units/MMLAddon/LPInc/Wrappers/bitmap.inc b/Units/MMLAddon/LPInc/Wrappers/bitmap.inc new file mode 100644 index 0000000..27a7f8d --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/bitmap.inc @@ -0,0 +1,259 @@ +procedure Lape_CreateBitmapString(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_CreateBitmapString(Pinteger(Params^[0])^); +end; + +procedure Lape_GetMufasaBitmap(const Params: PParamArray; const Result: Pointer); +begin + PMufasaBitmap(Result)^ := ps_GetMufasaBitmap(Pinteger(Params^[0])^); +end; + +procedure Lape_CreateBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_CreateBitmap(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_FreeBitmap(const Params: PParamArray); +begin + ps_FreeBitmap(Pinteger(Params^[0])^); +end; + +procedure Lape_SaveBitmap(const Params: PParamArray); +begin + ps_SaveBitmap(Pinteger(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_BitmapFromString(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_BitmapFromString(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pstring(Params^[1])^); +end; + +procedure Lape_LoadBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_LoadBitmap(PString(Params^[0])^); +end; + +procedure Lape_SetBitmapSize(const Params: PParamArray); +begin + ps_SetBitmapSize(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^); +end; + +procedure Lape_StretchBitmapResize(const Params: PParamArray); +begin + ps_StretchBitmapResize(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^); +end; + +procedure Lape_GetBitmapSize(const Params: PParamArray); +begin + ps_GetBitmapSize(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^); +end; + +procedure Lape_SetBitmapName(const Params: PParamArray); +begin + ps_SetBitmapName(Pinteger(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_CreateMirroredBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_CreateMirroredBitmap(Pinteger(Params^[0])^); +end; + +procedure Lape_CreateMirroredBitmapEx(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_CreateMirroredBitmapEx(Pinteger(Params^[0])^, PBmpMirrorStyle(Params^[1])^); +end; + +procedure Lape_FastGetPixel(const Params: PParamArray; const Result: Pointer); +begin + PLongWord(Result)^ := ps_FastGetPixel(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^); +end; + +procedure Lape_FastGetPixels(const Params: PParamArray; const Result: Pointer); +begin + PIntegerArray(Result)^ := ps_FastGetPixels(Pinteger(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_GetBitmapAreaColors(const Params: PParamArray; const Result: Pointer); +begin + P2DIntArray(Result)^ := ps_GetBitmapAreaColors(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^); +end; + +procedure Lape_FastSetPixel(const Params: PParamArray); +begin + ps_FastSetPixel(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^, PColor(Params^[1])^); +end; + +procedure Lape_FastSetPixels(const Params: PParamArray); +begin + ps_FastSetPixels(Pinteger(Params^[0])^, PPointArray(Params^[1])^, PIntegerArray(Params^[2])^); +end; + +procedure Lape_DrawTPABitmap(const Params: PParamArray); +begin + ps_DrawTPABitmap(Pinteger(Params^[0])^, PPointArray(Params^[1])^, Pinteger(Params^[2])^); +end; + +procedure Lape_DrawATPABitmap(const Params: PParamArray); +begin + ps_DrawATPABitmap(Pinteger(Params^[0])^, P2DPointArray(Params^[1])^); +end; + +procedure Lape_DrawATPABitmapEx(const Params: PParamArray); +begin + ps_DrawATPABitmapEx(Pinteger(Params^[0])^, P2DPointArray(Params^[1])^, PIntegerArray(Params^[2])^); +end; + +procedure Lape_FastDrawClear(const Params: PParamArray); +begin + ps_FastDrawClear(Pinteger(Params^[0])^, PColor(Params^[1])^); +end; + +procedure Lape_DrawBitmap(const Params: PParamArray); +begin + ps_DrawBitmap(PInteger(Params^[0])^, PCanvas(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^); +end; + +procedure Lape_FastDrawTransparent(const Params: PParamArray); +begin + ps_FastDrawTransparent(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_SetTransparentColor(const Params: PParamArray); +begin + ps_SetTransparentColor(Pinteger(Params^[0])^, PColor(Params^[1])^); +end; + +procedure Lape_GetTransparentColor(const Params: PParamArray; const Result: Pointer); +begin + PColor(Result)^ := ps_GetTransparentColor(Pinteger(Params^[0])^); +end; + +procedure Lape_FastReplaceColor(const Params: PParamArray); +begin + ps_FastReplaceColor(PInteger(Params^[0])^, PColor(Params^[1])^, PColor(Params^[2])^); +end; + +procedure Lape_CopyClientToBitmap(const Params: PParamArray); +begin + ps_CopyClientToBitmap(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^); +end; + +procedure Lape_BitmapFromClient(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_BitmapFromClient(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^); +end; + +procedure Lape_FindBitmap(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindBitmap(Pinteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_FindBitmapIn(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindBitmapIn(Pinteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^); +end; + +procedure Lape_FindBitmapToleranceIn(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindBitmapToleranceIn(Pinteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[3])^); +end; + +procedure Lape_FindBitmapSpiral(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindBitmapSpiral(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^); +end; + +procedure Lape_FindBitmapsSpiralTolerance(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindBitmapsSpiralTolerance(Pinteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PPointArray(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[6])^, PInteger(Params^[7])^); +end; + +procedure Lape_FindBitmapSpiralTolerance(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindBitmapSpiralTolerance(Pinteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, Pinteger(Params^[2])^, Pinteger(Params^[3])^, Pinteger(Params^[4])^, Pinteger(Params^[5])^, Pinteger(Params^[6])^); +end; + +procedure Lape_RotateBitmap(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_RotateBitmap(PInteger(Params^[0])^, PExtended(Params^[1])^); +end; + +procedure Lape_Desaturate(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_Desaturate(Pinteger(Params^[0])^); +end; + +procedure Lape_InvertBitmap(const Params: PParamArray); +begin + ps_InvertBitmap(Pinteger(Params^[0])^); +end; + +procedure Lape_CopyBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_CopyBitmap(Pinteger(Params^[0])^); +end; + +procedure Lape_GreyScaleBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_GreyScaleBitmap(Pinteger(Params^[0])^); +end; + +procedure Lape_BrightnessBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_BrightnessBitmap(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_ContrastBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_ContrastBitmap(Pinteger(Params^[0])^, Pextended(Params^[1])^); +end; + +procedure Lape_PosterizeBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_PosterizeBitmap(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_CreateMaskFromBitmap(const Params: PParamArray; const Result: Pointer); +begin + PMask(Result)^ := ps_CreateMaskFromBitmap(Pinteger(Params^[0])^); +end; + +procedure Lape_FindMaskTolerance(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindMaskTolerance(PMask(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[3])^, PInteger(Params^[4])^); +end; + +procedure Lape_FindBitmapMaskTolerance(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindBitmapMaskTolerance(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[3])^, PInteger(Params^[4])^); +end; + +procedure Lape_FindDeformedBitmapToleranceIn(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindDeformedBitmapToleranceIn(Pinteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PBoolean(Params^[5])^, PExtended(Params^[6])^); +end; + +procedure Lape_RectangleBitmap(const Params: PParamArray); +begin + ps_RectangleBitmap(Pinteger(Params^[0])^, PBox(Params^[1])^, PColor(Params^[2])^); +end; + +procedure Lape_FloodFillBitmap(const Params: PParamArray); +begin + ps_FloodFillBitmap(Pinteger(Params^[0])^, PPoint(Params^[1])^, PColor(Params^[2])^, PColor(Params^[3])^); +end; + +procedure Lape_ConvoluteBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_ConvoluteBitmap(Pinteger(Params^[0])^, P2DExtendedArray(Params^[1])^); +end; + +procedure Lape_CalculatePixelShift(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_CalculatePixelShift(PInteger(Params^[0])^, PInteger(Params^[1])^, PBox(Params^[1])^); +end; + +procedure Lape_CalculatePixelTolerance(const Params: PParamArray; const Result: Pointer); +begin + Pextended(Result)^ := ps_CalculatePixelTolerance(PInteger(Params^[0])^, PInteger(Params^[1])^, PBox(Params^[1])^, Pinteger(Params^[2])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/colour.inc b/Units/MMLAddon/LPInc/Wrappers/colour.inc new file mode 100644 index 0000000..75a6aa2 --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/colour.inc @@ -0,0 +1,104 @@ +procedure Lape_GetColor(const Params: PParamArray; const Result: Pointer); +begin + PColor(Result)^ := ps_GetColor(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_GetColorsWrap(const Params: PParamArray); +begin + ps_GetColorsWrap(PPointArray(Params^[0])^, PIntegerArray(Params^[1])^); +end; + +procedure Lape_GetColors(const Params: PParamArray; const Result: Pointer); +begin + PIntegerArray(Result)^ := ps_GetColors(PPointArray(Params^[0])^); +end; + +procedure Lape_findcolor(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_findcolor(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^, Pinteger(Params^[3])^, Pinteger(Params^[4])^, Pinteger(Params^[5])^); +end; + +procedure Lape_findcolortoleranceOptimised(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_findcolortoleranceOptimised(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^, Pinteger(Params^[3])^, Pinteger(Params^[4])^, Pinteger(Params^[5])^, Pinteger(Params^[6])^); +end; + +procedure Lape_findcolortolerance(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_findcolortolerance(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^, Pinteger(Params^[3])^, Pinteger(Params^[4])^, Pinteger(Params^[5])^, Pinteger(Params^[6])^); +end; + +procedure Lape_FindColors(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindColors(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^); +end; + +procedure Lape_SetColorToleranceSpeed(const Params: PParamArray); +begin + ps_SetColorToleranceSpeed(PInteger(Params^[0])^); +end; + +procedure Lape_GetToleranceSpeed(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_GetToleranceSpeed(); +end; + +procedure Lape_SetToleranceSpeed2Modifiers(const Params: PParamArray); +begin + ps_SetToleranceSpeed2Modifiers(PExtended(Params^[0])^, PExtended(Params^[1])^); +end; + +procedure Lape_GetToleranceSpeed2Modifiers(const Params: PParamArray); +begin + ps_GetToleranceSpeed2Modifiers(PExtended(Params^[0])^, PExtended(Params^[1])^); +end; + +procedure Lape_SimilarColors(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_SimilarColors(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^); +end; + +procedure Lape_CountColor(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_CountColor(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^); +end; + +procedure Lape_CountColorTolerance(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_CountColorTolerance(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^); +end; + +procedure Lape_FindColorsToleranceOptimised(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindColorsToleranceOptimised(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[6])^); +end; + +procedure Lape_FindColorsTolerance(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindColorsTolerance(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[6])^); +end; + +procedure Lape_FindColorSpiral(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindColorSpiral(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^); +end; + +procedure Lape_FindColorSpiralTolerance(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindColorSpiralTolerance(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[6])^); +end; + +procedure Lape_FindColorsSpiralTolerance(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_FindColorsSpiralTolerance(PInteger(Params^[0])^, PInteger(Params^[1])^, PPointArray(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[6])^, PInteger(Params^[3])^); +end; + +procedure Lape_FindColoredArea(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindColoredArea(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[2])^); +end; + +procedure Lape_FindColoredAreaTolerance(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindColoredAreaTolerance(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PInteger(Params^[6])^, PInteger(Params^[7])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/colourconv.inc b/Units/MMLAddon/LPInc/Wrappers/colourconv.inc new file mode 100644 index 0000000..07910d9 --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/colourconv.inc @@ -0,0 +1,4 @@ +procedure Lape_ColorToRGB(const Params: PParamArray); +begin + ps_ColorToRGB(Pinteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/crypto.inc b/Units/MMLAddon/LPInc/Wrappers/crypto.inc new file mode 100644 index 0000000..63e2a8b --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/crypto.inc @@ -0,0 +1,4 @@ +procedure Lape_haval(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_haval(Pstring(Params^[0])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/dtm.inc b/Units/MMLAddon/LPInc/Wrappers/dtm.inc new file mode 100644 index 0000000..572b872 --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/dtm.inc @@ -0,0 +1,79 @@ +procedure Lape_FindDTM(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindDTM(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^); +end; + +procedure Lape_FindDTMs(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindDTMs(PInteger(Params^[0])^, PPointArray(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^); +end; + +procedure Lape_FindDTMRotatedAlternating(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindDTMRotatedAlternating(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PExtended(Params^[3])^, PExtended(Params^[4])^, PExtended(Params^[5])^, PExtended(Params^[4])^); +end; + +procedure Lape_FindDTMRotatedSE(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindDTMRotatedSE(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PExtended(Params^[3])^, PExtended(Params^[4])^, PExtended(Params^[5])^, PExtended(Params^[4])^); +end; + +procedure Lape_FindDTMsRotatedAlternating(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindDTMsRotatedAlternating(PInteger(Params^[0])^, PPointArray(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PExtended(Params^[3])^, PExtended(Params^[4])^, PExtended(Params^[5])^, P2DExtendedArray(Params^[4])^); +end; + +procedure Lape_FindDTMsRotatedSE(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindDTMsRotatedSE(PInteger(Params^[0])^, PPointArray(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^, PInteger(Params^[5])^, PExtended(Params^[3])^, PExtended(Params^[4])^, PExtended(Params^[5])^, P2DExtendedArray(Params^[4])^); +end; + +procedure Lape_SetDTMName(const Params: PParamArray); +begin + ps_SetDTMName(Pinteger(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_DTMFromString(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_DTMFromString(PString(Params^[0])^); +end; + +procedure Lape_FreeDTM(const Params: PParamArray); +begin + ps_FreeDTM(PInteger(Params^[0])^); +end; + +procedure Lape_GetDTM(const Params: PParamArray; const Result: Pointer); +begin + PMDTM(Result)^ := ps_GetDTM(PInteger(Params^[0])^); +end; + +procedure Lape_AddTSDTM(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_AddTSDTM(PSDTM(Params^[0])^); +end; + +procedure Lape_AddDTM(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_AddDTM(PMDTM(Params^[0])^); +end; + +procedure Lape_PrintDTM(const Params: PParamArray); +begin + ps_PrintDTM(PMDTM(Params^[0])^); +end; + +procedure Lape_MDTMToSDTM(const Params: PParamArray; const Result: Pointer); +begin + PSDTM(Result)^ := ps_MDTMToSDTM(PMDTM(Params^[0])^); +end; + +procedure Lape_SDTMToMDTM(const Params: PParamArray; const Result: Pointer); +begin + PMDTM(Result)^ := ps_SDTMToMDTM(PSDTM(Params^[0])^); +end; + +procedure Lape_CreateDTMPoint(const Params: PParamArray; const Result: Pointer); +begin + PMDTMPoint(Result)^ := ps_CreateDTMPoint(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^, Pinteger(Params^[3])^, Pinteger(Params^[4])^, Pboolean(Params^[1])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/extensions.inc b/Units/MMLAddon/LPInc/Wrappers/extensions.inc new file mode 100644 index 0000000..0909a15 --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/extensions.inc @@ -0,0 +1,64 @@ +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ext_UnTar(Pstring(Params^[0])^, PStringArray(Params^[1])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ext_UnTarEx(Pstring(Params^[0])^, Pstring(Params^[1])^, Pboolean(Params^[2])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ext_DecompressBZip2(Pstring(Params^[0])^, Pstring(Params^[1])^, PCardinal(Params^[2])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ext_GetPage(Pstring(Params^[0])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ext_MessageDlg(Pstring(Params^[0])^, Pstring(Params^[1])^, PMsgDlgType(Params^[1])^, PMsgDlgButtons(Params^[2])^, PLongint(Params^[3])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + PMDTM(Result)^ := ext_SDTMToMDTM(PSDTM(Params^[0])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ext_InputQuery(PString(Params^[0])^, PString(Params^[1])^, PString(Params^[1])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ext_ScriptText(); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ext_GetSelectedText(); +end; + +procedure Lape_(const Params: PParamArray); +begin + ext_OpenScript(Pstring(Params^[0])^, Pstring(Params^[1])^, Pboolean(Params^[1])^); +end; + +procedure Lape_(const Params: PParamArray); +begin + ext_OpenScriptEx(Pstring(Params^[0])^, Pboolean(Params^[1])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ext_GetPageEx(Pstring(Params^[0])^, Pstring(Params^[1])^, Pstring(Params^[2])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ext_GetJSONValue(Pstring(Params^[0])^, Pstring(Params^[1])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/file.inc b/Units/MMLAddon/LPInc/Wrappers/file.inc new file mode 100644 index 0000000..2fd6685 --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/file.inc @@ -0,0 +1,89 @@ +procedure Lape_CreateFile(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_CreateFile(Pstring(Params^[0])^); +end; + +procedure Lape_OpenFile(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_OpenFile(Pstring(Params^[0])^, PBoolean(Params^[1])^); +end; + +procedure Lape_RewriteFile(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_RewriteFile(Pstring(Params^[0])^, PBoolean(Params^[1])^); +end; + +procedure Lape_AppendFile(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_AppendFile(Pstring(Params^[0])^); +end; + +procedure Lape_CloseFile(const Params: PParamArray); +begin + ps_CloseFile(PInteger(Params^[0])^); +end; + +procedure Lape_EndOfFile(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_EndOfFile(PInteger(Params^[0])^); +end; + +procedure Lape_FileSize(const Params: PParamArray; const Result: Pointer); +begin + PLongInt(Result)^ := ps_FileSize(PInteger(Params^[0])^); +end; + +procedure Lape_ReadFileString(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_ReadFileString(PInteger(Params^[0])^, Pstring(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_WriteFileString(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_WriteFileString(PInteger(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_SetFileCharPointer(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_SetFileCharPointer(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_FilePointerPos(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_FilePointerPos(PInteger(Params^[0])^); +end; + +procedure Lape_FileExists(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FileExists(Pstring(Params^[0])^); +end; + +procedure Lape_DirectoryExists(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_DirectoryExists(Pstring(Params^[0])^); +end; + +procedure Lape_CreateDirectory(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_CreateDirectory(Pstring(Params^[0])^); +end; + +procedure Lape_ForceDirectores(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_ForceDirectores(Pstring(Params^[0])^); +end; + +procedure Lape_GetFiles(const Params: PParamArray; const Result: Pointer); +begin + PStringArray(Result)^ := ps_GetFiles(Pstring(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_GetDirectories(const Params: PParamArray; const Result: Pointer); +begin + PStringArray(Result)^ := ps_GetDirectories(Pstring(Params^[0])^); +end; + +procedure Lape_WriteINI(const Params: PParamArray); +begin + ps_WriteINI(Pstring(Params^[0])^, Pstring(Params^[1])^, Pstring(Params^[2])^, Pstring(Params^[3])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/internets.inc b/Units/MMLAddon/LPInc/Wrappers/internets.inc new file mode 100644 index 0000000..e4651c3 --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/internets.inc @@ -0,0 +1,124 @@ +procedure Lape_OpenWebPage(const Params: PParamArray); +begin + ps_OpenWebPage(Pstring(Params^[0])^); +end; + +procedure Lape_GetPage(const Params: PParamArray; const Result: Pointer); +begin + PString(Result)^ := ps_GetPage(PString(Params^[0])^); +end; + +procedure Lape_InitializeHTTPClient(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_InitializeHTTPClient(PBoolean(Params^[0])^); +end; + +procedure Lape_FreeHTTPClient(const Params: PParamArray); +begin + ps_FreeHTTPClient(PInteger(Params^[0])^); +end; + +procedure Lape_GetHTTPPage(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_GetHTTPPage(PInteger(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_SetHTTPUserAgent(const Params: PParamArray); +begin + ps_SetHTTPUserAgent(PInteger(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_PostHTTPPage(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_PostHTTPPage(PInteger(Params^[0])^, Pstring(Params^[1])^, Pstring(Params^[2])^); +end; + +procedure Lape_PostHTTPPageEx(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_PostHTTPPageEx(PInteger(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_ClearPostData(const Params: PParamArray); +begin + ps_ClearPostData(PInteger(Params^[0])^); +end; + +procedure Lape_AddPostVariable(const Params: PParamArray); +begin + ps_AddPostVariable(PInteger(Params^[0])^, Pstring(Params^[1])^, Pstring(Params^[2])^); +end; + +procedure Lape_GetRawHeaders(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_GetRawHeaders(PInteger(Params^[0])^); +end; + +procedure Lape_SetProxy(const Params: PParamArray); +begin + ps_SetProxy(PInteger(Params^[0])^, PString(Params^[1])^, PString(Params^[2])^); +end; + +procedure Lape_RecvSocketStr(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_RecvSocketStr(Pinteger(Params^[0])^); +end; + +procedure Lape_RecvSocket(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_RecvSocket(Pinteger(Params^[0])^); +end; + +procedure Lape_RecvSocketEx(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_RecvSocketEx(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_SendSocket(const Params: PParamArray); +begin + ps_SendSocket(Pinteger(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_ConnectSocket(const Params: PParamArray); +begin + ps_ConnectSocket(Pinteger(Params^[0])^, Pstring(Params^[1])^, Pstring(Params^[2])^); +end; + +procedure Lape_CloseSocket(const Params: PParamArray); +begin + ps_CloseSocket(Pinteger(Params^[0])^); +end; + +procedure Lape_SetSocketTimeout(const Params: PParamArray); +begin + ps_SetSocketTimeout(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_BindSocket(const Params: PParamArray); +begin + ps_BindSocket(Pinteger(Params^[0])^, Pstring(Params^[1])^, Pstring(Params^[2])^); +end; + +procedure Lape_ListenSocket(const Params: PParamArray); +begin + ps_ListenSocket(Pinteger(Params^[0])^); +end; + +procedure Lape_AcceptSocket(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_AcceptSocket(Pinteger(Params^[0])^); +end; + +procedure Lape_SocketInfo(const Params: PParamArray); +begin + ps_SocketInfo(Pinteger(Params^[0])^, Pstring(Params^[1])^, Pstring(Params^[2])^); +end; + +procedure Lape_CreateSocket(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_CreateSocket(); +end; + +procedure Lape_FreeSocket(const Params: PParamArray); +begin + ps_FreeSocket(Pinteger(Params^[0])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/keyboard.inc b/Units/MMLAddon/LPInc/Wrappers/keyboard.inc new file mode 100644 index 0000000..9ff164e --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/keyboard.inc @@ -0,0 +1,29 @@ +procedure Lape_KeyDown(const Params: PParamArray); +begin + ps_KeyDown(PWord(Params^[0])^); +end; + +procedure Lape_KeyUp(const Params: PParamArray); +begin + ps_KeyUp(PWord(Params^[0])^); +end; + +procedure Lape_SendKeys(const Params: PParamArray); +begin + ps_SendKeys(Pstring(Params^[0])^); +end; + +procedure Lape_PressKey(const Params: PParamArray); +begin + ps_PressKey(PWord(Params^[0])^); +end; + +procedure Lape_isKeyDown(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_isKeyDown(PWord(Params^[0])^); +end; + +procedure Lape_GetKeyCode(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_GetKeyCode(Pchar(Params^[0])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/math.inc b/Units/MMLAddon/LPInc/Wrappers/math.inc new file mode 100644 index 0000000..7e93b02 --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/math.inc @@ -0,0 +1,114 @@ +procedure Lape_round(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_round(Pextended(Params^[0])^); +end; + +procedure Lape_iAbs(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_iAbs(Pinteger(Params^[0])^); +end; + +procedure Lape_ceil(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_ceil(Pextended(Params^[0])^); +end; + +procedure Lape_pow(const Params: PParamArray; const Result: Pointer); +begin + Pextended(Result)^ := ps_pow(Pextended(Params^[0])^, Pextended(Params^[1])^); +end; + +procedure Lape_RiemannGauss(const Params: PParamArray; const Result: Pointer); +begin + Pextended(Result)^ := ps_RiemannGauss(Pextended(Params^[0])^, Pextended(Params^[1])^, Pextended(Params^[2])^, Pinteger(Params^[1])^); +end; + +procedure Lape_DiscreteGauss(const Params: PParamArray; const Result: Pointer); +begin + PExtendedArray(Result)^ := ps_DiscreteGauss(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pextended(Params^[1])^); +end; + +procedure Lape_GaussMatrix(const Params: PParamArray; const Result: Pointer); +begin + P2DExtendedArray(Result)^ := ps_GaussMatrix(Pinteger(Params^[0])^, Pextended(Params^[1])^); +end; + +procedure Lape_exp(const Params: PParamArray; const Result: Pointer); +begin + Pextended(Result)^ := ps_exp(Pextended(Params^[0])^); +end; + +procedure Lape_Max(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_Max(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_Min(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_Min(PInteger(Params^[0])^, PInteger(Params^[1])^); +end; + +procedure Lape_MinE(const Params: PParamArray; const Result: Pointer); +begin + Pextended(Result)^ := ps_MinE(Pextended(Params^[0])^, Pextended(Params^[1])^); +end; + +procedure Lape_MaxE(const Params: PParamArray; const Result: Pointer); +begin + Pextended(Result)^ := ps_MaxE(Pextended(Params^[0])^, Pextended(Params^[1])^); +end; + +procedure Lape_Sqr(const Params: PParamArray; const Result: Pointer); +begin + Pextended(Result)^ := ps_Sqr(Pextended(Params^[0])^); +end; + +procedure Lape_Point(const Params: PParamArray; const Result: Pointer); +begin + PPoint(Result)^ := ps_Point(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_Distance(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_Distance(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^, Pinteger(Params^[3])^); +end; + +procedure Lape_Hypot(const Params: PParamArray; const Result: Pointer); +begin + PExtended(Result)^ := ps_Hypot(PExtended(Params^[0])^, PExtended(Params^[1])^); +end; + +procedure Lape_RandomRange(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_RandomRange(PInteger(Params^[0])^, PInteger(Params^[1])^); +end; + +procedure Lape_Random(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_Random(Pinteger(Params^[0])^); +end; + +procedure Lape_RandomE(const Params: PParamArray; const Result: Pointer); +begin + Pextended(Result)^ := ps_RandomE(); +end; + +procedure Lape_ArcTan2(const Params: PParamArray; const Result: Pointer); +begin + Pextended(Result)^ := ps_ArcTan2(Pextended(Params^[0])^, Pextended(Params^[1])^); +end; + +procedure Lape_IncEx(const Params: PParamArray); +begin + ps_IncEx(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_DecEx(const Params: PParamArray); +begin + ps_DecEx(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_Factorial(const Params: PParamArray; const Result: Pointer); +begin + PInt64(Result)^ := ps_Factorial(Plongword(Params^[0])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/mouse.inc b/Units/MMLAddon/LPInc/Wrappers/mouse.inc new file mode 100644 index 0000000..acaf68e --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/mouse.inc @@ -0,0 +1,39 @@ +procedure Lape_MoveMouse(const Params: PParamArray); +begin + ps_MoveMouse(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_ScrollMouse(const Params: PParamArray); +begin + ps_ScrollMouse(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[1])^); +end; + +procedure Lape_GetMousePos(const Params: PParamArray); +begin + ps_GetMousePos(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_(const Params: PParamArray; const Result: Pointer); +begin + PClickType(Result)^ := ConvIntClickType(PInteger(Params^[0])^); +end; + +procedure Lape_HoldMouse(const Params: PParamArray); +begin + ps_HoldMouse(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[1])^); +end; + +procedure Lape_ReleaseMouse(const Params: PParamArray); +begin + ps_ReleaseMouse(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[1])^); +end; + +procedure Lape_ClickMouse(const Params: PParamArray); +begin + ps_ClickMouse(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[1])^); +end; + +procedure Lape_IsMouseButtonDown(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_IsMouseButtonDown(Pinteger(Params^[0])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/ocr.inc b/Units/MMLAddon/LPInc/Wrappers/ocr.inc new file mode 100644 index 0000000..e15dd82 --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/ocr.inc @@ -0,0 +1,19 @@ +procedure Lape_rs_GetUpText(const Params: PParamArray; const Result: Pointer); +begin + PString(Result)^ := ps_rs_GetUpText(); +end; + +procedure Lape_rs_GetUpTextAtEx(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_rs_GetUpTextAtEx(Pinteger(Params^[0])^, Pinteger(Params^[1])^, Pboolean(Params^[1])^); +end; + +procedure Lape_rs_GetUpTextAt(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_rs_GetUpTextAt(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_BitmapFromText(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_BitmapFromText(PString(Params^[0])^, PString(Params^[1])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/other.inc b/Units/MMLAddon/LPInc/Wrappers/other.inc new file mode 100644 index 0000000..4a7969c --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/other.inc @@ -0,0 +1,19 @@ +procedure Lape_Writeln(const Params: PParamArray); +begin + ps_Writeln(Pstring(Params^[0])^); +end; + +procedure Lape_SetScriptProp(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_SetScriptProp(PSP_Property(Params^[0])^, PVariantArray(Params^[1])^); +end; + +procedure Lape_GetScriptProp(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_GetScriptProp(PSP_Property(Params^[0])^, PVariantArray(Params^[1])^); +end; + +procedure Lape_Wait(const Params: PParamArray); +begin + ps_Wait(PDWord(Params^[0])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/settings.inc b/Units/MMLAddon/LPInc/Wrappers/settings.inc new file mode 100644 index 0000000..f865eb6 --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/settings.inc @@ -0,0 +1,39 @@ +procedure Lape_SetSettingValue(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_SetSettingValue(Pstring(Params^[0])^, Pstring(Params^[1])^); +end; + +procedure Lape_KeyIsSetting(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_KeyIsSetting(PString(Params^[0])^); +end; + +procedure Lape_KeyIsDirectory(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_KeyIsDirectory(PString(Params^[0])^); +end; + +procedure Lape_GetSettingValue(const Params: PParamArray; const Result: Pointer); +begin + PString(Result)^ := ps_GetSettingValue(PString(Params^[0])^); +end; + +procedure Lape_GetSettingValueDef(const Params: PParamArray; const Result: Pointer); +begin + PString(Result)^ := ps_GetSettingValueDef(PString(Params^[0])^, PString(Params^[1])^); +end; + +procedure Lape_ListSettings(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_ListSettings(PString(Params^[0])^, PStringArray(Params^[1])^); +end; + +procedure Lape_DeleteSetting(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_DeleteSetting(PString(Params^[0])^); +end; + +procedure Lape_DeleteSubSettings(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_DeleteSubSettings(PString(Params^[0])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/strings.inc b/Units/MMLAddon/LPInc/Wrappers/strings.inc new file mode 100644 index 0000000..a09298f --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/strings.inc @@ -0,0 +1,84 @@ +procedure Lape_Capitalize(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_Capitalize(Pstring(Params^[0])^); +end; + +procedure Lape_CompressString(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_CompressString(Pstring(Params^[0])^); +end; + +procedure Lape_DecompressString(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_DecompressString(Pstring(Params^[0])^); +end; + +procedure Lape_Base64Encode(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_Base64Encode(Pstring(Params^[0])^); +end; + +procedure Lape_Base64Decode(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_Base64Decode(Pstring(Params^[0])^); +end; + +procedure Lape_ExtractFromStr(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_ExtractFromStr(Pstring(Params^[0])^, PStrExtr(Params^[1])^); +end; + +procedure Lape_BoolToStr(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_BoolToStr(Pboolean(Params^[0])^); +end; + +procedure Lape_Replace(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_Replace(Pstring(Params^[0])^, Pstring(Params^[1])^, Pstring(Params^[2])^, PReplaceFlags(Params^[1])^); +end; + +procedure Lape_IntToStr(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_IntToStr(Pinteger(Params^[0])^); +end; + +procedure Lape_FloatToStr(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_FloatToStr(Pextended(Params^[0])^); +end; + +procedure Lape_StrToInt(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_StrToInt(PString(Params^[0])^); +end; + +procedure Lape_StrToIntDef(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_StrToIntDef(PString(Params^[0])^, PInteger(Params^[1])^); +end; + +procedure Lape_StrToFloat(const Params: PParamArray; const Result: Pointer); +begin + PExtended(Result)^ := ps_StrToFloat(PString(Params^[0])^); +end; + +procedure Lape_StrToFloatDef(const Params: PParamArray; const Result: Pointer); +begin + PExtended(Result)^ := ps_StrToFloatDef(PString(Params^[0])^, PExtended(Params^[1])^); +end; + +procedure Lape_StrToBool(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_StrToBool(PString(Params^[0])^); +end; + +procedure Lape_StrToBoolDef(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_StrToBoolDef(PString(Params^[0])^, PBoolean(Params^[1])^); +end; + +procedure Lape_Between(const Params: PParamArray; const Result: Pointer); +begin + Pstring(Result)^ := ps_Between(Pstring(Params^[0])^, Pstring(Params^[1])^, Pstring(Params^[2])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/tpa.inc b/Units/MMLAddon/LPInc/Wrappers/tpa.inc new file mode 100644 index 0000000..51773bf --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/tpa.inc @@ -0,0 +1,424 @@ +procedure Lape_Quicksort(const Params: PParamArray); +begin + ps_Quicksort(PIntegerArray(Params^[0])^); +end; + +procedure Lape_tSwap(const Params: PParamArray); +begin + ps_tSwap(PPoint(Params^[0])^, PPoint(Params^[1])^); +end; + +procedure Lape_tpaSwap(const Params: PParamArray); +begin + ps_tpaSwap(PPointArray(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_SwapE(const Params: PParamArray); +begin + ps_SwapE(PExtended(Params^[0])^, PExtended(Params^[1])^); +end; + +procedure Lape_RAaSTPAEx(const Params: PParamArray); +begin + ps_RAaSTPAEx(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_RAaSTPA(const Params: PParamArray); +begin + ps_RAaSTPA(PPointArray(Params^[0])^, PInteger(Params^[1])^); +end; + +procedure Lape_NearbyPointInArrayEx(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_NearbyPointInArrayEx(PPoint(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PPointArray(Params^[2])^); +end; + +procedure Lape_NearbyPointInArray(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_NearbyPointInArray(PPoint(Params^[0])^, PInteger(Params^[1])^, PPointArray(Params^[2])^); +end; + +procedure Lape_QuickTPASort(const Params: PParamArray); +begin + ps_QuickTPASort(PIntegerArray(Params^[0])^, PPointArray(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PBoolean(Params^[3])^); +end; + +procedure Lape_QuickATPASort(const Params: PParamArray); +begin + ps_QuickATPASort(PIntegerArray(Params^[0])^, P2DPointArray(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PBoolean(Params^[3])^); +end; + +procedure Lape_SortTPAFrom(const Params: PParamArray); +begin + ps_SortTPAFrom(PPointArray(Params^[0])^, PPoint(Params^[1])^); +end; + +procedure Lape_SortATPAFrom(const Params: PParamArray); +begin + ps_SortATPAFrom(P2DPointArray(Params^[0])^, PPoint(Params^[1])^); +end; + +procedure Lape_SortATPAFromFirstPoint(const Params: PParamArray); +begin + ps_SortATPAFromFirstPoint(P2DPointArray(Params^[0])^, PPoint(Params^[1])^); +end; + +procedure Lape_InvertTPA(const Params: PParamArray); +begin + ps_InvertTPA(PPointArray(Params^[0])^); +end; + +procedure Lape_InvertATPA(const Params: PParamArray); +begin + ps_InvertATPA(P2DPointArray(Params^[0])^); +end; + +procedure Lape_MiddleTPAEx(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_MiddleTPAEx(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_MiddleTPA(const Params: PParamArray; const Result: Pointer); +begin + PPoint(Result)^ := ps_MiddleTPA(PPointArray(Params^[0])^); +end; + +procedure Lape_SortATPASize(const Params: PParamArray); +begin + ps_SortATPASize(P2DPointArray(Params^[0])^, PBoolean(Params^[1])^); +end; + +procedure Lape_SortATPAFromSize(const Params: PParamArray); +begin + ps_SortATPAFromSize(P2DPointArray(Params^[0])^, PInteger(Params^[1])^, PBoolean(Params^[2])^); +end; + +procedure Lape_InIntArrayEx(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_InIntArrayEx(PIntegerArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_InIntArray(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_InIntArray(PIntegerArray(Params^[0])^, PInteger(Params^[1])^); +end; + +procedure Lape_ClearSameIntegers(const Params: PParamArray); +begin + ps_ClearSameIntegers(PIntegerArray(Params^[0])^); +end; + +procedure Lape_ClearSameIntegersAndTPA(const Params: PParamArray); +begin + ps_ClearSameIntegersAndTPA(PIntegerArray(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_SplitTPAEx(const Params: PParamArray; const Result: Pointer); +begin + P2DPointArray(Result)^ := ps_SplitTPAEx(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_SplitTPA(const Params: PParamArray; const Result: Pointer); +begin + P2DPointArray(Result)^ := ps_SplitTPA(PPointArray(Params^[0])^, PInteger(Params^[1])^); +end; + +procedure Lape_FloodFillTPA(const Params: PParamArray; const Result: Pointer); +begin + P2DPointArray(Result)^ := ps_FloodFillTPA(PPointArray(Params^[0])^); +end; + +procedure Lape_FilterPointsPie(const Params: PParamArray); +begin + ps_FilterPointsPie(PPointArray(Params^[0])^, PExtended(Params^[1])^, PExtended(Params^[2])^, PExtended(Params^[3])^, PExtended(Params^[4])^, PInteger(Params^[2])^, PInteger(Params^[3])^); +end; + +procedure Lape_FilterPointsDist(const Params: PParamArray); +begin + ps_FilterPointsDist(PPointArray(Params^[0])^, PExtended(Params^[1])^, PExtended(Params^[2])^, PInteger(Params^[2])^, PInteger(Params^[3])^); +end; + +procedure Lape_FilterPointsLine(const Params: PParamArray); +begin + ps_FilterPointsLine(PPointArray(Params^[0])^, PExtended(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PInteger(Params^[4])^); +end; + +procedure Lape_FilterTPADist(const Params: PParamArray); +begin + ps_FilterTPADist(PPointArray(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_GetATPABounds(const Params: PParamArray; const Result: Pointer); +begin + PBox(Result)^ := ps_GetATPABounds(P2DPointArray(Params^[0])^); +end; + +procedure Lape_GetTPABounds(const Params: PParamArray; const Result: Pointer); +begin + PBox(Result)^ := ps_GetTPABounds(PPointArray(Params^[0])^); +end; + +procedure Lape_FindTPAinTPA(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindTPAinTPA(PPointArray(Params^[0])^, PPointArray(Params^[1])^, PPointArray(Params^[1])^); +end; + +procedure Lape_GetSamePointsATPA(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_GetSamePointsATPA(P2DPointArray(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_FindTextTPAinTPA(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_FindTextTPAinTPA(Pinteger(Params^[0])^, PPointArray(Params^[1])^, PPointArray(Params^[2])^, PPointArray(Params^[2])^); +end; + +procedure Lape_SortCircleWise(const Params: PParamArray); +begin + ps_SortCircleWise(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PBoolean(Params^[2])^, PBoolean(Params^[3])^); +end; + +procedure Lape_LinearSort(const Params: PParamArray); +begin + ps_LinearSort(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PInteger(Params^[3])^, PBoolean(Params^[2])^); +end; + +procedure Lape_RotatePoint(const Params: PParamArray; const Result: Pointer); +begin + PPoint(Result)^ := ps_RotatePoint(PPoint(Params^[0])^, PExtended(Params^[1])^, PExtended(Params^[2])^, PExtended(Params^[3])^); +end; + +procedure Lape_ChangeDistPT(const Params: PParamArray; const Result: Pointer); +begin + PPoint(Result)^ := ps_ChangeDistPT(PPoint(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^, Pextended(Params^[2])^); +end; + +procedure Lape_ChangeDistTPA(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_ChangeDistTPA(PPointArray(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^, Pextended(Params^[2])^); +end; + +procedure Lape_FindGapsTPA(const Params: PParamArray; const Result: Pointer); +begin + P2DPointArray(Result)^ := ps_FindGapsTPA(PPointArray(Params^[0])^, PInteger(Params^[1])^); +end; + +procedure Lape_RemoveDistTPointArray(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_RemoveDistTPointArray(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PPointArray(Params^[1])^, PBoolean(Params^[2])^); +end; + +procedure Lape_CombineTPA(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_CombineTPA(PPointArray(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_ReArrangeandShortenArrayEx(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_ReArrangeandShortenArrayEx(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_ReArrangeandShortenArray(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_ReArrangeandShortenArray(PPointArray(Params^[0])^, PInteger(Params^[1])^); +end; + +procedure Lape_TPAtoATPAEx(const Params: PParamArray; const Result: Pointer); +begin + P2DPointArray(Result)^ := ps_TPAtoATPAEx(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^); +end; + +procedure Lape_TPAtoATPA(const Params: PParamArray; const Result: Pointer); +begin + P2DPointArray(Result)^ := ps_TPAtoATPA(PPointArray(Params^[0])^, PInteger(Params^[1])^); +end; + +procedure Lape_CombineIntArray(const Params: PParamArray; const Result: Pointer); +begin + PIntegerArray(Result)^ := ps_CombineIntArray(PIntegerArray(Params^[0])^, PIntegerArray(Params^[1])^); +end; + +procedure Lape_MergeATPA(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_MergeATPA(P2DPointArray(Params^[0])^); +end; + +procedure Lape_AppendTPA(const Params: PParamArray); +begin + ps_AppendTPA(PPointArray(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_TPAFromBox(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_TPAFromBox(PBox(Params^[0])^); +end; + +procedure Lape_RotatePoints(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_RotatePoints(PPointArray(Params^[0])^, PExtended(Params^[1])^, PExtended(Params^[2])^, PExtended(Params^[3])^); +end; + +procedure Lape_FindTPAEdges(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_FindTPAEdges(PPointArray(Params^[0])^); +end; + +procedure Lape_ClearTPAFromTPA(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_ClearTPAFromTPA(PPointArray(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_ReturnPointsNotInTPA(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_ReturnPointsNotInTPA(PPointArray(Params^[0])^, PBox(Params^[1])^); +end; + +procedure Lape_PointInTPA(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_PointInTPA(PPoint(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_ClearDoubleTPA(const Params: PParamArray); +begin + ps_ClearDoubleTPA(PPointArray(Params^[0])^); +end; + +procedure Lape_TPACountSort(const Params: PParamArray); +begin + ps_TPACountSort(PPointArray(Params^[0])^, PPoint(Params^[1])^, PBoolean(Params^[2])^); +end; + +procedure Lape_TPACountSortBase(const Params: PParamArray); +begin + ps_TPACountSortBase(PPointArray(Params^[0])^, PPoint(Params^[1])^, PPoint(Params^[2])^, PBoolean(Params^[2])^); +end; + +procedure Lape_InvertTIA(const Params: PParamArray); +begin + ps_InvertTIA(PIntegerArray(Params^[0])^); +end; + +procedure Lape_SumIntegerArray(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_SumIntegerArray(PIntegerArray(Params^[0])^); +end; + +procedure Lape_AverageTIA(const Params: PParamArray; const Result: Pointer); +begin + PInteger(Result)^ := ps_AverageTIA(PIntegerArray(Params^[0])^); +end; + +procedure Lape_AverageExtended(const Params: PParamArray; const Result: Pointer); +begin + PExtended(Result)^ := ps_AverageExtended(PExtendedArray(Params^[0])^); +end; + +procedure Lape_SplitTPAExWrap(const Params: PParamArray); +begin + ps_SplitTPAExWrap(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, P2DPointArray(Params^[2])^); +end; + +procedure Lape_SplitTPAWrap(const Params: PParamArray); +begin + ps_SplitTPAWrap(PPointArray(Params^[0])^, PInteger(Params^[1])^, P2DPointArray(Params^[2])^); +end; + +procedure Lape_FindGapsTPAWrap(const Params: PParamArray); +begin + ps_FindGapsTPAWrap(PPointArray(Params^[0])^, PInteger(Params^[1])^, P2DPointArray(Params^[2])^); +end; + +procedure Lape_RemoveDistTPointArrayWrap(const Params: PParamArray); +begin + ps_RemoveDistTPointArrayWrap(PInteger(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PPointArray(Params^[1])^, PBoolean(Params^[2])^, PPointArray(Params^[3])^); +end; + +procedure Lape_CombineTPAWrap(const Params: PParamArray); +begin + ps_CombineTPAWrap(PPointArray(Params^[0])^, PPointArray(Params^[1])^, PPointArray(Params^[1])^); +end; + +procedure Lape_ReArrangeandShortenArrayExWrap(const Params: PParamArray); +begin + ps_ReArrangeandShortenArrayExWrap(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, PPointArray(Params^[2])^); +end; + +procedure Lape_ReArrangeandShortenArrayWrap(const Params: PParamArray); +begin + ps_ReArrangeandShortenArrayWrap(PPointArray(Params^[0])^, PInteger(Params^[1])^, PPointArray(Params^[2])^); +end; + +procedure Lape_TPAtoATPAExWrap(const Params: PParamArray); +begin + ps_TPAtoATPAExWrap(PPointArray(Params^[0])^, PInteger(Params^[1])^, PInteger(Params^[2])^, P2DPointArray(Params^[2])^); +end; + +procedure Lape_TPAtoATPAWrap(const Params: PParamArray); +begin + ps_TPAtoATPAWrap(PPointArray(Params^[0])^, PInteger(Params^[1])^, P2DPointArray(Params^[2])^); +end; + +procedure Lape_CombineIntArrayWrap(const Params: PParamArray); +begin + ps_CombineIntArrayWrap(PIntegerArray(Params^[0])^, PIntegerArray(Params^[1])^, PIntegerArray(Params^[1])^); +end; + +procedure Lape_MergeATPAWrap(const Params: PParamArray); +begin + ps_MergeATPAWrap(P2DPointArray(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_TPAFromBoxWrap(const Params: PParamArray); +begin + ps_TPAFromBoxWrap(PBox(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_RotatePointsWrap(const Params: PParamArray); +begin + ps_RotatePointsWrap(PPointArray(Params^[0])^, PExtended(Params^[1])^, PExtended(Params^[2])^, PExtended(Params^[3])^, PPointArray(Params^[2])^); +end; + +procedure Lape_FindTPAEdgesWrap(const Params: PParamArray); +begin + ps_FindTPAEdgesWrap(PPointArray(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_ClearTPAFromTPAWrap(const Params: PParamArray); +begin + ps_ClearTPAFromTPAWrap(PPointArray(Params^[0])^, PPointArray(Params^[1])^, PPointArray(Params^[1])^); +end; + +procedure Lape_ReturnPointsNotInTPAWrap(const Params: PParamArray); +begin + ps_ReturnPointsNotInTPAWrap(PPointArray(Params^[0])^, PBox(Params^[1])^, PPointArray(Params^[2])^); +end; + +procedure Lape_SameTPA(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_SameTPA(PPointArray(Params^[0])^, PPointArray(Params^[1])^); +end; + +procedure Lape_TPAInATPA(const Params: PParamArray; const Result: Pointer); +begin + PBoolean(Result)^ := ps_TPAInATPA(PPointArray(Params^[0])^, P2DPointArray(Params^[1])^, PLongInt(Params^[2])^); +end; + +procedure Lape_OffsetTPA(const Params: PParamArray); +begin + ps_OffsetTPA(PPointArray(Params^[0])^, PPoint(Params^[1])^); +end; + +procedure Lape_OffsetATPA(const Params: PParamArray); +begin + ps_OffsetATPA(P2DPointArray(Params^[0])^, PPoint(Params^[1])^); +end; + +procedure Lape_CopyTPA(const Params: PParamArray; const Result: Pointer); +begin + PPointArray(Result)^ := ps_CopyTPA(PPointArray(Params^[0])^); +end; + +procedure Lape_CopyATPA(const Params: PParamArray; const Result: Pointer); +begin + P2DPointArray(Result)^ := ps_CopyATPA(P2DPointArray(Params^[0])^); +end; diff --git a/Units/MMLAddon/LPInc/Wrappers/window.inc b/Units/MMLAddon/LPInc/Wrappers/window.inc new file mode 100644 index 0000000..7d70e4b --- /dev/null +++ b/Units/MMLAddon/LPInc/Wrappers/window.inc @@ -0,0 +1,84 @@ +procedure Lape_SetDesktopAsClient(const Params: PParamArray); +begin + ps_SetDesktopAsClient(); +end; + +procedure Lape_SetTargetArray(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_SetTargetArray(PInteger(Params^[0])^, Pinteger(Params^[1])^, Pinteger(Params^[2])^); +end; + +procedure Lape_SetTargetBitmap(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_SetTargetBitmap(PInteger(Params^[0])^); +end; + +procedure Lape_SetEIOSTarget(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_SetEIOSTarget(Pstring(Params^[0])^, PVariant(Params^[1])^); +end; + +procedure Lape_SetImageTarget(const Params: PParamArray); +begin + ps_SetImageTarget(Pinteger(Params^[0])^); +end; + +procedure Lape_SetKeyMouseTarget(const Params: PParamArray); +begin + ps_SetKeyMouseTarget(Pinteger(Params^[0])^); +end; + +procedure Lape_GetImageTarget(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_GetImageTarget(); +end; + +procedure Lape_GetKeyMouseTarget(const Params: PParamArray; const Result: Pointer); +begin + Pinteger(Result)^ := ps_GetKeyMouseTarget(); +end; + +procedure Lape_ExportImageTarget(const Params: PParamArray; const Result: Pointer); +begin + PTarget_Exported(Result)^ := ps_ExportImageTarget(); +end; + +procedure Lape_ExportKeyMouseTarget(const Params: PParamArray; const Result: Pointer); +begin + PTarget_Exported(Result)^ := ps_ExportKeyMouseTarget(); +end; + +procedure Lape_FreeTarget(const Params: PParamArray); +begin + ps_FreeTarget(Pinteger(Params^[0])^); +end; + +procedure Lape_GetClientDimensions(const Params: PParamArray); +begin + ps_GetClientDimensions(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_GetClientPosition(const Params: PParamArray); +begin + ps_GetClientPosition(Pinteger(Params^[0])^, Pinteger(Params^[1])^); +end; + +procedure Lape_Freeze(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_Freeze(); +end; + +procedure Lape_Unfreeze(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_Unfreeze(); +end; + +procedure Lape_ActivateClient(const Params: PParamArray); +begin + ps_ActivateClient(); +end; + +procedure Lape_IsTargetValid(const Params: PParamArray; const Result: Pointer); +begin + Pboolean(Result)^ := ps_IsTargetValid(); +end; diff --git a/Units/MMLAddon/LPInc/lpexportedmethods.inc b/Units/MMLAddon/LPInc/lpexportedmethods.inc index e6eeb8d..6c57193 100644 --- a/Units/MMLAddon/LPInc/lpexportedmethods.inc +++ b/Units/MMLAddon/LPInc/lpexportedmethods.inc @@ -21,4 +21,5 @@ lpexportedmethods.inc for the Mufasa Macro Library } -//These will be added from Generator... \ No newline at end of file +{$I lpexportedmethodsinc.inc} +//These will be added from Generator... diff --git a/Units/MMLAddon/LPInc/lpexportedmethodsinc.inc b/Units/MMLAddon/LPInc/lpexportedmethodsinc.inc new file mode 100644 index 0000000..1599305 --- /dev/null +++ b/Units/MMLAddon/LPInc/lpexportedmethodsinc.inc @@ -0,0 +1,319 @@ +AddGlobalFunc('procedure ps_SetDesktopAsClient;', @Lape_SetDesktopAsClient); +AddGlobalFunc('function ps_SetTargetArray(P: Integer; w, h: integer): integer', @Lape_SetTargetArray); +AddGlobalFunc('function ps_SetTargetBitmap(bitmap: Integer): integer', @Lape_SetTargetBitmap); +AddGlobalFunc('function ps_SetEIOSTarget(name: string; args: Variant): integer', @Lape_SetEIOSTarget); +AddGlobalFunc('procedure ps_SetImageTarget(idx: integer);', @Lape_SetImageTarget); +AddGlobalFunc('procedure ps_SetKeyMouseTarget(idx: integer);', @Lape_SetKeyMouseTarget); +AddGlobalFunc('function ps_GetImageTarget: integer', @Lape_GetImageTarget); +AddGlobalFunc('function ps_GetKeyMouseTarget: integer', @Lape_GetKeyMouseTarget); +AddGlobalFunc('function ps_ExportImageTarget: TTarget_Exported', @Lape_ExportImageTarget); +AddGlobalFunc('function ps_ExportKeyMouseTarget: TTarget_Exported', @Lape_ExportKeyMouseTarget); +AddGlobalFunc('procedure ps_FreeTarget(idx: integer);', @Lape_FreeTarget); +AddGlobalFunc('procedure ps_GetClientDimensions(var w, h: integer);', @Lape_GetClientDimensions); +AddGlobalFunc('procedure ps_GetClientPosition(var left, top: integer);', @Lape_GetClientPosition); +AddGlobalFunc('function ps_Freeze: boolean', @Lape_Freeze); +AddGlobalFunc('function ps_Unfreeze: boolean', @Lape_Unfreeze); +AddGlobalFunc('procedure ps_ActivateClient;', @Lape_ActivateClient); +AddGlobalFunc('function ps_IsTargetValid: boolean', @Lape_IsTargetValid); +AddGlobalFunc('procedure ps_Quicksort(var Arr: TIntegerArray);', @Lape_Quicksort); +AddGlobalFunc('procedure ps_tSwap(var a, b: TPoint);', @Lape_tSwap); +AddGlobalFunc('procedure ps_tpaSwap(var a, b: TPointArray);', @Lape_tpaSwap); +AddGlobalFunc('procedure ps_SwapE(var a, b: Extended);', @Lape_SwapE); +AddGlobalFunc('procedure ps_RAaSTPAEx(var a: TPointArray; const w, h: Integer);', @Lape_RAaSTPAEx); +AddGlobalFunc('procedure ps_RAaSTPA(var a: TPointArray; const Dist: Integer);', @Lape_RAaSTPA); +AddGlobalFunc('function ps_NearbyPointInArrayEx(const P: TPoint; w, h: Integer; const a: TPointArray): Boolean', @Lape_NearbyPointInArrayEx); +AddGlobalFunc('function ps_NearbyPointInArray(const P: TPoint; Dist: Integer; const a: TPointArray): Boolean', @Lape_NearbyPointInArray); +AddGlobalFunc('procedure ps_QuickTPASort(var A: TIntegerArray; var B: TPointArray; iLo, iHi: Integer; SortUp: Boolean);', @Lape_QuickTPASort); +AddGlobalFunc('procedure ps_QuickATPASort(var A: TIntegerArray; var B: T2DPointArray; iLo, iHi: Integer; SortUp: Boolean);', @Lape_QuickATPASort); +AddGlobalFunc('procedure ps_SortTPAFrom(var a: TPointArray; const From: TPoint);', @Lape_SortTPAFrom); +AddGlobalFunc('procedure ps_SortATPAFrom(var a: T2DPointArray; const From: TPoint);', @Lape_SortATPAFrom); +AddGlobalFunc('procedure ps_SortATPAFromFirstPoint(var a: T2DPointArray; const From: TPoint);', @Lape_SortATPAFromFirstPoint); +AddGlobalFunc('procedure ps_InvertTPA(var a: TPointArray);', @Lape_InvertTPA); +AddGlobalFunc('procedure ps_InvertATPA(var a: T2DPointArray);', @Lape_InvertATPA); +AddGlobalFunc('function ps_MiddleTPAEx(const TPA: TPointArray; var x, y: Integer): Boolean', @Lape_MiddleTPAEx); +AddGlobalFunc('function ps_MiddleTPA(const tpa: TPointArray): TPoint', @Lape_MiddleTPA); +AddGlobalFunc('procedure ps_SortATPASize(var a: T2DPointArray; const BigFirst: Boolean);', @Lape_SortATPASize); +AddGlobalFunc('procedure ps_SortATPAFromSize(var a: T2DPointArray; const Size: Integer; CloseFirst: Boolean);', @Lape_SortATPAFromSize); +AddGlobalFunc('function ps_InIntArrayEx(const a: TIntegerArray; var Where: Integer; const Number: Integer): Boolean', @Lape_InIntArrayEx); +AddGlobalFunc('function ps_InIntArray(const a: TIntegerArray; Number: Integer): Boolean', @Lape_InIntArray); +AddGlobalFunc('procedure ps_ClearSameIntegers(var a: TIntegerArray);', @Lape_ClearSameIntegers); +AddGlobalFunc('procedure ps_ClearSameIntegersAndTPA(var a: TIntegerArray; var p: TPointArray);', @Lape_ClearSameIntegersAndTPA); +AddGlobalFunc('function ps_SplitTPAEx(const arr: TPointArray; w, h: Integer): T2DPointArray', @Lape_SplitTPAEx); +AddGlobalFunc('function ps_SplitTPA(const arr: TPointArray; Dist: Integer): T2DPointArray', @Lape_SplitTPA); +AddGlobalFunc('function ps_FloodFillTPA(const TPA: TPointArray): T2DPointArray', @Lape_FloodFillTPA); +AddGlobalFunc('procedure ps_FilterPointsPie(var Points: TPointArray; const SD, ED, MinR, MaxR: Extended; Mx, My: Integer);', @Lape_FilterPointsPie); +AddGlobalFunc('procedure ps_FilterPointsDist(var Points: TPointArray; const MinDist, MaxDist: Extended; Mx, My: Integer);', @Lape_FilterPointsDist); +AddGlobalFunc('procedure ps_FilterPointsLine(var Points: TPointArray; Radial: Extended; Radius, MX, MY: Integer);', @Lape_FilterPointsLine); +AddGlobalFunc('procedure ps_FilterTPADist(var TPA: TPointArray; maxDist: integer);', @Lape_FilterTPADist); +AddGlobalFunc('function ps_GetATPABounds(const ATPA: T2DPointArray): TBox', @Lape_GetATPABounds); +AddGlobalFunc('function ps_GetTPABounds(const TPA: TPointArray): TBox', @Lape_GetTPABounds); +AddGlobalFunc('function ps_FindTPAinTPA(const SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean', @Lape_FindTPAinTPA); +AddGlobalFunc('function ps_GetSamePointsATPA(const ATPA: T2DPointArray; var Matches: TPointArray): boolean', @Lape_GetSamePointsATPA); +AddGlobalFunc('function ps_FindTextTPAinTPA(Height: integer; const SearchTPA, TotalTPA: TPointArray; var Matches: TPointArray): Boolean', @Lape_FindTextTPAinTPA); +AddGlobalFunc('procedure ps_SortCircleWise(var tpa: TPointArray; const cx, cy, StartDegree: Integer; SortUp, ClockWise: Boolean);', @Lape_SortCircleWise); +AddGlobalFunc('procedure ps_LinearSort(var tpa: TPointArray; cx, cy, sd: Integer; SortUp: Boolean);', @Lape_LinearSort); +AddGlobalFunc('function ps_RotatePoint(Const p: TPoint; angle, mx, my: Extended): TPoint', @Lape_RotatePoint); +AddGlobalFunc('function ps_ChangeDistPT(const PT: TPoint; mx,my: integer; newdist: extended): TPoint', @Lape_ChangeDistPT); +AddGlobalFunc('function ps_ChangeDistTPA(var TPA: TPointArray; mx,my: integer; newdist: extended): boolean', @Lape_ChangeDistTPA); +AddGlobalFunc('function ps_FindGapsTPA(const TPA: TPointArray; MinPixels: Integer): T2DPointArray', @Lape_FindGapsTPA); +AddGlobalFunc('function ps_RemoveDistTPointArray(x, y, dist: Integer; const ThePoints: TPointArray; RemoveHigher: Boolean): TPointArray', @Lape_RemoveDistTPointArray); +AddGlobalFunc('function ps_CombineTPA(const Ar1, Ar2: TPointArray): TPointArray', @Lape_CombineTPA); +AddGlobalFunc('function ps_ReArrangeandShortenArrayEx(const a: TPointArray; w, h: Integer): TPointArray', @Lape_ReArrangeandShortenArrayEx); +AddGlobalFunc('function ps_ReArrangeandShortenArray(const a: TPointArray; Dist: Integer): TPointArray', @Lape_ReArrangeandShortenArray); +AddGlobalFunc('function ps_TPAtoATPAEx(const TPA: TPointArray; w, h: Integer): T2DPointArray', @Lape_TPAtoATPAEx); +AddGlobalFunc('function ps_TPAtoATPA(const TPA: TPointArray; Dist: Integer): T2DPointArray', @Lape_TPAtoATPA); +AddGlobalFunc('function ps_CombineIntArray(const Ar1, Ar2: TIntegerArray): TIntegerArray', @Lape_CombineIntArray); +AddGlobalFunc('function ps_MergeATPA(const ATPA: T2DPointArray): TPointArray', @Lape_MergeATPA); +AddGlobalFunc('procedure ps_AppendTPA(var TPA: TPointArray; const ToAppend: TPointArray);', @Lape_AppendTPA); +AddGlobalFunc('function ps_TPAFromBox(const Box: TBox): TPointArray', @Lape_TPAFromBox); +AddGlobalFunc('function ps_RotatePoints(Const P: TPointArray; A, cx, cy: Extended): TPointArray', @Lape_RotatePoints); +AddGlobalFunc('function ps_FindTPAEdges(const p: TPointArray): TPointArray', @Lape_FindTPAEdges); +AddGlobalFunc('function ps_ClearTPAFromTPA(const arP, ClearPoints: TPointArray): TPointArray', @Lape_ClearTPAFromTPA); +AddGlobalFunc('function ps_ReturnPointsNotInTPA(Const TotalTPA: TPointArray; const Box: TBox): TPointArray', @Lape_ReturnPointsNotInTPA); +AddGlobalFunc('function ps_PointInTPA(p: TPoint; const arP: TPointArray): Boolean', @Lape_PointInTPA); +AddGlobalFunc('procedure ps_ClearDoubleTPA(var TPA: TPointArray);', @Lape_ClearDoubleTPA); +AddGlobalFunc('procedure ps_TPACountSort(Var TPA: TPointArray; const max: TPoint; Const SortOnX: Boolean);', @Lape_TPACountSort); +AddGlobalFunc('procedure ps_TPACountSortBase(Var TPA: TPointArray; const maxx, base: TPoint; const SortOnX: Boolean);', @Lape_TPACountSortBase); +AddGlobalFunc('procedure ps_InvertTIA(var tI: TIntegerArray);', @Lape_InvertTIA); +AddGlobalFunc('function ps_SumIntegerArray(const Ints: TIntegerArray): Integer', @Lape_SumIntegerArray); +AddGlobalFunc('function ps_AverageTIA(const tI: TIntegerArray): Integer', @Lape_AverageTIA); +AddGlobalFunc('function ps_AverageExtended(const tE: TExtendedArray): Extended', @Lape_AverageExtended); +AddGlobalFunc('procedure ps_SplitTPAExWrap(const arr: TPointArray; w, h: Integer; var res: T2DPointArray);', @Lape_SplitTPAExWrap); +AddGlobalFunc('procedure ps_SplitTPAWrap(const arr: TPointArray; Dist: Integer; var res: T2DPointArray);', @Lape_SplitTPAWrap); +AddGlobalFunc('procedure ps_FindGapsTPAWrap(const TPA: TPointArray; MinPixels: Integer; var Res: T2DPointArray);', @Lape_FindGapsTPAWrap); +AddGlobalFunc('procedure ps_RemoveDistTPointArrayWrap(x, y, dist: Integer; const ThePoints: TPointArray; RemoveHigher: Boolean; var Res: TPointArray);', @Lape_RemoveDistTPointArrayWrap); +AddGlobalFunc('procedure ps_CombineTPAWrap(const Ar1, Ar2: TPointArray; var Res: TPointArray);', @Lape_CombineTPAWrap); +AddGlobalFunc('procedure ps_ReArrangeandShortenArrayExWrap(const a: TPointArray; w, h: Integer; var Res: TPointArray);', @Lape_ReArrangeandShortenArrayExWrap); +AddGlobalFunc('procedure ps_ReArrangeandShortenArrayWrap(const a: TPointArray; Dist: Integer; var Res: TPointArray);', @Lape_ReArrangeandShortenArrayWrap); +AddGlobalFunc('procedure ps_TPAtoATPAExWrap(const TPA: TPointArray; w, h: Integer; var Res: T2DPointArray);', @Lape_TPAtoATPAExWrap); +AddGlobalFunc('procedure ps_TPAtoATPAWrap(const TPA: TPointArray; Dist: Integer; var Res: T2DPointArray);', @Lape_TPAtoATPAWrap); +AddGlobalFunc('procedure ps_CombineIntArrayWrap(const Ar1, Ar2: TIntegerArray; var Res: TIntegerArray);', @Lape_CombineIntArrayWrap); +AddGlobalFunc('procedure ps_MergeATPAWrap(const ATPA: T2DPointArray; var Res: TPointArray);', @Lape_MergeATPAWrap); +AddGlobalFunc('procedure ps_TPAFromBoxWrap(const Box: TBox; var Res: TPointArray);', @Lape_TPAFromBoxWrap); +AddGlobalFunc('procedure ps_RotatePointsWrap(Const P: TPointArray; A, cx, cy: Extended; var Res: TPointArray);', @Lape_RotatePointsWrap); +AddGlobalFunc('procedure ps_FindTPAEdgesWrap(const p: TPointArray; var Res: TPointArray);', @Lape_FindTPAEdgesWrap); +AddGlobalFunc('procedure ps_ClearTPAFromTPAWrap(const arP, ClearPoints: TPointArray; var Res: TPointArray);', @Lape_ClearTPAFromTPAWrap); +AddGlobalFunc('procedure ps_ReturnPointsNotInTPAWrap(Const TotalTPA: TPointArray; const Box: TBox; var Res: TPointArray);', @Lape_ReturnPointsNotInTPAWrap); +AddGlobalFunc('function ps_SameTPA(const aTPA, bTPA: TPointArray): Boolean', @Lape_SameTPA); +AddGlobalFunc('function ps_TPAInATPA(const TPA: TPointArray; const InATPA: T2DPointArray; var Index: LongInt): Boolean', @Lape_TPAInATPA); +AddGlobalFunc('procedure ps_OffsetTPA(var TPA: TPointArray; const Offset: TPoint);', @Lape_OffsetTPA); +AddGlobalFunc('procedure ps_OffsetATPA(var ATPA: T2DPointArray; const Offset: TPoint);', @Lape_OffsetATPA); +AddGlobalFunc('function ps_CopyTPA(const TPA: TPointArray): TPointArray', @Lape_CopyTPA); +AddGlobalFunc('function ps_CopyATPA(const ATPA: T2DPointArray): T2DPointArray', @Lape_CopyATPA); +AddGlobalFunc('function ps_Capitalize(str: string): string', @Lape_Capitalize); +AddGlobalFunc('function ps_CompressString(const Str: string): string', @Lape_CompressString); +AddGlobalFunc('function ps_DecompressString(const Compressed: string): string', @Lape_DecompressString); +AddGlobalFunc('function ps_Base64Encode(const str: string): string', @Lape_Base64Encode); +AddGlobalFunc('function ps_Base64Decode(const str: string): string', @Lape_Base64Decode); +AddGlobalFunc('function ps_ExtractFromStr(Str: string; Extract: StrExtr): string', @Lape_ExtractFromStr); +AddGlobalFunc('function ps_BoolToStr(bool: boolean): string', @Lape_BoolToStr); +AddGlobalFunc('function ps_Replace(Text, FindStr, ReplaceStr: string; Flags: TReplaceFlags): string', @Lape_Replace); +AddGlobalFunc('function ps_IntToStr(int: integer): string', @Lape_IntToStr); +AddGlobalFunc('function ps_FloatToStr(flt: extended): string', @Lape_FloatToStr); +AddGlobalFunc('function ps_StrToInt(value: String): Integer', @Lape_StrToInt); +AddGlobalFunc('function ps_StrToIntDef(value: String; default: Integer): Integer', @Lape_StrToIntDef); +AddGlobalFunc('function ps_StrToFloat(value: String): Extended', @Lape_StrToFloat); +AddGlobalFunc('function ps_StrToFloatDef(value: String; default: Extended): Extended', @Lape_StrToFloatDef); +AddGlobalFunc('function ps_StrToBool(value: String): Boolean', @Lape_StrToBool); +AddGlobalFunc('function ps_StrToBoolDef(value: String; default: Boolean): Boolean', @Lape_StrToBoolDef); +AddGlobalFunc('function ps_Between(s1, s2, str: string): string', @Lape_Between); +AddGlobalFunc('function ps_SetSettingValue(const KeyName,value: string): boolean', @Lape_SetSettingValue); +AddGlobalFunc('function ps_KeyIsSetting(const KeyName: String): Boolean', @Lape_KeyIsSetting); +AddGlobalFunc('function ps_KeyIsDirectory(const KeyName: String): Boolean', @Lape_KeyIsDirectory); +AddGlobalFunc('function ps_GetSettingValue(const KeyName: String): String', @Lape_GetSettingValue); +AddGlobalFunc('function ps_GetSettingValueDef(const KeyName, defVal: String): String', @Lape_GetSettingValueDef); +AddGlobalFunc('function ps_ListSettings(const KeyName: String; var KeyReturn: TStringArray): boolean', @Lape_ListSettings); +AddGlobalFunc('function ps_DeleteSetting(const KeyName: String): Boolean', @Lape_DeleteSetting); +AddGlobalFunc('function ps_DeleteSubSettings(const KeyName: String): Boolean', @Lape_DeleteSubSettings); +AddGlobalFunc('procedure ps_Writeln(const str: string);', @Lape_Writeln); +AddGlobalFunc('function ps_SetScriptProp(prop: TSP_Property; Value: TVariantArray): boolean', @Lape_SetScriptProp); +AddGlobalFunc('function ps_GetScriptProp(prop: TSP_Property; var Value: TVariantArray): boolean', @Lape_GetScriptProp); +AddGlobalFunc('procedure ps_Wait(t: DWord);', @Lape_Wait); +AddGlobalFunc('function ps_rs_GetUpText: String', @Lape_rs_GetUpText); +AddGlobalFunc('function ps_rs_GetUpTextAtEx(x, y: integer; shadow: boolean): string', @Lape_rs_GetUpTextAtEx); +AddGlobalFunc('function ps_rs_GetUpTextAt(x, y: integer): string', @Lape_rs_GetUpTextAt); +AddGlobalFunc('function ps_BitmapFromText(const text, font: String): integer', @Lape_BitmapFromText); +AddGlobalFunc('procedure ps_MoveMouse(x, y: integer);', @Lape_MoveMouse); +AddGlobalFunc('procedure ps_ScrollMouse(x,y: integer; Clicks: integer);', @Lape_ScrollMouse); +AddGlobalFunc('procedure ps_GetMousePos(var x, y: integer);', @Lape_GetMousePos); +AddGlobalFunc('function ConvIntClickType(Int: Integer): TClickType', @Lape_); +AddGlobalFunc('procedure ps_HoldMouse(x, y: integer; clickType: integer);', @Lape_HoldMouse); +AddGlobalFunc('procedure ps_ReleaseMouse(x, y: integer; clickType: integer);', @Lape_ReleaseMouse); +AddGlobalFunc('procedure ps_ClickMouse(x, y: integer; clickType: integer);', @Lape_ClickMouse); +AddGlobalFunc('function ps_IsMouseButtonDown(button: integer): boolean', @Lape_IsMouseButtonDown); +AddGlobalFunc('function ps_round(e: extended): integer', @Lape_round); +AddGlobalFunc('function ps_iAbs(a: integer): integer', @Lape_iAbs); +AddGlobalFunc('function ps_ceil(e: extended): integer', @Lape_ceil); +AddGlobalFunc('function ps_pow(base,exponent: extended): extended', @Lape_pow); +AddGlobalFunc('function ps_RiemannGauss(Xstart,StepSize,Sigma: extended; AmountSteps: integer): extended', @Lape_RiemannGauss); +AddGlobalFunc('function ps_DiscreteGauss(Xstart,Xend: integer; sigma: extended): TExtendedArray', @Lape_DiscreteGauss); +AddGlobalFunc('function ps_GaussMatrix(N: integer; sigma: extended): T2DExtendedArray', @Lape_GaussMatrix); +AddGlobalFunc('function ps_exp(exponent: extended): extended', @Lape_exp); +AddGlobalFunc('function ps_Max(a,b: integer): integer', @Lape_Max); +AddGlobalFunc('function ps_Min(a, b: Integer): Integer', @Lape_Min); +AddGlobalFunc('function ps_MinE(a, b: extended): extended', @Lape_MinE); +AddGlobalFunc('function ps_MaxE(a,b: extended): extended', @Lape_MaxE); +AddGlobalFunc('function ps_Sqr(e: extended): extended', @Lape_Sqr); +AddGlobalFunc('function ps_Point(x,y: integer): TPoint', @Lape_Point); +AddGlobalFunc('function ps_Distance(x1,y1,x2,y2: integer): integer', @Lape_Distance); +AddGlobalFunc('function ps_Hypot(X, Y: Extended): Extended', @Lape_Hypot); +AddGlobalFunc('function ps_RandomRange(const aFrom, aTo: Integer): Integer', @Lape_RandomRange); +AddGlobalFunc('function ps_Random(Int: integer): integer', @Lape_Random); +AddGlobalFunc('function ps_RandomE: extended', @Lape_RandomE); +AddGlobalFunc('function ps_ArcTan2(y,x: extended): extended', @Lape_ArcTan2); +AddGlobalFunc('procedure ps_IncEx(var x: integer; increase: integer);', @Lape_IncEx); +AddGlobalFunc('procedure ps_DecEx(var x: integer; Decrease: integer);', @Lape_DecEx); +AddGlobalFunc('function ps_Factorial(number: longword): Int64', @Lape_Factorial); +AddGlobalFunc('procedure ps_KeyDown(key: Word);', @Lape_KeyDown); +AddGlobalFunc('procedure ps_KeyUp(key: Word);', @Lape_KeyUp); +AddGlobalFunc('procedure ps_SendKeys(const s: string);', @Lape_SendKeys); +AddGlobalFunc('procedure ps_PressKey(key: Word);', @Lape_PressKey); +AddGlobalFunc('function ps_isKeyDown(key: Word): boolean', @Lape_isKeyDown); +AddGlobalFunc('function ps_GetKeyCode(c: char): integer', @Lape_GetKeyCode); +AddGlobalFunc('procedure ps_OpenWebPage(const url: string);', @Lape_OpenWebPage); +AddGlobalFunc('function ps_GetPage(const S: String): String', @Lape_GetPage); +AddGlobalFunc('function ps_InitializeHTTPClient(HandleCookies: Boolean): Integer', @Lape_InitializeHTTPClient); +AddGlobalFunc('procedure ps_FreeHTTPClient(Client: Integer);', @Lape_FreeHTTPClient); +AddGlobalFunc('function ps_GetHTTPPage(Client: Integer; const URL: string): string', @Lape_GetHTTPPage); +AddGlobalFunc('procedure ps_SetHTTPUserAgent(Client: Integer; const Agent: string);', @Lape_SetHTTPUserAgent); +AddGlobalFunc('function ps_PostHTTPPage(Client: Integer; const Url,PostData: string): string', @Lape_PostHTTPPage); +AddGlobalFunc('function ps_PostHTTPPageEx(Client: Integer; const Url: string): string', @Lape_PostHTTPPageEx); +AddGlobalFunc('procedure ps_ClearPostData(Client: Integer);', @Lape_ClearPostData); +AddGlobalFunc('procedure ps_AddPostVariable(Client: Integer; const VarName, VarValue: string);', @Lape_AddPostVariable); +AddGlobalFunc('function ps_GetRawHeaders(Client: Integer): string', @Lape_GetRawHeaders); +AddGlobalFunc('procedure ps_SetProxy(Client: Integer; pHost, pPort: String);', @Lape_SetProxy); +AddGlobalFunc('function ps_RecvSocketStr(Client: integer): string', @Lape_RecvSocketStr); +AddGlobalFunc('function ps_RecvSocket(Client: integer): string', @Lape_RecvSocket); +AddGlobalFunc('function ps_RecvSocketEx(Client, Length: integer): string', @Lape_RecvSocketEx); +AddGlobalFunc('procedure ps_SendSocket(Client: integer; Data: string);', @Lape_SendSocket); +AddGlobalFunc('procedure ps_ConnectSocket(Client: integer; IP, Port: string);', @Lape_ConnectSocket); +AddGlobalFunc('procedure ps_CloseSocket(Client: integer);', @Lape_CloseSocket); +AddGlobalFunc('procedure ps_SetSocketTimeout(Client, Time: integer);', @Lape_SetSocketTimeout); +AddGlobalFunc('procedure ps_BindSocket(Client: integer; IP, Port: string);', @Lape_BindSocket); +AddGlobalFunc('procedure ps_ListenSocket(Client: integer);', @Lape_ListenSocket); +AddGlobalFunc('function ps_AcceptSocket(Client: integer): integer', @Lape_AcceptSocket); +AddGlobalFunc('procedure ps_SocketInfo(Client: integer; out IP, Port: string);', @Lape_SocketInfo); +AddGlobalFunc('function ps_CreateSocket: integer', @Lape_CreateSocket); +AddGlobalFunc('procedure ps_FreeSocket(Client: integer);', @Lape_FreeSocket); +AddGlobalFunc('function ps_CreateFile(const Path: string): Integer', @Lape_CreateFile); +AddGlobalFunc('function ps_OpenFile(const Path: string; Shared: Boolean): Integer', @Lape_OpenFile); +AddGlobalFunc('function ps_RewriteFile(const Path: string; Shared: Boolean): Integer', @Lape_RewriteFile); +AddGlobalFunc('function ps_AppendFile(const Path: string): Integer', @Lape_AppendFile); +AddGlobalFunc('procedure ps_CloseFile(FileNum: Integer);', @Lape_CloseFile); +AddGlobalFunc('function ps_EndOfFile(FileNum: Integer): Boolean', @Lape_EndOfFile); +AddGlobalFunc('function ps_FileSize(FileNum: Integer): LongInt', @Lape_FileSize); +AddGlobalFunc('function ps_ReadFileString(FileNum: Integer; var s: string; x: Integer): Boolean', @Lape_ReadFileString); +AddGlobalFunc('function ps_WriteFileString(FileNum: Integer; s: string): Boolean', @Lape_WriteFileString); +AddGlobalFunc('function ps_SetFileCharPointer(FileNum, cChars, Origin: Integer): Integer', @Lape_SetFileCharPointer); +AddGlobalFunc('function ps_FilePointerPos(FileNum: Integer): Integer', @Lape_FilePointerPos); +AddGlobalFunc('function ps_FileExists(const FileName: string): Boolean', @Lape_FileExists); +AddGlobalFunc('function ps_DirectoryExists(const DirectoryName: string): Boolean', @Lape_DirectoryExists); +AddGlobalFunc('function ps_CreateDirectory(const DirectoryName: string): boolean', @Lape_CreateDirectory); +AddGlobalFunc('function ps_ForceDirectores(const dir: string): boolean', @Lape_ForceDirectores); +AddGlobalFunc('function ps_GetFiles(const Path, Ext: string): TStringArray', @Lape_GetFiles); +AddGlobalFunc('function ps_GetDirectories(const path: string): TStringArray', @Lape_GetDirectories); +AddGlobalFunc('procedure ps_WriteINI(const Section, KeyName, NewString, FileName: string);', @Lape_WriteINI); +AddGlobalFunc('function ext_UnTar(const Input: string; var Content: TStringArray): boolean', @Lape_); +AddGlobalFunc('function ext_UnTarEx(const Input: string; const outputdir: string; overwrite: boolean): boolean', @Lape_); +AddGlobalFunc('function ext_DecompressBZip2(const input: string; var output: string; const BlockSize: Cardinal): boolean', @Lape_); +AddGlobalFunc('function ext_GetPage(const url: string): string', @Lape_); +AddGlobalFunc('function ext_MessageDlg(const aCaption, aMsg: string; DlgType: TMsgDlgType; Buttons: TMsgDlgButtons; HelpCtx: Longint): Integer', @Lape_); +AddGlobalFunc('function ext_SDTMToMDTM(Const DTM: TSDTM): TMDTM', @Lape_); +AddGlobalFunc('function ext_InputQuery(const ACaption, APrompt: String; var Value: String): Boolean', @Lape_); +AddGlobalFunc('function ext_ScriptText: string', @Lape_); +AddGlobalFunc('function ext_GetSelectedText: string', @Lape_); +AddGlobalFunc('procedure ext_OpenScript(vName, Data: string; Run: boolean);', @Lape_); +AddGlobalFunc('procedure ext_OpenScriptEx(FileName: string; Run: boolean);', @Lape_); +AddGlobalFunc('function ext_GetPageEx(const URL, PostData, MimeType: string): string', @Lape_); +AddGlobalFunc('function ext_GetJSONValue(const Data, Value: string): string', @Lape_); +AddGlobalFunc('function ps_FindDTM(DTM: Integer; var x, y: Integer; xs, ys, xe, ye: Integer): Boolean', @Lape_FindDTM); +AddGlobalFunc('function ps_FindDTMs(DTM: Integer; var p: TPointArray; xs, ys, xe, ye: Integer): Boolean', @Lape_FindDTMs); +AddGlobalFunc('function ps_FindDTMRotatedAlternating(DTM: Integer; var x, y: Integer; xs, ys, xe, ye: Integer; sAngle, eAngle, aStep: Extended; var aFound: Extended): Boolean', @Lape_FindDTMRotatedAlternating); +AddGlobalFunc('function ps_FindDTMRotatedSE(DTM: Integer; var x, y: Integer; xs, ys, xe, ye: Integer; sAngle, eAngle, aStep: Extended; var aFound: Extended): Boolean', @Lape_FindDTMRotatedSE); +AddGlobalFunc('function ps_FindDTMsRotatedAlternating(DTM: Integer; var Points: TPointArray; xs, ys, xe, ye: Integer; sAngle, eAngle, aStep: Extended; var aFound: T2DExtendedArray): Boolean', @Lape_FindDTMsRotatedAlternating); +AddGlobalFunc('function ps_FindDTMsRotatedSE(DTM: Integer; var Points: TPointArray; xs, ys, xe, ye: Integer; sAngle, eAngle, aStep: Extended; var aFound: T2DExtendedArray): Boolean', @Lape_FindDTMsRotatedSE); +AddGlobalFunc('procedure ps_SetDTMName(DTM: integer; const name: string);', @Lape_SetDTMName); +AddGlobalFunc('function ps_DTMFromString(const DTMString: String): Integer', @Lape_DTMFromString); +AddGlobalFunc('procedure ps_FreeDTM(DTM: Integer);', @Lape_FreeDTM); +AddGlobalFunc('function ps_GetDTM(index: Integer): TMDTM', @Lape_GetDTM); +AddGlobalFunc('function ps_AddTSDTM(const d: TSDTM): Integer', @Lape_AddTSDTM); +AddGlobalFunc('function ps_AddDTM(const d: TMDTM): Integer', @Lape_AddDTM); +AddGlobalFunc('procedure ps_PrintDTM(const aDTM: TMDTM);', @Lape_PrintDTM); +AddGlobalFunc('function ps_MDTMToSDTM(Const DTM: TMDTM): TSDTM', @Lape_MDTMToSDTM); +AddGlobalFunc('function ps_SDTMToMDTM(Const DTM: TSDTM): TMDTM', @Lape_SDTMToMDTM); +AddGlobalFunc('function ps_CreateDTMPoint(x,y,c,t,asz: integer; bp: boolean): TMDTMPoint', @Lape_CreateDTMPoint); +AddGlobalFunc('function ps_haval(Data: string): string', @Lape_haval); +AddGlobalFunc('procedure ps_ColorToRGB(Color: integer; var r, g, b: Integer);', @Lape_ColorToRGB); +AddGlobalFunc('function ps_GetColor(x,y: integer): TColor', @Lape_GetColor); +AddGlobalFunc('procedure ps_GetColorsWrap(Coords: TPointArray; var Colors: TIntegerArray);', @Lape_GetColorsWrap); +AddGlobalFunc('function ps_GetColors(const Coords: TPointArray): TIntegerArray', @Lape_GetColors); +AddGlobalFunc('function ps_findcolor(var x, y: integer; color, x1, y1, x2, y2: integer): boolean', @Lape_findcolor); +AddGlobalFunc('function ps_findcolortoleranceOptimised(var x, y: integer; color, x1, y1, x2, y2, tol: integer): boolean', @Lape_findcolortoleranceOptimised); +AddGlobalFunc('function ps_findcolortolerance(var x, y: integer; color, x1, y1, x2, y2, tol: integer): boolean', @Lape_findcolortolerance); +AddGlobalFunc('function ps_FindColors(var TPA: TPointArray; Color, x1, y1, x2, y2: Integer): Boolean', @Lape_FindColors); +AddGlobalFunc('procedure ps_SetColorToleranceSpeed(cts: Integer);', @Lape_SetColorToleranceSpeed); +AddGlobalFunc('function ps_GetToleranceSpeed: Integer', @Lape_GetToleranceSpeed); +AddGlobalFunc('procedure ps_SetToleranceSpeed2Modifiers(nHue, nSat: Extended);', @Lape_SetToleranceSpeed2Modifiers); +AddGlobalFunc('procedure ps_GetToleranceSpeed2Modifiers(var hMod, sMod: Extended);', @Lape_GetToleranceSpeed2Modifiers); +AddGlobalFunc('function ps_SimilarColors(Col1,Col2,Tol: integer): boolean', @Lape_SimilarColors); +AddGlobalFunc('function ps_CountColor(Color, xs, ys, xe, ye: Integer): Integer', @Lape_CountColor); +AddGlobalFunc('function ps_CountColorTolerance(Color, xs, ys, xe, ye, Tolerance: Integer): Integer', @Lape_CountColorTolerance); +AddGlobalFunc('function ps_FindColorsToleranceOptimised(var Points: TPointArray; Color, xs, ys, xe, ye, Tolerance: Integer): Boolean', @Lape_FindColorsToleranceOptimised); +AddGlobalFunc('function ps_FindColorsTolerance(var Points: TPointArray; Color, xs, ys, xe, ye, Tolerance: Integer): Boolean', @Lape_FindColorsTolerance); +AddGlobalFunc('function ps_FindColorSpiral(var x, y: Integer; color, xs, ys, xe, ye: Integer): Boolean', @Lape_FindColorSpiral); +AddGlobalFunc('function ps_FindColorSpiralTolerance(var x, y: Integer; color, xs, ys, xe, ye,Tol: Integer): Boolean', @Lape_FindColorSpiralTolerance); +AddGlobalFunc('function ps_FindColorsSpiralTolerance(x, y: Integer; var Points: TPointArray; color, xs, ys, xe, ye: Integer; Tolerance: Integer): boolean', @Lape_FindColorsSpiralTolerance); +AddGlobalFunc('function ps_FindColoredArea(var x, y: Integer; color, xs, ys, xe, ye: Integer; MinArea: Integer): Boolean', @Lape_FindColoredArea); +AddGlobalFunc('function ps_FindColoredAreaTolerance(var x, y: Integer; Color, xs, ys, xe, ye, MinArea, tol: Integer): Boolean', @Lape_FindColoredAreaTolerance); +AddGlobalFunc('function ps_CreateBitmapString(bmp: integer): string', @Lape_CreateBitmapString); +AddGlobalFunc('function ps_GetMufasaBitmap(bmp: integer): TMufasaBitmap', @Lape_GetMufasaBitmap); +AddGlobalFunc('function ps_CreateBitmap(w,h: integer): integer', @Lape_CreateBitmap); +AddGlobalFunc('procedure ps_FreeBitmap(Number: integer);', @Lape_FreeBitmap); +AddGlobalFunc('procedure ps_SaveBitmap(Bmp: integer; path: string);', @Lape_SaveBitmap); +AddGlobalFunc('function ps_BitmapFromString(Width,height: integer; Data: string): integer', @Lape_BitmapFromString); +AddGlobalFunc('function ps_LoadBitmap(Path: String): integer', @Lape_LoadBitmap); +AddGlobalFunc('procedure ps_SetBitmapSize(Bmp,NewW,NewH: integer);', @Lape_SetBitmapSize); +AddGlobalFunc('procedure ps_StretchBitmapResize(Bmp,NewW,NewH: integer);', @Lape_StretchBitmapResize); +AddGlobalFunc('procedure ps_GetBitmapSize(Bmp: integer; var BmpW,BmpH: integer);', @Lape_GetBitmapSize); +AddGlobalFunc('procedure ps_SetBitmapName(Bmp: integer; name: string);', @Lape_SetBitmapName); +AddGlobalFunc('function ps_CreateMirroredBitmap(Bmp: integer): integer', @Lape_CreateMirroredBitmap); +AddGlobalFunc('function ps_CreateMirroredBitmapEx(Bmp: integer; MirrorStyle: TBmpMirrorStyle): integer', @Lape_CreateMirroredBitmapEx); +AddGlobalFunc('function ps_FastGetPixel(bmp,x,y: integer): LongWord', @Lape_FastGetPixel); +AddGlobalFunc('function ps_FastGetPixels(bmp: integer; TPA: TPointArray): TIntegerArray', @Lape_FastGetPixels); +AddGlobalFunc('function ps_GetBitmapAreaColors(bmp,xs, ys, xe, ye: Integer): T2DIntArray', @Lape_GetBitmapAreaColors); +AddGlobalFunc('procedure ps_FastSetPixel(Bmp,x,y: integer; Color: TColor);', @Lape_FastSetPixel); +AddGlobalFunc('procedure ps_FastSetPixels(Bmp: integer; TPA: TPointArray; Colors: TIntegerArray);', @Lape_FastSetPixels); +AddGlobalFunc('procedure ps_DrawTPABitmap(bitmap: integer; TPA: TPointArray; Color: integer);', @Lape_DrawTPABitmap); +AddGlobalFunc('procedure ps_DrawATPABitmap(bitmap: integer; ATPA: T2DPointArray);', @Lape_DrawATPABitmap); +AddGlobalFunc('procedure ps_DrawATPABitmapEx(bitmap: integer; ATPA: T2DPointArray; Colors: TIntegerArray);', @Lape_DrawATPABitmapEx); +AddGlobalFunc('procedure ps_FastDrawClear(bmp: integer; Color: TColor);', @Lape_FastDrawClear); +AddGlobalFunc('procedure ps_DrawBitmap(Bmp: Integer; Dest: TCanvas; x, y: Integer);', @Lape_DrawBitmap); +AddGlobalFunc('procedure ps_FastDrawTransparent(x, y: Integer; SourceBitmap, TargetBitmap: Integer);', @Lape_FastDrawTransparent); +AddGlobalFunc('procedure ps_SetTransparentColor(Bmp: integer; Color: TColor);', @Lape_SetTransparentColor); +AddGlobalFunc('function ps_GetTransparentColor(Bmp: integer): TColor', @Lape_GetTransparentColor); +AddGlobalFunc('procedure ps_FastReplaceColor(bmp: Integer; OldColor, NewColor: TColor);', @Lape_FastReplaceColor); +AddGlobalFunc('procedure ps_CopyClientToBitmap(bmp, xs, ys, xe, ye: Integer);', @Lape_CopyClientToBitmap); +AddGlobalFunc('function ps_BitmapFromClient(const xs, ys, xe, ye: Integer): Integer', @Lape_BitmapFromClient); +AddGlobalFunc('function ps_FindBitmap(Bitmap: integer; var x, y: Integer): Boolean', @Lape_FindBitmap); +AddGlobalFunc('function ps_FindBitmapIn(bitmap: integer; var x, y: Integer; xs, ys, xe, ye: Integer): Boolean', @Lape_FindBitmapIn); +AddGlobalFunc('function ps_FindBitmapToleranceIn(bitmap: integer; var x, y: Integer; xs, ys, xe, ye: Integer; tolerance: Integer): Boolean', @Lape_FindBitmapToleranceIn); +AddGlobalFunc('function ps_FindBitmapSpiral(bitmap: Integer; var x, y: Integer; xs, ys, xe, ye: Integer): Boolean', @Lape_FindBitmapSpiral); +AddGlobalFunc('function ps_FindBitmapsSpiralTolerance(bitmap: integer; x, y: Integer; var Points: TPointArray; xs, ys, xe, ye,tolerance: Integer): Boolean', @Lape_FindBitmapsSpiralTolerance); +AddGlobalFunc('function ps_FindBitmapSpiralTolerance(bitmap: integer; var x, y: Integer; xs, ys, xe, ye,tolerance: integer): Boolean', @Lape_FindBitmapSpiralTolerance); +AddGlobalFunc('function ps_RotateBitmap(bitmap: Integer; angle: Extended): Integer', @Lape_RotateBitmap); +AddGlobalFunc('function ps_Desaturate(Bitmap: integer): integer', @Lape_Desaturate); +AddGlobalFunc('procedure ps_InvertBitmap(Bitmap: integer);', @Lape_InvertBitmap); +AddGlobalFunc('function ps_CopyBitmap(Bitmap: integer): integer', @Lape_CopyBitmap); +AddGlobalFunc('function ps_GreyScaleBitmap(Bitmap: integer): integer', @Lape_GreyScaleBitmap); +AddGlobalFunc('function ps_BrightnessBitmap(Bitmap,br: integer): integer', @Lape_BrightnessBitmap); +AddGlobalFunc('function ps_ContrastBitmap(bitmap: integer; co: extended): integer', @Lape_ContrastBitmap); +AddGlobalFunc('function ps_PosterizeBitmap(Bitmap: integer; po: integer): integer', @Lape_PosterizeBitmap); +AddGlobalFunc('function ps_CreateMaskFromBitmap(Bitmap: integer): TMask', @Lape_CreateMaskFromBitmap); +AddGlobalFunc('function ps_FindMaskTolerance(const mask: TMask; var x, y: Integer; xs,ys, xe, ye: Integer; Tolerance, ContourTolerance: Integer): Boolean', @Lape_FindMaskTolerance); +AddGlobalFunc('function ps_FindBitmapMaskTolerance(mask: Integer; var x, y: Integer; xs, ys, xe, ye: Integer; Tolerance, ContourTolerance: Integer): Boolean', @Lape_FindBitmapMaskTolerance); +AddGlobalFunc('function ps_FindDeformedBitmapToleranceIn(bitmap: integer; var x, y: Integer; xs, ys, xe, ye: Integer; tolerance: Integer; Range: Integer; AllowPartialAccuracy: Boolean; var accuracy: Extended): Boolean', @Lape_FindDeformedBitmapToleranceIn); +AddGlobalFunc('procedure ps_RectangleBitmap(bitmap: integer; const box: TBox; Color: TColor);', @Lape_RectangleBitmap); +AddGlobalFunc('procedure ps_FloodFillBitmap(bitmap: integer; const StartPoint: TPoint; const SearchCol,ReplaceCol: TColor);', @Lape_FloodFillBitmap); +AddGlobalFunc('function ps_ConvoluteBitmap(bitmap: integer; matrix: T2DExtendedArray): integer', @Lape_ConvoluteBitmap); +AddGlobalFunc('function ps_CalculatePixelShift(Bmp1,Bmp2: Integer; CompareBox: TBox): integer', @Lape_CalculatePixelShift); +AddGlobalFunc('function ps_CalculatePixelTolerance(Bmp1,Bmp2: Integer; CompareBox: TBox; CTS: integer): extended', @Lape_CalculatePixelTolerance); diff --git a/Units/MMLAddon/mmlpsthread.pas b/Units/MMLAddon/mmlpsthread.pas index 5e006db..ee7a85c 100644 --- a/Units/MMLAddon/mmlpsthread.pas +++ b/Units/MMLAddon/mmlpsthread.pas @@ -1281,22 +1281,22 @@ type end; //Generate these wrappers with a script -Dg -//{$I LPInc/Wrappers/other.inc} -//{$I LPInc/Wrappers/settings.inc} -//{$I LPInc/Wrappers/bitmap.inc} -//{$I LPInc/Wrappers/window.inc} -//{$I LPInc/Wrappers/tpa.inc} -//{$I LPInc/Wrappers/strings.inc} -//{$I LPInc/Wrappers/colour.inc} -//{$I LPInc/Wrappers/colourconv.inc} -//{$I LPInc/Wrappers/crypto.inc} -//{$I LPInc/Wrappers/math.inc} -//{$I LPInc/Wrappers/mouse.inc} -//{$I LPInc/Wrappers/file.inc} -//{$I LPInc/Wrappers/keyboard.inc} -//{$I LPInc/Wrappers/dtm.inc} -//{$I LPInc/Wrappers/ocr.inc} -//{$I LPInc/Wrappers/internets.inc} +{$I LPInc/Wrappers/other.inc} +{$I LPInc/Wrappers/settings.inc} +{$I LPInc/Wrappers/bitmap.inc} +{$I LPInc/Wrappers/window.inc} +{$I LPInc/Wrappers/tpa.inc} +{$I LPInc/Wrappers/strings.inc} +{$I LPInc/Wrappers/colour.inc} +{$I LPInc/Wrappers/colourconv.inc} +{$I LPInc/Wrappers/crypto.inc} +{$I LPInc/Wrappers/math.inc} +{$I LPInc/Wrappers/mouse.inc} +{$I LPInc/Wrappers/file.inc} +{$I LPInc/Wrappers/keyboard.inc} +{$I LPInc/Wrappers/dtm.inc} +{$I LPInc/Wrappers/ocr.inc} +{$I LPInc/Wrappers/internets.inc} constructor TLPThread.Create(CreateSuspended: Boolean; TheSyncInfo: PSyncInfo; plugin_dir: string); var