ver. 3.3.1

- Built with Delphi 13
- Refactoring PageControl to speedup loading
- Added check for new version available, download and install
- Updated Setup
- Updated the latest Image32 library

Author: carloBarazzetta

Build.bat

@@ -1,4 +1,4 @@
-call "C:\BDS\Studio\23.0\bin\rsvars.bat"
+call "C:\BDS\Studio\37.0\bin\rsvars.bat"
 msbuild.exe "Source\SVGShellExtensions.dproj" /target:Clean;Build /p:Platform=Win64 /p:config=release
 msbuild.exe "Source\SVGShellExtensions32.dproj" /target:Clean;Build /p:Platform=Win32 /p:config=release
 msbuild.exe "Source\SVGTextEditor.dproj" /target:Clean;Build /p:Platform=Win64 /p:config=release

Ext/SVGIconImageList/Image32/source/Clipper.Core.pas

@@ -2,7 +2,7 @@
 
 (*******************************************************************************
 * Author    :  Angus Johnson                                                   *
-* Date      :  22 November 2024                                                *
+* Date      :  10 May 2025                                                     *
 * Website   :  https://www.angusj.com                                          *
 * Copyright :  Angus Johnson 2010-2024                                         *
 * Purpose   :  Core Clipper Library module                                     *
@@ -325,6 +325,7 @@ function GetSegmentIntersectPt(const ln1a, ln1b, ln2a, ln2b: TPoint64;
   out ip: TPoint64): Boolean;
 
 function PointInPolygon(const pt: TPoint64; const polygon: TPath64): TPointInPolygonResult;
+function Path2ContainsPath1(const path1, path2: TPath64): Boolean;
 
 function GetClosestPointOnSegment(const pt, seg1, seg2: TPoint64): TPoint64;
   {$IFDEF INLINING} inline; {$ENDIF}
@@ -375,7 +376,7 @@ function Iif(eval: Boolean; trueVal, falseVal: double): double; overload;
 implementation
 
 resourcestring
-  rsClipper_PrecisonErr = 'The decimal rounding value is invalid';
+  rsClipper_PrecisionErr = 'The decimal rounding value is invalid';
 
 //------------------------------------------------------------------------------
 // TRect64 methods ...
@@ -485,7 +486,7 @@ function TRectD.GetIsValid: Boolean;
 
 function TRectD.GetMidPoint: TPointD;
 begin
-  result := PointD((Left + Right) *0.5, (Top + Bottom) *0.5);
+  result := PointD((Left + Right) * 0.5, (Top + Bottom) * 0.5);
 end;
 //------------------------------------------------------------------------------
 
@@ -556,7 +557,7 @@ function TListEx.Add(item: Pointer): integer;
   begin
     if fCapacity = 0 then
       fCapacity := 16 else
-      fCapacity := fCapacity *2;
+      fCapacity := fCapacity * 2;
     SetLength(fList, fCapacity);
   end;
   fList[fCount] := item;
@@ -707,7 +708,7 @@ function Iif(eval: Boolean; trueVal, falseVal: double): double;
 procedure CheckPrecisionRange(var precision: integer);
 begin
   if (precision < -MaxDecimalPrecision) or (precision > MaxDecimalPrecision) then
-      Raise EClipper2LibException(rsClipper_PrecisonErr);
+      Raise EClipper2LibException(rsClipper_PrecisionErr);
 end;
 //------------------------------------------------------------------------------
 
@@ -1215,7 +1216,7 @@ function ReversePath(const path: TPath64): TPath64;
   i, highI: Integer;
 begin
   highI := high(path);
-  SetLength(Result, highI +1);
+  SetLength(Result, highI + 1);
   for i := 0 to highI do
     Result[i] := path[highI - i];
 end;
@@ -1226,7 +1227,7 @@ function ReversePath(const path: TPathD): TPathD;
   i, highI: Integer;
 begin
   highI := high(path);
-  SetLength(Result, highI +1);
+  SetLength(Result, highI + 1);
   for i := 0 to highI do
     Result[i] := path[highI - i];
 end;
@@ -1241,7 +1242,7 @@ function ReversePaths(const paths: TPaths64): TPaths64;
   for i := 0 to i -1 do
   begin
     highJ := high(paths[i]);
-    SetLength(Result[i], highJ+1);
+    SetLength(Result[i], highJ + 1);
     for j := 0 to highJ do
       Result[i][j] := paths[i][highJ - j];
   end;
@@ -1254,10 +1255,10 @@ function ReversePaths(const paths: TPathsD): TPathsD;
 begin
   i := length(paths);
   SetLength(Result, i);
-  for i := 0 to i -1 do
+  for i := 0 to i - 1 do
   begin
     highJ := high(paths[i]);
-    SetLength(Result[i], highJ+1);
+    SetLength(Result[i], highJ + 1);
     for j := 0 to highJ do
       Result[i][j] := paths[i][highJ - j];
   end;
@@ -1276,8 +1277,8 @@ function ShiftPath(const path: TPath64; shift: integer): TPath64;
   if shift = 0 then Exit;
   if shift < 0 then shift := len + shift;
   diff := len - shift;
-  Move(path[shift], Result[0], diff *SizeOf(TPoint64));
-  Move(path[0], Result[diff], shift *SizeOf(TPoint64));
+  Move(path[shift], Result[0], diff * SizeOf(TPoint64));
+  Move(path[0], Result[diff], shift * SizeOf(TPoint64));
 end;
 //------------------------------------------------------------------------------
 
@@ -1293,8 +1294,8 @@ function ShiftPath(const path: TPathD; shift: integer): TPathD;
   if shift = 0 then Exit;
   if shift < 0 then shift := len + shift;
   diff := len - shift;
-  Move(path[shift], Result[0], diff *SizeOf(TPointD));
-  Move(path[0], Result[diff], shift *SizeOf(TPointD));
+  Move(path[shift], Result[0], diff * SizeOf(TPointD));
+  Move(path[0], Result[diff], shift * SizeOf(TPointD));
 end;
 //------------------------------------------------------------------------------
 
@@ -2043,20 +2044,20 @@ function CleanPath(const path: TPath64): TPath64;
   Result := nil;
   len := Length(path);
   while (len > 2) and
-   (IsCollinear(path[len-2], path[len-1], path[0])) do dec(len);
+   (IsCollinear(path[len-2], path[len - 1], path[0])) do dec(len);
   SetLength(Result, len);
   if (len < 2) then Exit;
   prev := path[len -1];
   j := 0;
   for i := 0 to len -2 do
   begin
-    if IsCollinear(prev, path[i], path[i+1]) then Continue;
+    if IsCollinear(prev, path[i], path[i + 1]) then Continue;
     Result[j] := path[i];
     inc(j);
     prev := path[i];
   end;
-  Result[j] := path[len -1];
-  SetLength(Result, j+1);
+  Result[j] := path[len - 1];
+  SetLength(Result, j + 1);
 end;
 //------------------------------------------------------------------------------
 
@@ -2213,6 +2214,38 @@ function PointInPolygon(const pt: TPoint64;
 //------------------------------------------------------------------------------
 {$R+}
 
+function Path2ContainsPath1(const path1, path2: TPath64): Boolean;
+var
+  i   : integer;
+  mp  : TPoint64;
+  pip : TPointInPolygonResult;
+begin
+  // precondition: paths must not intersect, except for
+  // transient (and presumed 'micro') path intersections
+  Result := false;
+  pip := pipOn;
+  for i := 0 to High(path1) do
+  begin
+    case PointInPolygon(path1[i], path2) of
+      pipOutside:
+      begin
+        if (pip = pipOutside) then Exit;
+        pip := pipOutside;
+      end;
+      pipInside:
+      begin
+        if (pip = pipInside) then begin Result := true; Exit; end;
+        pip := pipInside;
+      end;
+    end;
+  end;
+  if (pip <> pipInside) then Exit;
+  // result is likely true but check midpoint
+  mp := GetBounds(path1).MidPoint;
+  Result := PointInPolygon(mp, path2) = pipInside;
+end;
+//------------------------------------------------------------------------------
+
 procedure GetSinCos(angle: double; out sinA, cosA: double);
   {$IFDEF INLINE} inline; {$ENDIF}
 {$IFNDEF FPC}