--- Merging r32333 into '.':

U    rtl/win/wininc/base.inc
U    rtl/win/wininc/struct.inc
U    rtl/win/sysutils.pp
U    rtl/objpas/types.pp
U    rtl/win32/windows.pp
--- Recording mergeinfo for merge of r32333 into '.':
 U   .
--- Merging r32335 into '.':
A    rtl/inc/typshrdh.inc
A    rtl/inc/typshrd.inc
--- Recording mergeinfo for merge of r32335 into '.':
 G   .
--- Merging r32344 into '.':
U    rtl/wince/windows.pp
U    rtl/win64/windows.pp
--- Recording mergeinfo for merge of r32344 into '.':
 G   .
--- Merging r32361 into '.':
G    rtl/objpas/types.pp
--- Recording mergeinfo for merge of r32361 into '.':
 G   .
--- Merging r32362 into '.':
U    rtl/wince/wininc/struct.inc
--- Recording mergeinfo for merge of r32362 into '.':
 G   .
--- Merging r32456 into '.':
G    rtl/win/wininc/base.inc
--- Recording mergeinfo for merge of r32456 into '.':
 G   .
--- Merging r32692 into '.':
G    rtl/win/sysutils.pp
G    rtl/win/wininc/struct.inc
--- Recording mergeinfo for merge of r32692 into '.':
 G   .
--- Merging r32998 into '.':
U    rtl/inc/typshrd.inc
U    rtl/inc/typshrdh.inc
--- Recording mergeinfo for merge of r32998 into '.':
 G   .
--- Merging r33018 into '.':
G    rtl/wince/wininc/struct.inc
--- Recording mergeinfo for merge of r33018 into '.':
 G   .
--- Merging r33062 into '.':
G    rtl/inc/typshrd.inc
G    rtl/inc/typshrdh.inc
--- Recording mergeinfo for merge of r33062 into '.':
 G   .
--- Merging r33143 into '.':
G    rtl/win/wininc/base.inc
U    rtl/win/wininc/ascfun.inc
G    rtl/win/wininc/struct.inc
U    rtl/win/wininc/unifun.inc
--- Recording mergeinfo for merge of r33143 into '.':
 G   .
--- Merging r33216 into '.':
G    rtl/win/wininc/struct.inc
G    rtl/win/wininc/unifun.inc
G    rtl/win/wininc/base.inc
U    rtl/win/wininc/unidef.inc
G    rtl/win/wininc/ascfun.inc
--- Recording mergeinfo for merge of r33216 into '.':
 G   .
--- Merging r33217 into '.':
G    rtl/win/wininc/struct.inc
G    rtl/win/wininc/unifun.inc
G    rtl/win/wininc/ascfun.inc
--- Recording mergeinfo for merge of r33217 into '.':
 G   .
--- Merging r33227 into '.':
U    rtl/win/wininc/defines.inc
G    rtl/win/wininc/struct.inc
G    rtl/win/wininc/unifun.inc
--- Recording mergeinfo for merge of r33227 into '.':
 G   .

# revisions: 32333,32335,32344,32361,32362,32456,32692,32998,33018,33062,33143,33216,33217,33227

git-svn-id: branches/fixes_3_0@33790 -

.gitattributes

@@ -8625,6 +8625,8 @@ rtl/inc/threadvr.inc svneol=native#text/plain
 rtl/inc/tinyheap.inc svneol=native#text/plain
 rtl/inc/tnyheaph.inc svneol=native#text/plain
 rtl/inc/typefile.inc svneol=native#text/plain
+rtl/inc/typshrd.inc svneol=native#text/plain
+rtl/inc/typshrdh.inc svneol=native#text/plain
 rtl/inc/ufloat128.pp svneol=native#text/plain
 rtl/inc/ustringh.inc svneol=native#text/plain
 rtl/inc/ustrings.inc svneol=native#text/plain

rtl/inc/typshrd.inc

@@ -0,0 +1,459 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2015 by Marco van de Voort
+    member of the Free Pascal development team.
+
+    Types that are in unit types on all platforms but also in 
+    unit Windows on win<x> 
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+
+{ TSize }
+{$ifdef VER3}
+constructor TSize.Create(ax,ay:Longint);
+begin
+  cx:=ax; cy:=ay;
+end;
+
+constructor TSize.Create(asz :TSize);
+begin
+  cx:=asz.cx; cy:=asz.cy;
+  // vector:=TSize(asz.vector); ??
+end;
+{$endif}
+
+function TSize.IsZero : Boolean;
+begin
+  result:=(cx=0) and (cy=0);
+end;
+
+function TSize.Distance(const asz : TSize) : Double;
+begin
+  result:=sqrt(sqr(cx-asz.cx)+sqr(cy-asz.cy));
+end;
+
+function TSize.Add(const asz : TSize): TSize;
+begin
+  result.cx:=cx+asz.cx;
+  result.cy:=cy+asz.cy;
+end;
+
+function TSize.Subtract(const asz : TSize): TSize;
+begin
+  result.cx:=cx-asz.cx;
+  result.cy:=cy-asz.cy;
+end;
+
+class operator TSize.=(const asz1, asz2 : TSize) : Boolean;
+begin
+  result:=(asz1.cx=asz2.cx) and (asz1.cy=asz2.cy);
+end;
+
+class operator TSize.<> (const asz1, asz2 : TSize): Boolean;
+begin
+  result:=(asz1.cx<>asz2.cx) or (asz1.cy<>asz2.cy);
+end;
+
+class operator TSize.+(const asz1, asz2 : TSize): TSize;
+begin
+  result.cx:=asz1.cx+asz2.cx;
+  result.cy:=asz1.cy+asz2.cy;
+end;
+
+class operator TSize.-(const asz1, asz2 : TSize): TSize;
+begin
+  result.cx:=asz1.cx-asz2.cx;
+  result.cy:=asz1.cy-asz2.cy;
+end;
+
+{ TPoint }
+{$ifdef VER3}
+constructor TPoint.Create(ax,ay:Longint);
+begin
+  x:=ax; y:=ay;
+end;
+
+constructor TPoint.Create(apt :TPoint);
+begin
+  x:=apt.x; y:=apt.y;
+end;
+
+{$endif}
+function TPoint.Add(const apt: TPoint): TPoint;
+begin
+  result.x:=x+apt.x;
+  result.y:=y+apt.y;
+end;
+
+function TPoint.Distance(const apt: TPoint): ValReal;
+begin
+  result:=sqrt(sqr(ValReal(apt.x)-ValReal(x))+sqr(ValReal(apt.y)-ValReal(y))); // convert to ValReal to prevent integer overflows
+end;
+
+function TPoint.IsZero : Boolean;
+begin
+ result:=(x=0) and (y=0);
+end;
+
+function TPoint.Subtract(const apt : TPoint): TPoint;
+begin
+  result.x:=x-apt.x;
+  result.y:=y-apt.y;
+end;
+
+class function TPoint.Zero: TPoint;
+begin
+  Result.x := 0;
+  Result.y := 0;
+end;
+
+procedure TPoint.SetLocation(const apt :TPoint);
+begin
+ x:=apt.x; y:=apt.y;
+end;
+procedure TPoint.SetLocation(ax,ay : Longint);
+begin
+  x:=ax; y:=ay;
+end;
+
+procedure TPoint.Offset(const apt :TPoint);
+begin
+ x:=x+apt.x;
+ y:=y+apt.y;
+end;
+
+class function TPoint.PointInCircle(const apt, acenter: TPoint;
+  const aradius: Integer): Boolean;
+begin
+  Result := apt.Distance(acenter) <= aradius;
+end;
+
+procedure TPoint.Offset(dx,dy : Longint);
+begin
+  x:=x+dx;
+  y:=y+dy;
+end;
+
+class operator TPoint.= (const apt1, apt2 : TPoint) : Boolean;
+begin
+  result:=(apt1.x=apt2.x) and (apt1.y=apt2.y);
+end;
+
+class operator TPoint.<> (const apt1, apt2 : TPoint): Boolean;
+begin
+  result:=(apt1.x<>apt2.x) or (apt1.y<>apt2.y);
+end;
+
+class operator TPoint.+ (const apt1, apt2 : TPoint): TPoint;
+begin
+  result.x:=apt1.x+apt2.x;
+  result.y:=apt1.y+apt2.y;
+end;
+
+class operator TPoint.- (const apt1, apt2 : TPoint): TPoint;
+begin
+  result.x:=apt1.x-apt2.x;
+  result.y:=apt1.y-apt2.y;
+end;
+
+// warning suppression for the next ones?
+class operator TPoint.:= (const aspt : TSmallPoint): TPoint;
+begin
+  result.x:=aspt.x;
+  result.y:=aspt.y;
+end;
+
+class operator TPoint.Explicit (const apt: TPoint): TSmallPoint;
+begin
+  result.x:=apt.x;
+  result.y:=apt.y;
+end;
+
+{ TRect }
+
+class operator TRect. * (L, R: TRect): TRect;
+begin
+  Result := TRect.Intersect(L, R);
+end;
+
+class operator TRect. + (L, R: TRect): TRect;
+begin
+  Result := TRect.Union(L, R);
+end;
+
+class operator TRect. <> (L, R: TRect): Boolean;
+begin
+  Result := not(L=R);
+end;
+
+class operator TRect. = (L, R: TRect): Boolean;
+begin
+  Result :=
+    (L.Left = R.Left) and (L.Right = R.Right) and
+    (L.Top = R.Top) and (L.Bottom = R.Bottom);
+end;
+
+{$IFDEF VER3_0_0}
+class function TRect.Create(ALeft, ATop, ARight, ABottom: Longint): TRect;
+begin
+  Result.Left := ALeft;
+  Result.Top := ATop;
+  Result.Right := ARight;
+  Result.Bottom := ABottom;
+end;
+
+class function TRect.Create(P1, P2: TPoint; Normalize: Boolean): TRect;
+begin
+  Result.TopLeft := P1;
+  Result.BottomRight := P2;
+  if Normalize then
+    Result.NormalizeRect;
+end;
+
+class function TRect.Create(Origin: TPoint): TRect;
+begin
+  Result.TopLeft := Origin;
+  Result.BottomRight := Origin;
+end;
+
+class function TRect.Create(Origin: TPoint; AWidth, AHeight: Longint): TRect;
+begin
+  Result.TopLeft := Origin;
+  Result.Width := AWidth;
+  Result.Height := AHeight;
+end;
+
+class function TRect.Create(R: TRect; Normalize: Boolean): TRect;
+begin
+  Result := R;
+  if Normalize then
+    Result.NormalizeRect;
+end;
+
+{$ELSE}
+
+constructor TRect.Create(ALeft, ATop, ARight, ABottom: Longint);
+begin
+  Left := ALeft;
+  Top := ATop;
+  Right := ARight;
+  Bottom := ABottom;
+end;
+
+constructor TRect.Create(P1, P2: TPoint; Normalize: Boolean);
+begin
+  TopLeft := P1;
+  BottomRight := P2;
+  if Normalize then
+    NormalizeRect;
+end;
+
+constructor TRect.Create(Origin: TPoint);
+begin
+  TopLeft := Origin;
+  BottomRight := Origin;
+end;
+
+constructor TRect.Create(Origin: TPoint; AWidth, AHeight: Longint);
+begin
+  TopLeft := Origin;
+  Width := AWidth;
+  Height := AHeight;
+end;
+
+constructor TRect.Create(R: TRect; Normalize: Boolean);
+begin
+  Self := R;
+  if Normalize then
+    NormalizeRect;
+end;
+{$ENDIF}
+
+function TRect.CenterPoint: TPoint;
+begin
+  Result.X := (Right-Left) div 2 + Left;
+  Result.Y := (Bottom-Top) div 2 + Top;
+end;
+
+function TRect.Contains(Pt: TPoint): Boolean;
+begin
+  Result := (Left <= Pt.X) and (Pt.X <= Right) and (Top <= Pt.Y) and (Pt.Y <= Bottom);
+end;
+
+function TRect.Contains(R: TRect): Boolean;
+begin
+  Result := (Left <= R.Left) and (R.Right <= Right) and (Top <= R.Top) and (R.Bottom <= Bottom);
+end;
+
+class function TRect.Empty: TRect;
+begin
+  Result := TRect.Create(0,0,0,0);
+end;
+
+function TRect.getHeight: Longint;
+begin
+  result:=bottom-top;
+end;
+
+function TRect.getLocation: TPoint;
+begin
+  result.x:=Left; result.y:=top;
+end;
+
+function TRect.getSize: TSize;
+begin
+  result.cx:=width; result.cy:=height;
+end;
+
+function TRect.getWidth: Longint;
+begin
+  result:=right-left;
+end;
+
+procedure TRect.Inflate(DX, DY: Longint);
+begin
+  InflateRect(Self, DX, DY);
+end;
+
+procedure TRect.Intersect(R: TRect);
+begin
+  Self := Intersect(Self, R);
+end;
+
+class function TRect.Intersect(R1: TRect; R2: TRect): TRect;
+begin
+  IntersectRect(Result, R1, R2);
+end;
+
+function TRect.IntersectsWith(R: TRect): Boolean;
+begin
+  Result := (Left < R.Right) and (R.Left < Right) and (Top < R.Bottom) and (R.Top < Bottom);
+end;
+
+function TRect.IsEmpty: Boolean;
+begin
+  Result := (Right <= Left) or (Bottom <= Top);
+end;
+
+procedure TRect.NormalizeRect;
+var
+  x: LongInt;
+begin
+  if Top>Bottom then
+  begin
+    x := Top;
+    Top := Bottom;
+    Bottom := x;
+  end;
+  if Left>Right then
+  begin
+    x := Left;
+    Left := Right;
+    Right := x;
+  end
+end;
+
+procedure TRect.Inflate(DL, DT, DR, DB: Longint);
+begin
+  Dec(Left, DL);
+  Dec(Top, DT);
+  Inc(Right, DR);
+  Inc(Bottom, DB);
+end;
+
+procedure TRect.Offset(DX, DY: Longint);
+begin
+  OffsetRect(Self, DX, DY);
+end;
+
+procedure TRect.Offset(DP: TPoint);
+begin
+  OffsetRect(Self, DP.X, DP.Y);
+end;
+
+procedure TRect.setHeight(AValue: Longint);
+begin
+  right:=left+avalue;
+end;
+
+procedure TRect.SetLocation(X, Y: Longint);
+begin
+  Offset(X-Left, Y-Top);
+end;
+
+procedure TRect.SetLocation(P: TPoint);
+begin
+  SetLocation(P.X, P.Y);
+end;
+
+procedure TRect.setSize(AValue: TSize);
+begin
+  bottom:=top+avalue.cy;
+  right:=left+avalue.cx;
+end;
+
+procedure TRect.setWidth(AValue: Longint);
+begin
+  bottom:=top+avalue;
+end;
+
+function TRect.SplitRect(SplitType: TSplitRectType; Percent: Double): TRect;
+begin
+  Result := Self;
+  case SplitType of
+    srLeft: Result.Right := Left + Trunc(Percent*Width);
+    srRight: Result.Left := Right - Trunc(Percent*Width);
+    srTop: Result.Bottom := Top + Trunc(Percent*Height);
+    srBottom: Result.Top := Bottom - Trunc(Percent*Height);
+  end;
+end;
+
+function TRect.SplitRect(SplitType: TSplitRectType; ASize: Longint): TRect;
+begin
+  Result := Self;
+  case SplitType of
+    srLeft: Result.Right := Left + ASize;
+    srRight: Result.Left := Right - ASize;
+    srTop: Result.Bottom := Top + ASize;
+    srBottom: Result.Top := Bottom - ASize;
+  end;
+end;
+
+class function TRect.Union(const Points: array of TPoint): TRect;
+var
+  i: Integer;
+begin
+  if Length(Points) > 0 then
+  begin
+    Result.TopLeft := Points[Low(Points)];
+    Result.BottomRight := Points[Low(Points)];
+
+    for i := Low(Points)+1 to High(Points) do
+    begin
+      if Points[i].X < Result.Left then Result.Left := Points[i].X;
+      if Points[i].X > Result.Right then Result.Right := Points[i].X;
+      if Points[i].Y < Result.Top then Result.Top := Points[i].Y;
+      if Points[i].Y > Result.Bottom then Result.Bottom := Points[i].Y;
+    end;
+  end else
+    Result := Empty;
+end;
+
+procedure TRect.Union(R: TRect);
+begin
+  Self := Union(Self, R);
+end;
+
+class function TRect.Union(R1, R2: TRect): TRect;
+begin
+  UnionRect(Result, R1, R2);
+end;
+
+

rtl/inc/typshrdh.inc

@@ -0,0 +1,164 @@
+{
+    This file is part of the Free Pascal run time library.
+    Copyright (c) 2015 by Marco van de Voort
+    member of the Free Pascal development team.
+
+    Types that are in unit types on all platforms but also in 
+    unit Windows on win<x> 
+
+    Name is types shared, but 8.3'd to typshard
+
+    See the file COPYING.FPC, included in this distribution,
+    for details about the copyright.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+ **********************************************************************}
+
+// the aliases without "T" remain unit Windows only, so are in unit Windows, not here.
+// note 2.6.x requires a space after the operator, 3.x.x seems to fix it.
+// tried to make all records unions with an array type as second form, but that
+// fails because of the properties. TRect doesn't suffer from this because it has
+// getters/setters in the properties instead of field references
+
+  TArray4IntegerType = array[0..3] of Longint;
+
+  PSmallPoint = ^TSmallPoint;
+  TSmallPoint =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  record
+      X,
+      Y : SmallInt;
+      end;
+
+  TSize =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  record
+      cx : Longint; cy : Longint;
+     public
+       {$ifdef VER3}
+       constructor Create(ax,ay:Longint); overload;
+       constructor Create(asz :TSize); overload;
+       {$endif}
+       function Add(const asz: TSize): TSize;
+       function Distance(const asz : TSize) : Double;
+       function IsZero : Boolean;
+       function Subtract(const asz : TSize): TSize;
+       class operator = (const asz1, asz2 : TSize) : Boolean;
+       class operator <> (const asz1, asz2 : TSize): Boolean;
+       class operator + (const asz1, asz2 : TSize): TSize;
+       class operator - (const asz1, asz2 : TSize): TSize;
+       property Width : Longint read cx write cx;
+       property Height: Longint read cy write cy;
+     end;
+  PSize =^TSize;
+
+  TPoint  =
+  {$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+   packed
+  {$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  record
+       x : Longint; y : Longint;
+     public
+       {$ifdef VER3}
+       constructor Create(ax,ay:Longint); overload;
+       constructor Create(apt :TPoint); overload;
+       {$endif}
+       class function Zero: TPoint; static; inline;
+       function Add(const apt: TPoint): TPoint;
+       function Distance(const apt: TPoint) : ValReal;
+       function IsZero : Boolean;
+       function Subtract(const apt : TPoint): TPoint;
+       procedure SetLocation(const apt :TPoint);
+       procedure SetLocation(ax,ay : Longint);
+       procedure Offset(const apt :TPoint);
+       procedure Offset(dx,dy : Longint);
+       class function PointInCircle(const apt, acenter: TPoint; const aradius: Integer): Boolean; static; inline;
+       class operator = (const apt1, apt2 : TPoint) : Boolean;
+       class operator <> (const apt1, apt2 : TPoint): Boolean;
+       class operator + (const apt1, apt2 : TPoint): TPoint;
+       class operator - (const apt1, apt2 : TPoint): TPoint;
+       class operator := (const aspt : TSmallPoint) : TPoint;
+       class operator Explicit (Const apt : TPoint) : TSmallPoint;
+     end;
+  PPoint = ^TPoint;
+
+  TSplitRectType = (
+    srLeft,
+    srRight,
+    srTop,
+    srBottom
+  );
+
+  { TRect }
+
+  TRect =
+{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
+  packed
+{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
+  record
+     private
+       function  getHeight: Longint; inline;
+       function  getLocation: TPoint;
+       function  getSize: TSize;
+       function  getWidth : Longint; inline;
+       procedure setHeight(AValue: Longint);
+       procedure setSize(AValue: TSize);
+       procedure setWidth (AValue: Longint);
+     public
+{$IFDEF VER3_0_0}
+       class function Create(Origin: TPoint): TRect; static; // empty rect at given origin
+       class function Create(Origin: TPoint; AWidth, AHeight: Longint): TRect; static;
+       class function Create(ALeft, ATop, ARight, ABottom: Longint): TRect; static;   
+       class function Create(P1, P2: TPoint; Normalize: Boolean = False): TRect; static;
+       class function Create(R: TRect; Normalize: Boolean = False): TRect; static;
+{$ELSE}       
+       constructor Create(Origin: TPoint); // empty rect at given origin
+       constructor Create(Origin: TPoint; AWidth, AHeight: Longint);
+       constructor Create(ALeft, ATop, ARight, ABottom: Longint);
+       constructor Create(P1, P2: TPoint; Normalize: Boolean = False);
+       constructor Create(R: TRect; Normalize: Boolean = False);
+{$ENDIF}       
+       class operator = (L, R: TRect): Boolean;
+       class operator <> (L, R: TRect): Boolean;
+       class operator + (L, R: TRect): TRect; // union
+       class operator * (L, R: TRect): TRect; // intersection
+       class function Empty: TRect; static;
+       procedure NormalizeRect;
+       function IsEmpty: Boolean;
+       function Contains(Pt: TPoint): Boolean;
+       function Contains(R: TRect): Boolean;
+       function IntersectsWith(R: TRect): Boolean;
+       class function Intersect(R1: TRect; R2: TRect): TRect; static;
+       procedure Intersect(R: TRect);
+       class function Union(R1, R2: TRect): TRect; static;
+       procedure Union(R: TRect);
+       class function Union(const Points: array of TPoint): TRect; static;
+       procedure Offset(DX, DY: Longint);
+       procedure Offset(DP: TPoint);
+       procedure SetLocation(X, Y: Longint);
+       procedure SetLocation(P: TPoint);
+       procedure Inflate(DX, DY: Longint);
+       procedure Inflate(DL, DT, DR, DB: Longint);
+       function CenterPoint: TPoint;
+       function SplitRect(SplitType: TSplitRectType; ASize: Longint): TRect;
+       function SplitRect(SplitType: TSplitRectType; Percent: Double): TRect;
+     public
+       property Height: Longint read getHeight write setHeight;
+       property Width : Longint read getWidth  write setWidth;
+       property Size  : TSize   read getSize   write setSize;
+       property Location  : TPoint read getLocation write setLocation;
+       case Longint of
+         0: (Left,Top,Right,Bottom : Longint);
+         1: (TopLeft,BottomRight : TPoint);
+         2: (Vector:TArray4IntegerType);
+       end;
+  PRect = ^TRect;
+
+

rtl/objpas/types.pp

@@ -15,7 +15,8 @@
 unit Types;
 
   interface
-
+{$modeswitch advancedrecords}
+{$modeswitch class}
 {$ifdef Windows}
     uses
        Windows;
@@ -68,63 +69,79 @@ type
 {$endif}
 
 {$ifdef Windows}
+  TSmallPoint = Windows.TSmallPoint;
+  PSmallPoint = Windows.PSmallPoint;
+
+  TSize  = Windows.TSize;
+  TagSize  = Windows.tagSize deprecated;
+  PSize  = Windows.PSize;
+
   TPoint = Windows.TPoint;
-{$else}
-  TPoint =
-{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
-  packed
-{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
-  record
-    X : Longint;
-    Y : Longint;
-  end;
-{$endif}
-  PPoint = ^TPoint;
-  tagPOINT = TPoint;
+  TagPoint = Windows.TagPoint deprecated;
+  PPoint = Windows.PPoint;
 
-{$ifdef Windows}
-  TRect = Windows.TRect;
+  TRect  = Windows.TRect;
+  PRect  = Windows.PRect;
 {$else}
-  TRect =
-{$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
-  packed
-{$endif FPC_REQUIRES_PROPER_ALIGNMENT}
-  record
-    case Integer of
-      0: (Left,Top,Right,Bottom : Longint);
-      1: (TopLeft,BottomRight : TPoint);
-    end;
-{$endif Windows}
-  PRect = ^TRect;
+  {$i typshrdh.inc}
+   TagSize = tSize deprecated;
+   TagPoint = TPoint deprecated;
+{$endif}
 
-{$ifdef Windows}
-  TSize = Windows.TSize;
-{$else}
-  TSize =
+  { TPointF }
+  TPointF =
 {$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
   packed
 {$endif FPC_REQUIRES_PROPER_ALIGNMENT}
   record
-     cx : Longint;
-     cy : Longint;
-  end;
-{$endif Windows}
-
-
-  PSize = ^TSize;
-  tagSIZE = TSize;
-//  SIZE = TSize;
-
-
-  TSmallPoint =
+       x,y : Single;
+       public
+          function Add(const apt: TPoint): TPointF;
+          function Add(const apt: TPointF): TPointF;
+          function Distance(const apt : TPointF) : Single;
+          function DotProduct(const apt : TPointF) : Single;
+          function IsZero : Boolean;
+          function Subtract(const apt : TPointF): TPointF;
+          function Subtract(const apt : TPoint): TPointF;
+          procedure SetLocation(const apt :TPointF);
+          procedure SetLocation(const apt :TPoint);
+          procedure SetLocation(ax,ay : Longint);
+          procedure Offset(const apt :TPointF);
+          procedure Offset(const apt :TPoint);
+          procedure Offset(dx,dy : Longint);
+
+          function  Scale (afactor:Single)  : TPointF;
+          function  Ceiling : TPoint;
+          function  Truncate: TPoint;
+          function  Floor   : TPoint;
+          function  Round   : TPoint;
+          function  Length  : Single;
+          class operator = (const apt1, apt2 : TPointF) : Boolean;
+          class operator <> (const apt1, apt2 : TPointF): Boolean;
+          class operator + (const apt1, apt2 : TPointF): TPointF;
+          class operator - (const apt1, apt2 : TPointF): TPointF;
+       end;
+  { TRectF }
+
+  TRectF =
 {$ifndef FPC_REQUIRES_PROPER_ALIGNMENT}
   packed
 {$endif FPC_REQUIRES_PROPER_ALIGNMENT}
   record
-     x : SmallInt;
-     y : SmallInt;
-  end;
-  PSmallPoint = ^TSmallPoint;
+  private
+    function GetHeight: Single; inline;
+    function GetWidth: Single;  inline;
+    procedure SetHeight(AValue: Single);
+    procedure SetWidth (AValue: Single);
+  public
+    function  Union  (const r: TRectF):TRectF; inline;
+    procedure Offset (const dx,dy : Single); inline;
+    property  Width  : Single read GetWidth write SetWidth;
+    property  Height : Single read GetHeight write SetHeight;
+    case Integer of
+     0: (Left, Top, Right, Bottom: Single);
+     1: (TopLeft, BottomRight: TPointF);
+    end;
 
   TDuplicates = (dupIgnore, dupAccept, dupError);
 
@@ -305,6 +322,11 @@ function Size(const ARect: TRect): TSize;
 
 implementation
 
+Uses Math;
+
+{$ifndef Windows}
+  {$i typshrd.inc}
+{$endif}
 
 function EqualRect(const r1,r2 : TRect) : Boolean;
 
@@ -312,7 +334,6 @@ begin
   EqualRect:=(r1.left=r2.left) and (r1.right=r2.right) and (r1.top=r2.top) and (r1.bottom=r2.bottom);
 end;
 
-
 function Rect(Left,Top,Right,Bottom : Integer) : TRect;
 
 begin
@@ -322,7 +343,6 @@ begin
   Rect.Bottom:=Bottom;
 end;
 
-
 function Bounds(ALeft,ATop,AWidth,AHeight : Integer) : TRect;
 
 begin
@@ -332,7 +352,6 @@ begin
   Bounds.Bottom:=ATop+AHeight;
 end;
 
-
 function Point(x,y : Integer) : TPoint; inline;
 
 begin
@@ -349,7 +368,6 @@ begin
             (p.x<Rect.Right);
 end;
 
-
 function IntersectRect(var Rect : TRect;const R1,R2 : TRect) : Boolean;
 var
   lRect: TRect;
@@ -474,5 +492,171 @@ begin
 end;
 
 
+{ TPointF}
+
+function TPointF.Add(const apt: TPoint): TPointF;
+begin
+  result.x:=x+apt.x;
+  result.y:=y+apt.y;
+end;
+
+function TPointF.Add(const apt: TPointF): TPointF;
+begin
+  result.x:=x+apt.x;
+  result.y:=y+apt.y;
+end;
+
+function TPointF.Subtract(const apt : TPointF): TPointF;
+begin
+  result.x:=x-apt.x;
+  result.y:=y-apt.y;
+end;
+
+function TPointF.Subtract(const apt: TPoint): TPointF;
+begin
+  result.x:=x-apt.x;
+  result.y:=y-apt.y;
+end;
+
+function TPointF.Distance(const apt : TPointF) : Single;
+begin
+  result:=sqrt(sqr(apt.x-x)+sqr(apt.y-y));
+end;
+
+function TPointF.DotProduct(const apt: TPointF): Single;
+begin
+  result:=x*apt.x+y*apt.y;
+end;
+
+function TPointF.IsZero : Boolean;
+begin
+  result:=SameValue(x,0.0) and SameValue(y,0.0);
+end;
+
+procedure TPointF.Offset(const apt :TPointF);
+begin
+  x:=x+apt.x;
+  y:=y+apt.y;
+end;
+
+procedure TPointF.Offset(const apt: TPoint);
+begin
+  x:=x+apt.x;
+  y:=y+apt.y;
+end;
+
+procedure TPointF.Offset(dx,dy : Longint);
+begin
+  x:=x+dx;
+  y:=y+dy;
+end;
+
+function TPointF.Scale(afactor: Single): TPointF;
+begin
+  result.x:=afactor*x;
+  result.y:=afactor*y;
+end;
+
+function TPointF.Ceiling: TPoint;
+begin
+  result.x:=ceil(x);
+  result.y:=ceil(y);
+end;
+
+function TPointF.Truncate: TPoint;
+begin
+  result.x:=trunc(x);
+  result.y:=trunc(y);
+end;
+
+function TPointF.Floor: TPoint;
+begin
+  result.x:=Math.floor(x);
+  result.y:=Math.floor(y);
+end;
+
+function TPointF.Round: TPoint;
+begin
+  result.x:=System.round(x);
+  result.y:=System.round(y);
+end;
+
+function TPointF.Length: Single;
+begin     //distance(self) ?
+  result:=sqrt(sqr(x)+sqr(y));
+end;
+
+class operator TPointF.= (const apt1, apt2 : TPointF) : Boolean;
+begin
+  result:=SameValue(apt1.x,apt2.x) and SameValue(apt1.y,apt2.y);
+end;
+
+class operator TPointF.<> (const apt1, apt2 : TPointF): Boolean;
+begin
+  result:=NOT (SameValue(apt1.x,apt2.x) and Samevalue(apt1.y,apt2.y));
+end;
+
+class operator TPointF.+ (const apt1, apt2 : TPointF): TPointF;
+begin
+  result.x:=apt1.x+apt2.x;
+  result.y:=apt1.y+apt2.y;
+end;
+
+class operator TPointF.- (const apt1, apt2 : TPointF): TPointF;
+begin
+  result.x:=apt1.x-apt2.x;
+  result.y:=apt1.y-apt2.y;
+end;
+
+procedure TPointF.SetLocation(const apt :TPointF);
+begin
+ x:=apt.x; y:=apt.y;
+end;
+
+procedure TPointF.SetLocation(const apt: TPoint);
+begin
+  x:=apt.x; y:=apt.y;
+end;
+
+procedure TPointF.SetLocation(ax,ay : Longint);
+begin
+  x:=ax; y:=ay;
+end;
+
+{ TRectF }
+
+function TRectF.GetHeight: Single;
+begin
+  result:=bottom-top;
+end;
+
+function TRectF.GetWidth: Single;
+begin
+ result:=right-left;
+end;
+
+procedure TRectF.SetHeight(AValue: Single);
+begin
+  bottom:=top+avalue;
+end;
+
+procedure TRectF.SetWidth(AValue: Single);
+begin
+  right:=left+avalue;
+end;
+
+function TRectF.Union(const r: TRectF): TRectF;
+begin
+  result.left:=min(r.left,left);
+  result.top:=min(r.top,top);
+  result.right:=min(r.right,right);
+  result.bottom:=min(r.bottom,bottom);
+end;
+
+procedure TRectF.Offset(const dx, dy: Single);
+begin
+  left:=left+dx; right:=right+dx;
+  bottom:=bottom+dy; top:=top+dy;
+end;
 
 end.

rtl/win/sysutils.pp

@@ -255,7 +255,7 @@ begin
         rc := WNetGetUniversalNameW (pwidechar(s), UNIVERSAL_NAME_INFO_LEVEL, buf, @size);
       end;
     if rc = NO_ERROR then
-      Result := PRemoteNameInfo(buf)^.lpUniversalName
+      Result := PRemoteNameInfoW(buf)^.lpUniversalName
     else if rc = ERROR_NOT_CONNECTED then
       Result := filename
     else
@@ -1110,14 +1110,20 @@ end;
 
 {$pop}
 
-function ExecuteProcess(Const Path: AnsiString; Const ComLine: AnsiString;Flags:TExecuteFlags=[]):integer;
+function ExecuteProcess(Const Path: RawByteString; Const ComLine: RawByteString;Flags:TExecuteFlags=[]):integer;
+begin
+  result:=ExecuteProcess(Unicodestring(Path),UnicodeString(ComLine),Flags);
+end;
+
+
+function ExecuteProcess(Const Path: UnicodeString; Const ComLine: UnicodeString;Flags:TExecuteFlags=[]):integer;
 // win specific  function
 var
-  SI: TStartupInfo;
+  SI: TStartupInfoW;
   PI: TProcessInformation;
   Proc : THandle;
   l    : DWord;
-  CommandLine : ansistring;
+  CommandLine : unicodestring;
   e : EOSError;
   ExecInherits : longbool;
 begin
@@ -1140,7 +1146,7 @@ begin
 
   ExecInherits:=ExecInheritsHandles in Flags;
 
-  if not CreateProcessA(nil, pchar(CommandLine),
+  if not CreateProcessW(nil, pwidechar(CommandLine),
     Nil, Nil, ExecInherits,$20, Nil, Nil, SI, PI) then
     begin
       e:=EOSError.CreateFmt(SExecuteProcessFailed,[CommandLine,GetLastError]);
@@ -1165,10 +1171,27 @@ begin
     end;
 end;
 
-function ExecuteProcess(Const Path: AnsiString; Const ComLine: Array of AnsiString;Flags:TExecuteFlags=[]):integer;
+
+function ExecuteProcess(Const Path: RawByteString; Const ComLine: Array of RawByteString;Flags:TExecuteFlags=[]):integer;
+
+var
+  CommandLine: UnicodeString;
+  I: integer;
+
+begin
+  Commandline := '';
+  for I := 0 to High (ComLine) do
+   if Pos (' ', ComLine [I]) <> 0 then
+    CommandLine := CommandLine + ' ' + '"' + ComLine [I] + '"'
+   else
+    CommandLine := CommandLine + ' ' + Comline [I];
+  ExecuteProcess := ExecuteProcess (UnicodeString(Path), CommandLine,Flags);
+end;
+
+function ExecuteProcess(Const Path: UnicodeString; Const ComLine: Array of UnicodeString;Flags:TExecuteFlags=[]):integer;
 
 var
-  CommandLine: AnsiString;
+  CommandLine: UnicodeString;
   I: integer;
 
 begin
@@ -1178,7 +1201,7 @@ begin
     CommandLine := CommandLine + ' ' + '"' + ComLine [I] + '"'
    else
     CommandLine := CommandLine + ' ' + Comline [I];
-  ExecuteProcess := ExecuteProcess (Path, CommandLine,Flags);
+  ExecuteProcess := ExecuteProcess (Path,CommandLine,Flags);
 end;
 
 Procedure Sleep(Milliseconds : Cardinal);

rtl/win/wininc/ascfun.inc

@@ -77,9 +77,9 @@ function ExpandEnvironmentStringsA(lpSrc:LPCSTR; lpDst:LPSTR; nSize:DWORD):DWORD
 procedure OutputDebugStringA(lpOutputString:LPCSTR); external 'kernel32' name 'OutputDebugStringA';
 function FindResourceA(hModule:HINST; lpName:LPCSTR; lpType:LPCSTR):HRSRC; external 'kernel32' name 'FindResourceA';
 function FindResourceExA(hModule:HINST; lpType:LPCSTR; lpName:LPCSTR; wLanguage:WORD):HRSRC; external 'kernel32' name 'FindResourceExA';
-function EnumResourceTypesA(hModule:HMODULE; lpEnumFunc:ENUMRESTYPEPROC; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceTypesA';
-function EnumResourceNamesA(hModule:HMODULE; lpType:LPCSTR; lpEnumFunc:ENUMRESNAMEPROC; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceNamesA';
-function EnumResourceLanguagesA(hModule:HMODULE; lpType:LPCSTR; lpName:LPCSTR; lpEnumFunc:ENUMRESLANGPROC; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceLanguagesA';
+function EnumResourceTypesA(hModule:HMODULE; lpEnumFunc:ENUMRESTYPEPROCA; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceTypesA';
+function EnumResourceNamesA(hModule:HMODULE; lpType:LPCSTR; lpEnumFunc:ENUMRESNAMEPROCA; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceNamesA';
+function EnumResourceLanguagesA(hModule:HMODULE; lpType:LPCSTR; lpName:LPCSTR; lpEnumFunc:ENUMRESLANGPROCA; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceLanguagesA';
 function BeginUpdateResourceA(pFileName:LPCSTR; bDeleteExistingResources:WINBOOL):HANDLE; external 'kernel32' name 'BeginUpdateResourceA';
 function UpdateResourceA(hUpdate:HANDLE; lpType:LPCSTR; lpName:LPCSTR; wLanguage:WORD; lpData:LPVOID;cbData:DWORD):WINBOOL; external 'kernel32' name 'UpdateResourceA';
 function EndUpdateResourceA(hUpdate:HANDLE; fDiscard:WINBOOL):WINBOOL; external 'kernel32' name 'EndUpdateResourceA';
@@ -176,7 +176,7 @@ function OpenDesktopA(lpszDesktop:LPSTR; dwFlags:DWORD; fInherit:WINBOOL; dwDesi
 function EnumDesktopsA(hwinsta:HWINSTA; lpEnumFunc:DESKTOPENUMPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumDesktopsA';
 function CreateWindowStationA(lpwinsta:LPSTR; dwReserved:DWORD; dwDesiredAccess:DWORD; lpsa:LPSECURITY_ATTRIBUTES):HWINSTA; external 'user32' name 'CreateWindowStationA';
 function OpenWindowStationA(lpszWinSta:LPSTR; fInherit:WINBOOL; dwDesiredAccess:DWORD):HWINSTA; external 'user32' name 'OpenWindowStationA';
-function EnumWindowStationsA(lpEnumFunc:ENUMWINDOWSTATIONPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumWindowStationsA';
+function EnumWindowStationsA(lpEnumFunc:ENUMWINDOWSTATIONPROCA; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumWindowStationsA';
 function GetUserObjectInformationA(hObj:HANDLE; nIndex:longint; pvInfo:PVOID; nLength:DWORD; lpnLengthNeeded:LPDWORD):WINBOOL; external 'user32' name 'GetUserObjectInformationA';
 function SetUserObjectInformationA(hObj:HANDLE; nIndex:longint; pvInfo:PVOID; nLength:DWORD):WINBOOL; external 'user32' name 'SetUserObjectInformationA';
 function RegisterWindowMessageA(lpString:LPCSTR):UINT; external 'user32' name 'RegisterWindowMessageA';
@@ -193,9 +193,9 @@ function DefWindowProcA(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESU
 function CallWindowProcA(lpPrevWndFunc:WNDPROC; hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; external 'user32' name 'CallWindowProcA';
 function RegisterClassA(lpWndClass:LPWNDCLASS):ATOM; external 'user32' name 'RegisterClassA';
 function UnregisterClassA(lpClassName:LPCSTR; hInstance:HINST):WINBOOL; external 'user32' name 'UnregisterClassA';
-function GetClassInfoA(hInstance:HINST; lpClassName:LPCSTR; lpWndClass:LPWNDCLASS):WINBOOL; external 'user32' name 'GetClassInfoA';
-function RegisterClassExA(_para1:LPWNDCLASSEX):ATOM; external 'user32' name 'RegisterClassExA';
-function GetClassInfoExA(_para1:HINST; _para2:LPCSTR; _para3:LPWNDCLASSEX):WINBOOL; external 'user32' name 'GetClassInfoExA';
+function GetClassInfoA(hInstance:HINST; lpClassName:LPCSTR; lpWndClass:LPWNDCLASSA):WINBOOL; external 'user32' name 'GetClassInfoA';
+function RegisterClassExA(_para1:LPWNDCLASSEXA):ATOM; external 'user32' name 'RegisterClassExA';
+function GetClassInfoExA(_para1:HINST; _para2:LPCSTR; _para3:LPWNDCLASSEXA):WINBOOL; external 'user32' name 'GetClassInfoExA';
 function CreateWindowExA(dwExStyle:DWORD; lpClassName:LPCSTR; lpWindowName:LPCSTR; dwStyle:DWORD; X:longint;Y:longint; nWidth:longint; nHeight:longint; hWndParent:HWND; hMenu:HMENU;hInstance:HINST; lpParam:LPVOID):HWND;
   external 'user32' name 'CreateWindowExA';
 function CreateDialogParamA(hInstance:HINST; lpTemplateName:LPCSTR; hWndParent:HWND; lpDialogFunc:DLGPROC; dwInitParam:LPARAM):HWND; external 'user32' name 'CreateDialogParamA';
@@ -239,9 +239,9 @@ function GetMenuStringA(hMenu:HMENU; uIDItem:UINT; lpString:LPSTR; nMaxCount:lon
 function InsertMenuA(hMenu:HMENU; uPosition:UINT; uFlags:UINT; uIDNewItem:UINT; lpNewItem:LPCSTR):WINBOOL; external 'user32' name 'InsertMenuA';
 function AppendMenuA(hMenu:HMENU; uFlags:UINT; uIDNewItem:UINT; lpNewItem:LPCSTR):WINBOOL; external 'user32' name 'AppendMenuA';
 function ModifyMenuA(hMnu:HMENU; uPosition:UINT; uFlags:UINT; uIDNewItem:UINT; lpNewItem:LPCSTR):WINBOOL; external 'user32' name 'ModifyMenuA';
-function InsertMenuItemA(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFO):WINBOOL; external 'user32' name 'InsertMenuItemA';
-function GetMenuItemInfoA(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPMENUITEMINFO):WINBOOL; external 'user32' name 'GetMenuItemInfoA';
-function SetMenuItemInfoA(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFO):WINBOOL; external 'user32' name 'SetMenuItemInfoA';
+function InsertMenuItemA(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFOA):WINBOOL; external 'user32' name 'InsertMenuItemA';
+function GetMenuItemInfoA(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPMENUITEMINFOA):WINBOOL; external 'user32' name 'GetMenuItemInfoA';
+function SetMenuItemInfoA(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFOA):WINBOOL; external 'user32' name 'SetMenuItemInfoA';
 function DrawTextA(hDC:HDC; lpString:LPCSTR; nCount:longint; lpRect:LPRECT; uFormat:UINT):longint; external 'user32' name 'DrawTextA';
 function DrawTextExA(_para1:HDC; _para2:LPSTR; _para3:longint; _para4:LPRECT; _para5:UINT;_para6:LPDRAWTEXTPARAMS):longint; external 'user32' name 'DrawTextExA';
 function GrayStringA(hDC:HDC; hBrush:HBRUSH; lpOutputFunc:GRAYSTRINGPROC; lpData:LPARAM; nCount:longint;X:longint; Y:longint; nWidth:longint; nHeight:longint):WINBOOL; external 'user32' name 'GrayStringA';
@@ -258,7 +258,7 @@ function GetWindowTextA(hWnd:HWND; lpString:LPSTR; nMaxCount:longint):longint; e
 function GetWindowTextLengthA(hWnd:HWND):longint; external 'user32' name 'GetWindowTextLengthA';
 function MessageBoxA(hWnd:HWND; lpText:LPCSTR; lpCaption:LPCSTR; uType:UINT):longint; external 'user32' name 'MessageBoxA';
 function MessageBoxExA(hWnd:HWND; lpText:LPCSTR; lpCaption:LPCSTR; uType:UINT; wLanguageId:WORD):longint; external 'user32' name 'MessageBoxExA';
-function MessageBoxIndirectA(_para1:LPMSGBOXPARAMS):longint; external 'user32' name 'MessageBoxIndirectA';
+function MessageBoxIndirectA(_para1:LPMSGBOXPARAMSA):longint; external 'user32' name 'MessageBoxIndirectA';
 function GetWindowLongA(hWnd:HWND; nIndex:longint):LONG; external 'user32' name 'GetWindowLongA';
 function SetWindowLongA(hWnd:HWND; nIndex:longint; dwNewLong:LONG):LONG; external 'user32' name 'SetWindowLongA';
 function GetClassLongA(hWnd:HWND; nIndex:longint):DWORD; external 'user32' name 'GetClassLongA';
@@ -305,10 +305,10 @@ function CreateFontIndirectA(var _para1:LOGFONT):HFONT; external 'gdi32' name 'C
 function CreateICA(_para1:LPCSTR; _para2:LPCSTR; _para3:LPCSTR; _para4:LPDEVMODE):HDC; external 'gdi32' name 'CreateICA';
 function CreateMetaFileA(_para1:LPCSTR):HDC; external 'gdi32' name 'CreateMetaFileA';
 function CreateScalableFontResourceA(_para1:DWORD; _para2:LPCSTR; _para3:LPCSTR; _para4:LPCSTR):WINBOOL; external 'gdi32' name 'CreateScalableFontResourceA';
-function EnumFontFamiliesExA(_para1:HDC; _para2:LPLOGFONT; _para3:FONTENUMEXPROC; _para4:LPARAM; _para5:DWORD):longint; external 'gdi32' name 'EnumFontFamiliesExA';
-function EnumFontFamiliesA(_para1:HDC; _para2:LPCSTR; _para3:FONTENUMPROC; _para4:LPARAM):longint; external 'gdi32' name 'EnumFontFamiliesA';
-function EnumFontsA(_para1:HDC; _para2:LPCSTR; _para3:ENUMFONTSPROC; _para4:LPARAM):longint; external 'gdi32' name 'EnumFontsA';
-function EnumFontsA(_para1:HDC; _para2:LPCSTR; _para3:ENUMFONTSPROC; _para4:pointer):longint; external 'gdi32' name 'EnumFontsA';
+function EnumFontFamiliesExA(_para1:HDC; _para2:LPLOGFONTA; _para3:FONTENUMEXPROCA; _para4:LPARAM; _para5:DWORD):longint; external 'gdi32' name 'EnumFontFamiliesExA';
+function EnumFontFamiliesA(_para1:HDC; _para2:LPCSTR; _para3:FONTENUMPROCA; _para4:LPARAM):longint; external 'gdi32' name 'EnumFontFamiliesA';
+function EnumFontsA(_para1:HDC; _para2:LPCSTR; _para3:ENUMFONTSPROCA; _para4:LPARAM):longint; external 'gdi32' name 'EnumFontsA';
+function EnumFontsA(_para1:HDC; _para2:LPCSTR; _para3:ENUMFONTSPROCA; _para4:pointer):longint; external 'gdi32' name 'EnumFontsA';
 function GetCharWidthA(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPINT):WINBOOL; external 'gdi32' name 'GetCharWidthA';
 function GetCharWidth32A(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPINT):WINBOOL; external 'gdi32' name 'GetCharWidth32A';
 function GetCharWidthFloatA(_para1:HDC; _para2:UINT; _para3:UINT; _para4:PSingle):WINBOOL; external 'gdi32' name 'GetCharWidthFloatA';
@@ -316,27 +316,27 @@ function GetCharABCWidthsA(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPABC):W
 function GetCharABCWidthsFloatA(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPABCFLOAT):WINBOOL; external 'gdi32' name 'GetCharABCWidthsFloatA';
 function GetGlyphOutlineA(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPGLYPHMETRICS; _para5:DWORD;_para6:LPVOID; _para7:PMAT2):DWORD; external 'gdi32' name 'GetGlyphOutlineA';
 function GetMetaFileA(_para1:LPCSTR):HMETAFILE; external 'gdi32' name 'GetMetaFileA';
-function GetOutlineTextMetricsA(_para1:HDC; _para2:UINT; _para3:LPOUTLINETEXTMETRIC):UINT; external 'gdi32' name 'GetOutlineTextMetricsA';
+function GetOutlineTextMetricsA(_para1:HDC; _para2:UINT; _para3:LPOUTLINETEXTMETRICA):UINT; external 'gdi32' name 'GetOutlineTextMetricsA';
 function GetTextExtentPointA(_para1:HDC; _para2:LPCSTR; _para3:longint; _para4:LPSIZE):WINBOOL; external 'gdi32' name 'GetTextExtentPointA';
 function GetTextExtentPoint32A(_para1:HDC; _para2:LPCSTR; _para3:longint; _para4:LPSIZE):WINBOOL; external 'gdi32' name 'GetTextExtentPoint32A';
 function GetTextExtentExPointA(_para1:HDC; _para2:LPCSTR; _para3:longint; _para4:longint; _para5:LPINT;_para6:LPINT; _para7:LPSIZE):WINBOOL; external 'gdi32' name 'GetTextExtentExPointA';
-function GetCharacterPlacementA(_para1:HDC; _para2:LPCSTR; _para3:longint; _para4:longint; _para5:LPGCP_RESULTS;_para6:DWORD):DWORD; external 'gdi32' name 'GetCharacterPlacementA';
+function GetCharacterPlacementA(_para1:HDC; _para2:LPCSTR; _para3:longint; _para4:longint; _para5:LPGCP_RESULTSA;_para6:DWORD):DWORD; external 'gdi32' name 'GetCharacterPlacementA';
 function ResetDCA(_para1:HDC; _para2:LPDEVMODE):HDC; external 'gdi32' name 'ResetDCA';
 function RemoveFontResourceA(_para1:LPCSTR):WINBOOL; external 'gdi32' name 'RemoveFontResourceA';
 function CopyEnhMetaFileA(_para1:HENHMETAFILE; _para2:LPCSTR):HENHMETAFILE; external 'gdi32' name 'CopyEnhMetaFileA';
 function CreateEnhMetaFileA(_para1:HDC; _para2:LPCSTR; _para3:LPRECT; _para4:LPCSTR):HDC; external 'gdi32' name 'CreateEnhMetaFileA';
 function GetEnhMetaFileA(_para1:LPCSTR):HENHMETAFILE; external 'gdi32' name 'GetEnhMetaFileA';
 function GetEnhMetaFileDescriptionA(_para1:HENHMETAFILE; _para2:UINT; _para3:LPSTR):UINT; external 'gdi32' name 'GetEnhMetaFileDescriptionA';
-function GetTextMetricsA(_para1:HDC; _para2:LPTEXTMETRIC):WINBOOL; external 'gdi32' name 'GetTextMetricsA';
-function StartDocA(_para1:HDC; _para2:PDOCINFO):longint; external 'gdi32' name 'StartDocA';
+function GetTextMetricsA(_para1:HDC; _para2:LPTEXTMETRICA):WINBOOL; external 'gdi32' name 'GetTextMetricsA';
+function StartDocA(_para1:HDC; _para2:PDOCINFOA):longint; external 'gdi32' name 'StartDocA';
 function GetObjectA(_para1:HGDIOBJ; _para2:longint; _para3:LPVOID):longint; external 'gdi32' name 'GetObjectA';
 function TextOutA(_para1:HDC; _para2:longint; _para3:longint; _para4:LPCSTR; _para5:longint):WINBOOL; external 'gdi32' name 'TextOutA';
 function ExtTextOutA(_para1:HDC; _para2:longint; _para3:longint; _para4:UINT; _para5:LPRECT;_para6:LPCSTR; _para7:UINT; _para8:LPINT):WINBOOL; external 'gdi32' name 'ExtTextOutA';
-function PolyTextOutA(_para1:HDC; _para2:PPOLYTEXT; _para3:longint):WINBOOL; external 'gdi32' name 'PolyTextOutA';
+function PolyTextOutA(_para1:HDC; _para2:PPOLYTEXTA; _para3:longint):WINBOOL; external 'gdi32' name 'PolyTextOutA';
 function GetTextFaceA(_para1:HDC; _para2:longint; _para3:LPSTR):longint; external 'gdi32' name 'GetTextFaceA';
 function GetKerningPairsA(_para1:HDC; _para2:DWORD; _para3:LPKERNINGPAIR):DWORD; external 'gdi32' name 'GetKerningPairsA';
-function CreateColorSpaceA(_para1:LPLOGCOLORSPACE):HCOLORSPACE; external 'gdi32' name 'CreateColorSpaceA';
-function GetLogColorSpaceA(_para1:HCOLORSPACE; _para2:LPLOGCOLORSPACE; _para3:DWORD):WINBOOL; external 'gdi32' name 'GetLogColorSpaceA';
+function CreateColorSpaceA(_para1:LPLOGCOLORSPACEA):HCOLORSPACE; external 'gdi32' name 'CreateColorSpaceA';
+function GetLogColorSpaceA(_para1:HCOLORSPACE; _para2:LPLOGCOLORSPACEA; _para3:DWORD):WINBOOL; external 'gdi32' name 'GetLogColorSpaceA';
 function GetICMProfileA(_para1:HDC; _para2:DWORD; _para3:LPSTR):WINBOOL; external 'gdi32' name 'GetICMProfileA';
 function SetICMProfileA(_para1:HDC; _para2:LPSTR):WINBOOL; external 'gdi32' name 'SetICMProfileA';
 function UpdateICMRegKeyA(_para1:DWORD; _para2:DWORD; _para3:LPSTR; _para4:UINT):WINBOOL; external 'gdi32' name 'UpdateICMRegKeyA';
@@ -390,7 +390,7 @@ function RegOpenKeyExA(hKey:HKEY; lpSubKey:LPCSTR; ulOptions:DWORD; samDesired:R
 function RegQueryInfoKeyA(hKey:HKEY; lpClass:LPSTR; lpcbClass:LPDWORD; lpReserved:LPDWORD; lpcSubKeys:LPDWORD;lpcbMaxSubKeyLen:LPDWORD; lpcbMaxClassLen:LPDWORD; lpcValues:LPDWORD; lpcbMaxValueNameLen:LPDWORD;
   lpcbMaxValueLen:LPDWORD;lpcbSecurityDescriptor:LPDWORD; lpftLastWriteTime:PFILETIME):LONG; external 'advapi32' name 'RegQueryInfoKeyA';
 function RegQueryValueA(hKey:HKEY; lpSubKey:LPCSTR; lpValue:LPSTR; lpcbValue:PLONG):LONG; external 'advapi32' name 'RegQueryValueA';
-function RegQueryMultipleValuesA(hKey:HKEY; val_list:PVALENT; num_vals:DWORD; lpValueBuf:LPSTR; ldwTotsize:LPDWORD):LONG; external 'advapi32' name 'RegQueryMultipleValuesA';
+function RegQueryMultipleValuesA(hKey:HKEY; val_list:PVALENTA; num_vals:DWORD; lpValueBuf:LPSTR; ldwTotsize:LPDWORD):LONG; external 'advapi32' name 'RegQueryMultipleValuesA';
 function RegQueryValueExA(hKey:HKEY; lpValueName:LPCSTR; lpReserved:LPDWORD; lpType:LPDWORD; lpData:LPBYTE;lpcbData:LPDWORD):LONG; external 'advapi32' name 'RegQueryValueExA';
 function RegReplaceKeyA(hKey:HKEY; lpSubKey:LPCSTR; lpNewFile:LPCSTR; lpOldFile:LPCSTR):LONG; external 'advapi32' name 'RegReplaceKeyA';
 function RegRestoreKeyA(hKey:HKEY; lpFile:LPCSTR; dwFlags:DWORD):LONG; external 'advapi32' name 'RegRestoreKeyA';
@@ -406,8 +406,8 @@ function GetLocaleInfoA(Locale:LCID; LCType:LCTYPE; lpLCData:LPSTR; cchData:long
 function SetLocaleInfoA(Locale:LCID; LCType:LCTYPE; lpLCData:LPCSTR):WINBOOL; external 'kernel32' name 'SetLocaleInfoA';
 function GetTimeFormatA(Locale:LCID; dwFlags:DWORD; lpTime:LPSYSTEMTIME; lpFormat:LPCSTR; lpTimeStr:LPSTR;cchTime:longint):longint; external 'kernel32' name 'GetTimeFormatA';
 function GetDateFormatA(Locale:LCID; dwFlags:DWORD; lpDate:LPSYSTEMTIME; lpFormat:LPCSTR; lpDateStr:LPSTR;cchDate:longint):longint; external 'kernel32' name 'GetDateFormatA';
-function GetNumberFormatA(Locale:LCID; dwFlags:DWORD; lpValue:LPCSTR; lpFormat:PNUMBERFMT; lpNumberStr:LPSTR;cchNumber:longint):longint; external 'kernel32' name 'GetNumberFormatA';
-function GetCurrencyFormatA(Locale:LCID; dwFlags:DWORD; lpValue:LPCSTR; lpFormat:PCURRENCYFMT; lpCurrencyStr:LPSTR;cchCurrency:longint):longint; external 'kernel32' name 'GetCurrencyFormatA';
+function GetNumberFormatA(Locale:LCID; dwFlags:DWORD; lpValue:LPCSTR; lpFormat:PNUMBERFMTA; lpNumberStr:LPSTR;cchNumber:longint):longint; external 'kernel32' name 'GetNumberFormatA';
+function GetCurrencyFormatA(Locale:LCID; dwFlags:DWORD; lpValue:LPCSTR; lpFormat:PCURRENCYFMTA; lpCurrencyStr:LPSTR;cchCurrency:longint):longint; external 'kernel32' name 'GetCurrencyFormatA';
 function EnumCalendarInfoA(lpCalInfoEnumProc:CALINFO_ENUMPROCA; Locale:LCID; Calendar:CALID; CalType:CALTYPE):WINBOOL; external 'kernel32' name 'EnumCalendarInfoA';
 function EnumTimeFormatsA(lpTimeFmtEnumProc:TIMEFMT_ENUMPROCA; Locale:LCID; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumTimeFormatsA';
 function EnumDateFormatsA(lpDateFmtEnumProc:DATEFMT_ENUMPROCA; Locale:LCID; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumDateFormatsA';
@@ -430,38 +430,38 @@ function SetConsoleTitleA(lpConsoleTitle:LPCSTR):WINBOOL; external 'kernel32' na
 function ReadConsoleA(hConsoleInput:HANDLE; lpBuffer:LPVOID; nNumberOfCharsToRead:DWORD; lpNumberOfCharsRead:LPDWORD; lpReserved:LPVOID):WINBOOL; external 'kernel32' name 'ReadConsoleA';
 function WriteConsoleA(hConsoleOutput:HANDLE;lpBuffer:pointer; nNumberOfCharsToWrite:DWORD; lpNumberOfCharsWritten:LPDWORD; lpReserved:LPVOID):WINBOOL; external 'kernel32' name 'WriteConsoleA';
 function WNetAddConnectionA(lpRemoteName:LPCSTR; lpPassword:LPCSTR; lpLocalName:LPCSTR):DWORD; external 'mpr' name 'WNetAddConnectionA';
-function WNetAddConnection2A(lpNetResource:LPNETRESOURCE; lpPassword:LPCSTR; lpUserName:LPCSTR; dwFlags:DWORD):DWORD; external 'mpr' name 'WNetAddConnection2A';
-function WNetAddConnection3A(hwndOwner:HWND; lpNetResource:LPNETRESOURCE; lpPassword:LPCSTR; lpUserName:LPCSTR; dwFlags:DWORD):DWORD; external 'mpr' name 'WNetAddConnection3A';
+function WNetAddConnection2A(lpNetResource:LPNETRESOURCEA; lpPassword:LPCSTR; lpUserName:LPCSTR; dwFlags:DWORD):DWORD; external 'mpr' name 'WNetAddConnection2A';
+function WNetAddConnection3A(hwndOwner:HWND; lpNetResource:LPNETRESOURCEA; lpPassword:LPCSTR; lpUserName:LPCSTR; dwFlags:DWORD):DWORD; external 'mpr' name 'WNetAddConnection3A';
 function WNetCancelConnectionA(lpName:LPCSTR; fForce:WINBOOL):DWORD; external 'mpr' name 'WNetCancelConnectionA';
 function WNetCancelConnection2A(lpName:LPCSTR; dwFlags:DWORD; fForce:WINBOOL):DWORD; external 'mpr' name 'WNetCancelConnection2A';
 function WNetGetConnectionA(lpLocalName:LPCSTR; lpRemoteName:LPSTR; lpnLength:LPDWORD):DWORD; external 'mpr' name 'WNetGetConnectionA';
-function WNetUseConnectionA(hwndOwner:HWND; lpNetResource:LPNETRESOURCE; lpUserID:LPCSTR; lpPassword:LPCSTR; dwFlags:DWORD;lpAccessName:LPSTR; lpBufferSize:LPDWORD; lpResult:LPDWORD):DWORD; external 'mpr' name 'WNetUseConnectionA';
+function WNetUseConnectionA(hwndOwner:HWND; lpNetResource:LPNETRESOURCEA; lpUserID:LPCSTR; lpPassword:LPCSTR; dwFlags:DWORD;lpAccessName:LPSTR; lpBufferSize:LPDWORD; lpResult:LPDWORD):DWORD; external 'mpr' name 'WNetUseConnectionA';
 function WNetSetConnectionA(lpName:LPCSTR; dwProperties:DWORD; pvValues:LPVOID):DWORD; external 'mpr' name 'WNetSetConnectionA';
-function WNetConnectionDialog1A(lpConnDlgStruct:LPCONNECTDLGSTRUCT):DWORD; external 'mpr' name 'WNetConnectionDialog1A';
-function WNetDisconnectDialog1A(lpConnDlgStruct:LPDISCDLGSTRUCT):DWORD; external 'mpr' name 'WNetDisconnectDialog1A';
-function WNetOpenEnumA(dwScope:DWORD; dwType:DWORD; dwUsage:DWORD; lpNetResource:LPNETRESOURCE; lphEnum:LPHANDLE):DWORD; external 'mpr' name 'WNetOpenEnumA';
+function WNetConnectionDialog1A(lpConnDlgStruct:LPCONNECTDLGSTRUCTA):DWORD; external 'mpr' name 'WNetConnectionDialog1A';
+function WNetDisconnectDialog1A(lpConnDlgStruct:LPDISCDLGSTRUCTA):DWORD; external 'mpr' name 'WNetDisconnectDialog1A';
+function WNetOpenEnumA(dwScope:DWORD; dwType:DWORD; dwUsage:DWORD; lpNetResource:LPNETRESOURCEA; lphEnum:LPHANDLE):DWORD; external 'mpr' name 'WNetOpenEnumA';
 function WNetEnumResourceA(hEnum:HANDLE; lpcCount:LPDWORD; lpBuffer:LPVOID; lpBufferSize:LPDWORD):DWORD; external 'mpr' name 'WNetEnumResourceA';
 function WNetGetUniversalNameA(lpLocalPath:LPCSTR; dwInfoLevel:DWORD; lpBuffer:LPVOID; lpBufferSize:LPDWORD):DWORD; external 'mpr' name 'WNetGetUniversalNameA';
 function WNetGetUserA(lpName:LPCSTR; lpUserName:LPSTR; lpnLength:LPDWORD):DWORD; external 'mpr' name 'WNetGetUserA';
 function WNetGetProviderNameA(dwNetType:DWORD; lpProviderName:LPSTR; lpBufferSize:LPDWORD):DWORD; external 'mpr' name 'WNetGetProviderNameA';
 function WNetGetNetworkInformationA(lpProvider:LPCSTR; lpNetInfoStruct:LPNETINFOSTRUCT):DWORD; external 'mpr' name 'WNetGetNetworkInformationA';
 function WNetGetLastErrorA(lpError:LPDWORD; lpErrorBuf:LPSTR; nErrorBufSize:DWORD; lpNameBuf:LPSTR; nNameBufSize:DWORD):DWORD; external 'mpr' name 'WNetGetLastErrorA';
-function MultinetGetConnectionPerformanceA(lpNetResource:LPNETRESOURCE; lpNetConnectInfoStruct:LPNETCONNECTINFOSTRUCT):DWORD; external 'mpr' name 'MultinetGetConnectionPerformanceA';
+function MultinetGetConnectionPerformanceA(lpNetResource:LPNETRESOURCEA; lpNetConnectInfoStruct:LPNETCONNECTINFOSTRUCT):DWORD; external 'mpr' name 'MultinetGetConnectionPerformanceA';
 function ChangeServiceConfigA(hService:SC_HANDLE; dwServiceType:DWORD; dwStartType:DWORD; dwErrorControl:DWORD; lpBinaryPathName:LPCSTR;lpLoadOrderGroup:LPCSTR; lpdwTagId:LPDWORD; lpDependencies:LPCSTR; lpServiceStartName:LPCSTR;
   lpPassword:LPCSTR;lpDisplayName:LPCSTR):WINBOOL; external 'advapi32' name 'ChangeServiceConfigA';
 function CreateServiceA(hSCManager:SC_HANDLE; lpServiceName:LPCSTR; lpDisplayName:LPCSTR; dwDesiredAccess:DWORD; dwServiceType:DWORD;dwStartType:DWORD; dwErrorControl:DWORD; lpBinaryPathName:LPCSTR; lpLoadOrderGroup:LPCSTR;
   lpdwTagId:LPDWORD;lpDependencies:LPCSTR; lpServiceStartName:LPCSTR; lpPassword:LPCSTR):SC_HANDLE; external 'advapi32' name 'CreateServiceA';
-function EnumDependentServicesA(hService:SC_HANDLE; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUS; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD;lpServicesReturned:LPDWORD):WINBOOL; external 'advapi32' name 'EnumDependentServicesA';
-function EnumServicesStatusA(hSCManager:SC_HANDLE; dwServiceType:DWORD; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUS; cbBufSize:DWORD;pcbBytesNeeded:LPDWORD; lpServicesReturned:LPDWORD; lpResumeHandle:LPDWORD):WINBOOL;
+function EnumDependentServicesA(hService:SC_HANDLE; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUSA; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD;lpServicesReturned:LPDWORD):WINBOOL; external 'advapi32' name 'EnumDependentServicesA';
+function EnumServicesStatusA(hSCManager:SC_HANDLE; dwServiceType:DWORD; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUSA; cbBufSize:DWORD;pcbBytesNeeded:LPDWORD; lpServicesReturned:LPDWORD; lpResumeHandle:LPDWORD):WINBOOL;
   external 'advapi32' name 'EnumServicesStatusA';
 function GetServiceKeyNameA(hSCManager:SC_HANDLE; lpDisplayName:LPCSTR; lpServiceName:LPSTR; lpcchBuffer:LPDWORD):WINBOOL; external 'advapi32' name 'GetServiceKeyNameA';
 function GetServiceDisplayNameA(hSCManager:SC_HANDLE; lpServiceName:LPCSTR; lpDisplayName:LPSTR; lpcchBuffer:LPDWORD):WINBOOL; external 'advapi32' name 'GetServiceDisplayNameA';
 function OpenSCManagerA(lpMachineName:LPCSTR; lpDatabaseName:LPCSTR; dwDesiredAccess:DWORD):SC_HANDLE; external 'advapi32' name 'OpenSCManagerA';
 function OpenServiceA(hSCManager:SC_HANDLE; lpServiceName:LPCSTR; dwDesiredAccess:DWORD):SC_HANDLE; external 'advapi32' name 'OpenServiceA';
-function QueryServiceConfigA(hService:SC_HANDLE; lpServiceConfig:LPQUERY_SERVICE_CONFIG; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceConfigA';
-function QueryServiceLockStatusA(hSCManager:SC_HANDLE; lpLockStatus:LPQUERY_SERVICE_LOCK_STATUS; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceLockStatusA';
+function QueryServiceConfigA(hService:SC_HANDLE; lpServiceConfig:LPQUERY_SERVICE_CONFIGA; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceConfigA';
+function QueryServiceLockStatusA(hSCManager:SC_HANDLE; lpLockStatus:LPQUERY_SERVICE_LOCK_STATUSA; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceLockStatusA';
 function RegisterServiceCtrlHandlerA(lpServiceName:LPCSTR; lpHandlerProc:LPHANDLER_FUNCTION):SERVICE_STATUS_HANDLE; external 'advapi32' name 'RegisterServiceCtrlHandlerA';
-function StartServiceCtrlDispatcherA(lpServiceStartTable:LPSERVICE_TABLE_ENTRY):WINBOOL; external 'advapi32' name 'StartServiceCtrlDispatcherA';
+function StartServiceCtrlDispatcherA(lpServiceStartTable:LPSERVICE_TABLE_ENTRYA):WINBOOL; external 'advapi32' name 'StartServiceCtrlDispatcherA';
 function StartServiceA(hService:SC_HANDLE; dwNumServiceArgs:DWORD; lpServiceArgVectors:LPPCSTR):WINBOOL; external 'advapi32' name 'StartServiceA';
 function DragQueryFileA(_para1:HDROP; _para2:cardinal; _para3:Pchar;_para4:cardinal):cardinal; external 'shell32' name 'DragQueryFileA';
 function ExtractAssociatedIconA(_para1:HINST; _para2:Pchar; _para3:LPWORD):HICON; external 'shell32' name 'ExtractAssociatedIconA';

rtl/win/wininc/base.inc

@@ -284,7 +284,7 @@
   Enumerations
 }
 
-     ACL_INFORMATION_CLASS = (AclRevisionInformation := 1,AclSizeInformation
+     ACL_INFORMATION_CLASS = (AclRevisionInformation = 1,AclSizeInformation
        );
 
      _ACL_INFORMATION_CLASS = ACL_INFORMATION_CLASS;
@@ -302,7 +302,7 @@
 
   type
 
-     RASCONNSTATE = (RASCS_OpenPort := 0,RASCS_PortOpened,
+     RASCONNSTATE = (RASCS_OpenPort = 0,RASCS_PortOpened,
        RASCS_ConnectDevice,RASCS_DeviceConnected,
        RASCS_AllDevicesConnected,RASCS_Authenticate,
        RASCS_AuthNotify,RASCS_AuthRetry,RASCS_AuthCallback,
@@ -312,15 +312,15 @@
        RASCS_WaitForModemReset,RASCS_WaitForCallback,
        RASCS_Projected,RASCS_StartAuthentication,
        RASCS_CallbackComplete,RASCS_LogonNetwork,
-       RASCS_Interactive := RASCS_PAUSED,RASCS_RetryAuthentication,
+       RASCS_Interactive = RASCS_PAUSED,RASCS_RetryAuthentication,
        RASCS_CallbackSetByCaller,RASCS_PasswordExpired,
-       RASCS_Connected := RASCS_DONE,RASCS_Disconnected
+       RASCS_Connected = RASCS_DONE,RASCS_Disconnected
        );
 
      _RASCONNSTATE = RASCONNSTATE;
 
-     RASPROJECTION = (RASP_PppIp := $8021, RASP_PppIpx := $802B, RASP_PppNbf := $803F,
-       RASP_Amb := $10000);
+     RASPROJECTION = (RASP_PppIp = $8021, RASP_PppIpx = $802B, RASP_PppNbf = $803F,
+       RASP_Amb = $10000);
 
      _RASPROJECTION = RASPROJECTION;
 
@@ -330,7 +330,7 @@
 
      _SECURITY_IMPERSONATION_LEVEL = SECURITY_IMPERSONATION_LEVEL;
 
-     SID_NAME_USE = (SidTypeUser := 1,SidTypeGroup,SidTypeDomain,
+     SID_NAME_USE = (SidTypeUser = 1,SidTypeGroup,SidTypeDomain,
        SidTypeAlias,SidTypeWellKnownGroup,SidTypeDeletedAccount,
        SidTypeInvalid,SidTypeUnknown);
 
@@ -404,7 +404,7 @@
     FINDEX_SEARCH_OPS   = _FINDEX_SEARCH_OPS;
     PFINDEX_SEARCH_OPS  = ^TFINDEX_SEARCH_OPS;
 
-    PARTITION_STYLE     = (PARTITION_STYLE_MBR:=0,PARTITION_STYLE_GPT,PARTITION_STYLE_RAW);
+    PARTITION_STYLE     = (PARTITION_STYLE_MBR=0,PARTITION_STYLE_GPT,PARTITION_STYLE_RAW);
     TPARTITION_STYLE    = PARTITION_STYLE;
     PPARTITION_STYLE    = ^TPARTITION_STYLE;
 
@@ -624,7 +624,7 @@
 
      LPTHREAD_START_ROUTINE = PTHREAD_START_ROUTINE;
 
-     EDITSTREAMCALLBACK = function (_para1:DWORD_PTR; _para2:LPBYTE; _para3:LONG; _para4:LONG):DWORD;stdcall;
+     EDITSTREAMCALLBACK = function (_para1:DWORD_PTR; _para2:LPBYTE; _para3:LONG; _para4:PLONG):DWORD;stdcall;
 
      LPFRHOOKPROC = function (_para1:HWND; _para2:UINT; _para3:WPARAM; _para4:LPARAM):UINT_PTR;stdcall;
 
@@ -638,7 +638,9 @@
 
      PFNPROPSHEETCALLBACK = function (_para1:HWND; _para2:UINT; _para3:LPARAM):longint;stdcall;
 
-     LPSERVICE_MAIN_FUNCTION = procedure (_para1:DWORD; _para2:LPPTSTR);stdcall;
+     LPSERVICE_MAIN_FUNCTION  = procedure (_para1:DWORD; _para2:LPPTSTR);stdcall;
+     LPSERVICE_MAIN_FUNCTIONA = procedure (_para1:DWORD; _para2:LPPSTR);stdcall;
+     LPSERVICE_MAIN_FUNCTIONW = procedure (_para1:DWORD; _para2:LPPWSTR);stdcall;
 
      PFNTVCOMPARE = function (_para1:LPARAM; _para2:LPARAM; _para3:LPARAM):longint;stdcall;
 
@@ -653,16 +655,23 @@
      PROC = FARPROC;
 
      ENUMRESTYPEPROC = function (hModule:HMODULE; lpszType:LPTSTR; lParam:LONG_PTR):WINBOOL;stdcall;
+     ENUMRESTYPEPROCA = function (hModule:HMODULE; lpszType:LPSTR; lParam:LONG_PTR):WINBOOL;stdcall;
+     ENUMRESTYPEPROCW = function (hModule:HMODULE; lpszType:LPWSTR; lParam:LONG_PTR):WINBOOL;stdcall;
 
      ENUMRESNAMEPROC = function (hModule:HMODULE; lpszType:LPCTSTR; lpszName:LPTSTR; lParam:LONG_PTR):WINBOOL;stdcall;
+     ENUMRESNAMEPROCA= function (hModule:HMODULE; lpszType:LPCSTR;  lpszName:LPSTR;  lParam:LONG_PTR):WINBOOL;stdcall;
+     ENUMRESNAMEPROCW= function (hModule:HMODULE; lpszType:LPCWSTR; lpszName:LPWSTR; lParam:LONG_PTR):WINBOOL;stdcall;
 
      ENUMRESLANGPROC = function (hModule:HMODULE; lpszType:LPCTSTR; lpszName:LPCTSTR; wIDLanguage:WORD; lParam:LONG_PTR):WINBOOL;stdcall;
-
+     ENUMRESLANGPROCA= function (hModule:HMODULE; lpszType:LPCSTR;  lpszName:LPCSTR;  wIDLanguage:WORD; lParam:LONG_PTR):WINBOOL;stdcall;
+     ENUMRESLANGPROCW= function (hModule:HMODULE; lpszType:LPCWSTR; lpszName:LPCWSTR; wIDLanguage:WORD; lParam:LONG_PTR):WINBOOL;stdcall;
      DESKTOPENUMPROC = FARPROC;
 
      ENUMWINDOWSPROC = function (_para1:HWND; _para2:LPARAM):WINBOOL;stdcall;
 
      ENUMWINDOWSTATIONPROC = function (_para1:LPTSTR; _para2:LPARAM):WINBOOL;stdcall;
+     ENUMWINDOWSTATIONPROCA = function (_para1:LPSTR; _para2:LPARAM):WINBOOL;stdcall;
+     ENUMWINDOWSTATIONPROCW = function (_para1:LPWSTR; _para2:LPARAM):WINBOOL;stdcall;
 
      SENDASYNCPROC = procedure (_para1:HWND; _para2:UINT; _para3:ULONG_PTR; _para4:LRESULT);stdcall;
 
@@ -672,9 +681,9 @@
 
      DRAWSTATEPROC = function (_para1:HDC; _para2:LPARAM; _para3:WPARAM; _para4:longint; _para5:longint):WINBOOL;stdcall;
 
-     PROPENUMPROCEXA = function (_para1:HWND; _para2:LPCSTR;  _para3:HANDLE; _para4:DWORD_PTR):WINBOOL;stdcall;
-     PROPENUMPROCEXW = function (_para1:HWND; _para2:LPCWSTR; _para3:HANDLE; _para4:DWORD_PTR):WINBOOL;stdcall;
-     PROPENUMPROCEX  = function (_para1:HWND; _para2:LPCTSTR; _para3:HANDLE; _para4:DWORD_PTR):WINBOOL;stdcall;
+     PROPENUMPROCEXA = function (_para1:HWND; _para2:LPCSTR;  _para3:HANDLE; _para4:ULONG_PTR):WINBOOL;stdcall;
+     PROPENUMPROCEXW = function (_para1:HWND; _para2:LPCWSTR; _para3:HANDLE; _para4:ULONG_PTR):WINBOOL;stdcall;
+     PROPENUMPROCEX  = function (_para1:HWND; _para2:LPCTSTR; _para3:HANDLE; _para4:ULONG_PTR):WINBOOL;stdcall;
 
      PROPENUMPROCA = function (_para1:HWND; _para2:LPCSTR;  _para3:HANDLE):WINBOOL;stdcall;
      PROPENUMPROCW = function (_para1:HWND; _para2:LPCWSTR; _para3:HANDLE):WINBOOL;stdcall;

rtl/win/wininc/defines.inc

@@ -6045,6 +6045,58 @@ const
       MBIFB_BAR_FOCUSED = $00000001;
       MBIFB_FOCUSED     = $00000002;
 
+
+const 
+//
+// Define possible return codes from the CopyFileEx callback routine
+//
+
+    PROGRESS_CONTINUE   = 0;
+    PROGRESS_CANCEL     = 1;
+    PROGRESS_STOP       = 2;
+    PROGRESS_QUIET      = 3;
+
+//
+// Define CopyFileEx callback routine state change values
+//
+
+    CALLBACK_CHUNK_FINISHED         = $00000000;
+    CALLBACK_STREAM_SWITCH          = $00000001;
+
+//
+// Define CopyFileEx option flags
+//
+
+    COPY_FILE_FAIL_IF_EXISTS              = $00000001;
+    COPY_FILE_RESTARTABLE                 = $00000002;
+    COPY_FILE_OPEN_SOURCE_FOR_WRITE       = $00000004;
+    COPY_FILE_ALLOW_DECRYPTED_DESTINATION = $00000008;
+
+//
+//  Gap for private copyfile flags
+//
+
+    COPY_FILE_COPY_SYMLINK                = $00000800;
+    COPY_FILE_NO_BUFFERING                = $00001000;
+
+//
+//  CopyFile2 flags
+//
+
+    COPY_FILE_REQUEST_SECURITY_PRIVILEGES        = $00002000;
+    COPY_FILE_RESUME_FROM_PAUSE                  = $00004000;
+
+
+    COPY_FILE_NO_OFFLOAD                         = $00040000;
+
+//
+// Define ReplaceFile option flags
+//
+
+    REPLACEFILE_WRITE_THROUGH       = $00000001;
+    REPLACEFILE_IGNORE_MERGE_ERRORS = $00000002;
+    REPLACEFILE_IGNORE_ACL_ERRORS   = $00000004;
+
 {$endif read_interface}
 
 {$ifdef read_implementation}

rtl/win/wininc/unidef.inc

@@ -193,7 +193,7 @@ function RegisterClass(lpWndClass:LPWNDCLASS):ATOM; external 'user32' name 'Regi
 function UnregisterClass(lpClassName:LPCWSTR; hInstance:HINST):WINBOOL; external 'user32' name 'UnregisterClassW';
 function GetClassInfo(hInstance:HINST; lpClassName:LPCWSTR; lpWndClass:LPWNDCLASS):WINBOOL; external 'user32' name 'GetClassInfoW';
 function RegisterClassEx(_para1:LPWNDCLASSEXW):ATOM; external 'user32' name 'RegisterClassExW';
-function GetClassInfoEx(_para1:HINST; _para2:LPCWSTR; _para3:LPWNDCLASSEX):WINBOOL; external 'user32' name 'GetClassInfoExW';
+function GetClassInfoEx(_para1:HINST; _para2:LPCWSTR; _para3:LPWNDCLASSEXW):WINBOOL; external 'user32' name 'GetClassInfoExW';
 function CreateWindowEx(dwExStyle:DWORD; lpClassName:LPCWSTR; lpWindowName:LPCWSTR; dwStyle:DWORD; X:longint;Y:longint; nWidth:longint; nHeight:longint; hWndParent:HWND; hMenu:HMENU;hInstance:HINST; lpParam:LPVOID):HWND;
   external 'user32' name 'CreateWindowExW';
 function CreateDialogParam(hInstance:HINST; lpTemplateName:LPCWSTR; hWndParent:HWND; lpDialogFunc:DLGPROC; dwInitParam:LPARAM):HWND; external 'user32' name 'CreateDialogParamW';

rtl/win/wininc/unifun.inc

@@ -77,9 +77,9 @@ function ExpandEnvironmentStringsW(lpSrc:LPCWSTR; lpDst:LPWSTR; nSize:DWORD):DWO
 procedure OutputDebugStringW(lpOutputString:LPCWSTR); external 'kernel32' name 'OutputDebugStringW';
 function FindResourceW(hModule:HINST; lpName:LPCWSTR; lpType:LPCWSTR):HRSRC; external 'kernel32' name 'FindResourceW';
 function FindResourceExW(hModule:HINST; lpType:LPCWSTR; lpName:LPCWSTR; wLanguage:WORD):HRSRC; external 'kernel32' name 'FindResourceExW';
-function EnumResourceTypesW(hModule:HMODULE; lpEnumFunc:ENUMRESTYPEPROC; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceTypesW';
-function EnumResourceNamesW(hModule:HMODULE; lpType:LPCWSTR; lpEnumFunc:ENUMRESNAMEPROC; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceNamesW';
-function EnumResourceLanguagesW(hModule:HMODULE; lpType:LPCWSTR; lpName:LPCWSTR; lpEnumFunc:ENUMRESLANGPROC; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceLanguagesW';
+function EnumResourceTypesW(hModule:HMODULE; lpEnumFunc:ENUMRESTYPEPROCW; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceTypesW';
+function EnumResourceNamesW(hModule:HMODULE; lpType:LPCWSTR; lpEnumFunc:ENUMRESNAMEPROCW; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceNamesW';
+function EnumResourceLanguagesW(hModule:HMODULE; lpType:LPCWSTR; lpName:LPCWSTR; lpEnumFunc:ENUMRESLANGPROCW; lParam:LONG_PTR):WINBOOL; external 'kernel32' name 'EnumResourceLanguagesW';
 function BeginUpdateResourceW(pFileName:LPCWSTR; bDeleteExistingResources:WINBOOL):HANDLE; external 'kernel32' name 'BeginUpdateResourceW';
 function UpdateResourceW(hUpdate:HANDLE; lpType:LPCWSTR; lpName:LPCWSTR; wLanguage:WORD; lpData:LPVOID;cbData:DWORD):WINBOOL; external 'kernel32' name 'UpdateResourceW';
 function EndUpdateResourceW(hUpdate:HANDLE; fDiscard:WINBOOL):WINBOOL; external 'kernel32' name 'EndUpdateResourceW';
@@ -173,7 +173,7 @@ function OpenDesktopW(lpszDesktop:LPWSTR; dwFlags:DWORD; fInherit:WINBOOL; dwDes
 function EnumDesktopsW(hwinsta:HWINSTA; lpEnumFunc:DESKTOPENUMPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumDesktopsW';
 function CreateWindowStationW(lpwinsta:LPWSTR; dwReserved:DWORD; dwDesiredAccess:DWORD; lpsa:LPSECURITY_ATTRIBUTES):HWINSTA; external 'user32' name 'CreateWindowStationW';
 function OpenWindowStationW(lpszWinSta:LPWSTR; fInherit:WINBOOL; dwDesiredAccess:DWORD):HWINSTA; external 'user32' name 'OpenWindowStationW';
-function EnumWindowStationsW(lpEnumFunc:ENUMWINDOWSTATIONPROC; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumWindowStationsW';
+function EnumWindowStationsW(lpEnumFunc:ENUMWINDOWSTATIONPROCW; lParam:LPARAM):WINBOOL; external 'user32' name 'EnumWindowStationsW';
 function GetUserObjectInformationW(hObj:HANDLE; nIndex:longint; pvInfo:PVOID; nLength:DWORD; lpnLengthNeeded:LPDWORD):WINBOOL; external 'user32' name 'GetUserObjectInformationW';
 function SetUserObjectInformationW(hObj:HANDLE; nIndex:longint; pvInfo:PVOID; nLength:DWORD):WINBOOL; external 'user32' name 'SetUserObjectInformationW';
 function RegisterWindowMessageW(lpString:LPCWSTR):UINT; external 'user32' name 'RegisterWindowMessageW';
@@ -190,9 +190,9 @@ function DefWindowProcW(hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESU
 function CallWindowProcW(lpPrevWndFunc:WNDPROC; hWnd:HWND; Msg:UINT; wParam:WPARAM; lParam:LPARAM):LRESULT; external 'user32' name 'CallWindowProcW';
 function RegisterClassW(lpWndClass:LPWNDCLASSW):ATOM; external 'user32' name 'RegisterClassW';
 function UnregisterClassW(lpClassName:LPCWSTR; hInstance:HINST):WINBOOL; external 'user32' name 'UnregisterClassW';
-function GetClassInfoW(hInstance:HINST; lpClassName:LPCWSTR; lpWndClass:LPWNDCLASS):WINBOOL; external 'user32' name 'GetClassInfoW';
+function GetClassInfoW(hInstance:HINST; lpClassName:LPCWSTR; lpWndClass:LPWNDCLASSW):WINBOOL; external 'user32' name 'GetClassInfoW';
 function RegisterClassExW(_para1:LPWNDCLASSEXW):ATOM; external 'user32' name 'RegisterClassExW';
-function GetClassInfoExW(_para1:HINST; _para2:LPCWSTR; _para3:LPWNDCLASSEX):WINBOOL; external 'user32' name 'GetClassInfoExW';
+function GetClassInfoExW(_para1:HINST; _para2:LPCWSTR; _para3:LPWNDCLASSEXW):WINBOOL; external 'user32' name 'GetClassInfoExW';
 function CreateWindowExW(dwExStyle:DWORD; lpClassName:LPCWSTR; lpWindowName:LPCWSTR; dwStyle:DWORD; X:longint;Y:longint; nWidth:longint; nHeight:longint; hWndParent:HWND; hMenu:HMENU;hInstance:HINST; lpParam:LPVOID):HWND;
   external 'user32' name 'CreateWindowExW';
 function CreateDialogParamW(hInstance:HINST; lpTemplateName:LPCWSTR; hWndParent:HWND; lpDialogFunc:DLGPROC; dwInitParam:LPARAM):HWND; external 'user32' name 'CreateDialogParamW';
@@ -236,9 +236,9 @@ function GetMenuStringW(hMenu:HMENU; uIDItem:UINT; lpString:LPWSTR; nMaxCount:lo
 function InsertMenuW(hMenu:HMENU; uPosition:UINT; uFlags:UINT; uIDNewItem:UINT; lpNewItem:LPCWSTR):WINBOOL; external 'user32' name 'InsertMenuW';
 function AppendMenuW(hMenu:HMENU; uFlags:UINT; uIDNewItem:UINT; lpNewItem:LPCWSTR):WINBOOL; external 'user32' name 'AppendMenuW';
 function ModifyMenuW(hMnu:HMENU; uPosition:UINT; uFlags:UINT; uIDNewItem:UINT; lpNewItem:LPCWSTR):WINBOOL; external 'user32' name 'ModifyMenuW';
-function InsertMenuItemW(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFO):WINBOOL; external 'user32' name 'InsertMenuItemW';
-function GetMenuItemInfoW(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPMENUITEMINFO):WINBOOL; external 'user32' name 'GetMenuItemInfoW';
-function SetMenuItemInfoW(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFO):WINBOOL; external 'user32' name 'SetMenuItemInfoW';
+function InsertMenuItemW(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFOW):WINBOOL; external 'user32' name 'InsertMenuItemW';
+function GetMenuItemInfoW(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPMENUITEMINFOW):WINBOOL; external 'user32' name 'GetMenuItemInfoW';
+function SetMenuItemInfoW(_para1:HMENU; _para2:UINT; _para3:WINBOOL; _para4:LPCMENUITEMINFOW):WINBOOL; external 'user32' name 'SetMenuItemInfoW';
 function DrawTextW(hDC:HDC; lpString:LPCWSTR; nCount:longint; lpRect:LPRECT; uFormat:UINT):longint; external 'user32' name 'DrawTextW';
 function DrawTextExW(_para1:HDC; _para2:LPWSTR; _para3:longint; _para4:LPRECT; _para5:UINT;_para6:LPDRAWTEXTPARAMS):longint; external 'user32' name 'DrawTextExW';
 function GrayStringW(hDC:HDC; hBrush:HBRUSH; lpOutputFunc:GRAYSTRINGPROC; lpData:LPARAM; nCount:longint;X:longint; Y:longint; nWidth:longint; nHeight:longint):WINBOOL; external 'user32' name 'GrayStringW';
@@ -248,14 +248,14 @@ function GetTabbedTextExtentW(hDC:HDC; lpString:LPCWSTR; nCount:longint; nTabPos
 function SetPropW(hWnd:HWND; lpString:LPCWSTR; hData:HANDLE):WINBOOL; external 'user32' name 'SetPropW';
 function GetPropW(hWnd:HWND; lpString:LPCWSTR):HANDLE; external 'user32' name 'GetPropW';
 function RemovePropW(hWnd:HWND; lpString:LPCWSTR):HANDLE; external 'user32' name 'RemovePropW';
-function EnumPropsExW(hWnd:HWND; lpEnumFunc:PROPENUMPROCEX; lParam:LPARAM):longint; external 'user32' name 'EnumPropsExW';
-function EnumPropsW(hWnd:HWND; lpEnumFunc:PROPENUMPROC):longint; external 'user32' name 'EnumPropsW';
+function EnumPropsExW(hWnd:HWND; lpEnumFunc:PROPENUMPROCEXW; lParam:LPARAM):longint; external 'user32' name 'EnumPropsExW';
+function EnumPropsW(hWnd:HWND; lpEnumFunc:PROPENUMPROCW):longint; external 'user32' name 'EnumPropsW';
 function SetWindowTextW(hWnd:HWND; lpString:LPCWSTR):WINBOOL; external 'user32' name 'SetWindowTextW';
 function GetWindowTextW(hWnd:HWND; lpString:LPWSTR; nMaxCount:longint):longint; external 'user32' name 'GetWindowTextW';
 function GetWindowTextLengthW(hWnd:HWND):longint; external 'user32' name 'GetWindowTextLengthW';
 function MessageBoxW(hWnd:HWND; lpText:LPCWSTR; lpCaption:LPCWSTR; uType:UINT):longint; external 'user32' name 'MessageBoxW';
 function MessageBoxExW(hWnd:HWND; lpText:LPCWSTR; lpCaption:LPCWSTR; uType:UINT; wLanguageId:WORD):longint; external 'user32' name 'MessageBoxExW';
-function MessageBoxIndirectW(_para1:LPMSGBOXPARAMS):longint; external 'user32' name 'MessageBoxIndirectW';
+function MessageBoxIndirectW(_para1:LPMSGBOXPARAMSW):longint; external 'user32' name 'MessageBoxIndirectW';
 function GetWindowLongW(hWnd:HWND; nIndex:longint):LONG; external 'user32' name 'GetWindowLongW';
 function SetWindowLongW(hWnd:HWND; nIndex:longint; dwNewLong:LONG):LONG; external 'user32' name 'SetWindowLongW';
 function GetClassLongW(hWnd:HWND; nIndex:longint):DWORD; external 'user32' name 'GetClassLongW';
@@ -302,10 +302,10 @@ function CreateFontW(_para1:longint; _para2:longint; _para3:longint; _para4:long
 function CreateICW(_para1:LPCWSTR; _para2:LPCWSTR; _para3:LPCWSTR; _para4:LPDEVMODEw):HDC; external 'gdi32' name 'CreateICW';
 function CreateMetaFileW(_para1:LPCWSTR):HDC; external 'gdi32' name 'CreateMetaFileW';
 function CreateScalableFontResourceW(_para1:DWORD; _para2:LPCWSTR; _para3:LPCWSTR; _para4:LPCWSTR):WINBOOL; external 'gdi32' name 'CreateScalableFontResourceW';
-function EnumFontFamiliesExW(_para1:HDC; _para2:LPLOGFONT; _para3:FONTENUMEXPROC; _para4:LPARAM; _para5:DWORD):longint; external 'gdi32' name 'EnumFontFamiliesExW';
-function EnumFontFamiliesW(_para1:HDC; _para2:LPCWSTR; _para3:FONTENUMPROC; _para4:LPARAM):longint; external 'gdi32' name 'EnumFontFamiliesW';
-function EnumFontsW(_para1:HDC; _para2:LPCWSTR; _para3:ENUMFONTSPROC; _para4:LPARAM):longint; external 'gdi32' name 'EnumFontsW';
-function EnumFontsW(_para1:HDC; _para2:LPCWSTR; _para3:ENUMFONTSPROC; _para4:pointer):longint; external 'gdi32' name 'EnumFontsW';
+function EnumFontFamiliesExW(_para1:HDC; _para2:LPLOGFONTW; _para3:FONTENUMEXPROCW; _para4:LPARAM; _para5:DWORD):longint; external 'gdi32' name 'EnumFontFamiliesExW';
+function EnumFontFamiliesW(_para1:HDC; _para2:LPCWSTR; _para3:FONTENUMPROCW; _para4:LPARAM):longint; external 'gdi32' name 'EnumFontFamiliesW';
+function EnumFontsW(_para1:HDC; _para2:LPCWSTR; _para3:ENUMFONTSPROCW; _para4:LPARAM):longint; external 'gdi32' name 'EnumFontsW';
+function EnumFontsW(_para1:HDC; _para2:LPCWSTR; _para3:ENUMFONTSPROCW; _para4:pointer):longint; external 'gdi32' name 'EnumFontsW';
 function GetCharWidthW(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPINT):WINBOOL; external 'gdi32' name 'GetCharWidthW';
 function GetCharWidth32W(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPINT):WINBOOL; external 'gdi32' name 'GetCharWidth32W';
 function GetCharWidthFloatW(_para1:HDC; _para2:UINT; _para3:UINT; _para4:PSingle):WINBOOL; external 'gdi32' name 'GetCharWidthFloatW';
@@ -313,31 +313,31 @@ function GetCharABCWidthsW(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPABC):W
 function GetCharABCWidthsFloatW(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPABCFLOAT):WINBOOL; external 'gdi32' name 'GetCharABCWidthsFloatW';
 function GetGlyphOutlineW(_para1:HDC; _para2:UINT; _para3:UINT; _para4:LPGLYPHMETRICS; _para5:DWORD;_para6:LPVOID; _para7:PMAT2):DWORD; external 'gdi32' name 'GetGlyphOutlineW';
 function GetMetaFileW(_para1:LPCWSTR):HMETAFILE; external 'gdi32' name 'GetMetaFileW';
-function GetOutlineTextMetricsW(_para1:HDC; _para2:UINT; _para3:LPOUTLINETEXTMETRIC):UINT; external 'gdi32' name 'GetOutlineTextMetricsW';
+function GetOutlineTextMetricsW(_para1:HDC; _para2:UINT; _para3:LPOUTLINETEXTMETRICW):UINT; external 'gdi32' name 'GetOutlineTextMetricsW';
 function GetTextExtentPointW(_para1:HDC; _para2:LPCWSTR; _para3:longint; _para4:LPSIZE):WINBOOL; external 'gdi32' name 'GetTextExtentPointW';
 function GetTextExtentPoint32W(_para1:HDC; _para2:LPCWSTR; _para3:longint; _para4:LPSIZE):WINBOOL; external 'gdi32' name 'GetTextExtentPoint32W';
 function GetTextExtentExPointW(_para1:HDC; _para2:LPCWSTR; _para3:longint; _para4:longint; _para5:LPINT;_para6:LPINT; _para7:LPSIZE):WINBOOL; external 'gdi32' name 'GetTextExtentExPointW';
-function GetCharacterPlacementW(_para1:HDC; _para2:LPCWSTR; _para3:longint; _para4:longint; _para5:LPGCP_RESULTS;_para6:DWORD):DWORD; external 'gdi32' name 'GetCharacterPlacementW';
+function GetCharacterPlacementW(_para1:HDC; _para2:LPCWSTR; _para3:longint; _para4:longint; _para5:LPGCP_RESULTSW;_para6:DWORD):DWORD; external 'gdi32' name 'GetCharacterPlacementW';
 function ResetDCW(_para1:HDC; _para2:LPDEVMODEW):HDC; external 'gdi32' name 'ResetDCW';
 function RemoveFontResourceW(_para1:LPCWSTR):WINBOOL; external 'gdi32' name 'RemoveFontResourceW';
 function CopyEnhMetaFileW(_para1:HENHMETAFILE; _para2:LPCWSTR):HENHMETAFILE; external 'gdi32' name 'CopyEnhMetaFileW';
 function CreateEnhMetaFileW(_para1:HDC; _para2:LPCWSTR; _para3:LPRECT; _para4:LPCWSTR):HDC; external 'gdi32' name 'CreateEnhMetaFileW';
 function GetEnhMetaFileW(_para1:LPCWSTR):HENHMETAFILE; external 'gdi32' name 'GetEnhMetaFileW';
 function GetEnhMetaFileDescriptionW(_para1:HENHMETAFILE; _para2:UINT; _para3:LPWSTR):UINT; external 'gdi32' name 'GetEnhMetaFileDescriptionW';
-function GetTextMetricsW(_para1:HDC; _para2:LPTEXTMETRIC):WINBOOL; external 'gdi32' name 'GetTextMetricsW';
-function StartDocW(_para1:HDC; _para2:PDOCINFO):longint; external 'gdi32' name 'StartDocW';
+function GetTextMetricsW(_para1:HDC; _para2:LPTEXTMETRICW):WINBOOL; external 'gdi32' name 'GetTextMetricsW';
+function StartDocW(_para1:HDC; _para2:PDOCINFOW):longint; external 'gdi32' name 'StartDocW';
 function GetObjectW(_para1:HGDIOBJ; _para2:longint; _para3:LPVOID):longint; external 'gdi32' name 'GetObjectW';
 function TextOutW(_para1:HDC; _para2:longint; _para3:longint; _para4:LPCWSTR; _para5:longint):WINBOOL; external 'gdi32' name 'TextOutW';
 function ExtTextOutW(_para1:HDC; _para2:longint; _para3:longint; _para4:UINT; _para5:LPRECT;_para6:LPCWSTR; _para7:UINT; _para8:LPINT):WINBOOL; external 'gdi32' name 'ExtTextOutW';
-function PolyTextOutW(_para1:HDC; _para2:PPOLYTEXT; _para3:longint):WINBOOL; external 'gdi32' name 'PolyTextOutW';
+function PolyTextOutW(_para1:HDC; _para2:PPOLYTEXTW; _para3:longint):WINBOOL; external 'gdi32' name 'PolyTextOutW';
 function GetTextFaceW(_para1:HDC; _para2:longint; _para3:LPWSTR):longint; external 'gdi32' name 'GetTextFaceW';
 function GetKerningPairsW(_para1:HDC; _para2:DWORD; _para3:LPKERNINGPAIR):DWORD; external 'gdi32' name 'GetKerningPairsW';
-function GetLogColorSpaceW(_para1:HCOLORSPACE; _para2:LPLOGCOLORSPACE; _para3:DWORD):WINBOOL; external 'gdi32' name 'GetLogColorSpaceW';
-function CreateColorSpaceW(_para1:LPLOGCOLORSPACE):HCOLORSPACE; external 'gdi32' name 'CreateColorSpaceW';
+function GetLogColorSpaceW(_para1:HCOLORSPACE; _para2:LPLOGCOLORSPACEW; _para3:DWORD):WINBOOL; external 'gdi32' name 'GetLogColorSpaceW';
+function CreateColorSpaceW(_para1:LPLOGCOLORSPACEW):HCOLORSPACE; external 'gdi32' name 'CreateColorSpaceW';
 function GetICMProfileW(_para1:HDC; _para2:LPDWORD; _para3:LPWSTR):WINBOOL; external 'gdi32' name 'GetICMProfileW';
 function SetICMProfileW(_para1:HDC; _para2:LPWSTR):WINBOOL; external 'gdi32' name 'SetICMProfileW';
 function UpdateICMRegKeyW(_para1:DWORD; _para2:DWORD; _para3:LPWSTR; _para4:UINT):WINBOOL; external 'gdi32' name 'UpdateICMRegKeyW';
-function EnumICMProfilesW(_para1:HDC; _para2:ICMENUMPROC; _para3:LPARAM):longint; external 'gdi32' name 'EnumICMProfilesW';
+function EnumICMProfilesW(_para1:HDC; _para2:ICMENUMPROCW; _para3:LPARAM):longint; external 'gdi32' name 'EnumICMProfilesW';
 {
 function CreatePropertySheetPageW(lppsp:LPCPROPSHEETPAGE):HPROPSHEETPAGE; external 'comctl32' name 'CreatePropertySheetPageW';
 function PropertySheetW(lppsph:LPCPROPSHEETHEADER):longint; external 'comctl32' name 'PropertySheetW';
@@ -381,7 +381,7 @@ function RegRestoreKeyW(hKey:HKEY; lpFile:LPCWSTR; dwFlags:DWORD):LONG; external
 function RegSaveKeyW(hKey:HKEY; lpFile:LPCWSTR; lpSecurityAttributes:LPSECURITY_ATTRIBUTES):LONG; external 'advapi32' name 'RegSaveKeyW';
 function RegSetValueW(hKey:HKEY; lpSubKey:LPCWSTR; dwType:DWORD; lpData:LPCWSTR; cbData:DWORD):LONG; external 'advapi32' name 'RegSetValueW';
 function RegQueryValueW(hKey:HKEY; lpSubKey:LPCWSTR; lpValue:LPWSTR; lpcbValue:PLONG):LONG; external 'advapi32' name 'RegQueryValueW';
-function RegQueryMultipleValuesW(hKey:HKEY; val_list:PVALENT; num_vals:DWORD; lpValueBuf:LPWSTR; ldwTotsize:LPDWORD):LONG; external 'advapi32' name 'RegQueryMultipleValuesW';
+function RegQueryMultipleValuesW(hKey:HKEY; val_list:PVALENTW; num_vals:DWORD; lpValueBuf:LPWSTR; ldwTotsize:LPDWORD):LONG; external 'advapi32' name 'RegQueryMultipleValuesW';
 function RegQueryValueExW(hKey:HKEY; lpValueName:LPCWSTR; lpReserved:LPDWORD; lpType:LPDWORD; lpData:LPBYTE;lpcbData:LPDWORD):LONG; external 'advapi32' name 'RegQueryValueExW';
 function RegReplaceKeyW(hKey:HKEY; lpSubKey:LPCWSTR; lpNewFile:LPCWSTR; lpOldFile:LPCWSTR):LONG; external 'advapi32' name 'RegReplaceKeyW';
 function RegConnectRegistryW(lpMachineName:LPWSTR; hKey:HKEY; phkResult:PHKEY):LONG; external 'advapi32' name 'RegConnectRegistryW';
@@ -404,16 +404,16 @@ function GetLocaleInfoW(Locale:LCID; LCType:LCTYPE; lpLCData:LPWSTR; cchData:lon
 function SetLocaleInfoW(Locale:LCID; LCType:LCTYPE; lpLCData:LPCWSTR):WINBOOL; external 'kernel32' name 'SetLocaleInfoW';
 function GetTimeFormatW(Locale:LCID; dwFlags:DWORD; lpTime:LPSYSTEMTIME; lpFormat:LPCWSTR; lpTimeStr:LPWSTR;cchTime:longint):longint; external 'kernel32' name 'GetTimeFormatW';
 function GetDateFormatW(Locale:LCID; dwFlags:DWORD; lpDate:LPSYSTEMTIME; lpFormat:LPCWSTR; lpDateStr:LPWSTR;cchDate:longint):longint; external 'kernel32' name 'GetDateFormatW';
-function GetNumberFormatW(Locale:LCID; dwFlags:DWORD; lpValue:LPCWSTR; lpFormat:PNUMBERFMT; lpNumberStr:LPWSTR;cchNumber:longint):longint; external 'kernel32' name 'GetNumberFormatW';
-function GetCurrencyFormatW(Locale:LCID; dwFlags:DWORD; lpValue:LPCWSTR; lpFormat:PCURRENCYFMT; lpCurrencyStr:LPWSTR;cchCurrency:longint):longint; external 'kernel32' name 'GetCurrencyFormatW';
-function EnumCalendarInfoW(lpCalInfoEnumProc:CALINFO_ENUMPROC; Locale:LCID; Calendar:CALID; CalType:CALTYPE):WINBOOL; external 'kernel32' name 'EnumCalendarInfoW';
-function EnumTimeFormatsW(lpTimeFmtEnumProc:TIMEFMT_ENUMPROC; Locale:LCID; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumTimeFormatsW';
-function EnumDateFormatsW(lpDateFmtEnumProc:DATEFMT_ENUMPROC; Locale:LCID; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumDateFormatsW';
+function GetNumberFormatW(Locale:LCID; dwFlags:DWORD; lpValue:LPCWSTR; lpFormat:PnumberfmtW; lpNumberStr:LPWSTR;cchNumber:longint):longint; external 'kernel32' name 'GetNumberFormatW';
+function GetCurrencyFormatW(Locale:LCID; dwFlags:DWORD; lpValue:LPCWSTR; lpFormat:PCURRENCYFMTW; lpCurrencyStr:LPWSTR;cchCurrency:longint):longint; external 'kernel32' name 'GetCurrencyFormatW';
+function EnumCalendarInfoW(lpCalInfoEnumProc:CALINFO_ENUMPROCW; Locale:LCID; Calendar:CALID; CalType:CALTYPE):WINBOOL; external 'kernel32' name 'EnumCalendarInfoW';
+function EnumTimeFormatsW(lpTimeFmtEnumProc:TIMEFMT_ENUMPROCW; Locale:LCID; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumTimeFormatsW';
+function EnumDateFormatsW(lpDateFmtEnumProc:DATEFMT_ENUMPROCW; Locale:LCID; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumDateFormatsW';
 function GetStringTypeExW(Locale:LCID; dwInfoType:DWORD; lpSrcStr:LPCWSTR; cchSrc:longint; lpCharType:LPWORD):WINBOOL; external 'kernel32' name 'GetStringTypeExW';
 function GetStringTypeW(dwInfoType:DWORD; lpSrcStr:LPCWSTR; cchSrc:longint; lpCharType:LPWORD):WINBOOL; external 'kernel32' name 'GetStringTypeW';
 function FoldStringW(dwMapFlags:DWORD; lpSrcStr:LPCWSTR; cchSrc:longint; lpDestStr:LPWSTR; cchDest:longint):longint; external 'kernel32' name 'FoldStringW';
-function EnumSystemLocalesW(lpLocaleEnumProc:LOCALE_ENUMPROC; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumSystemLocalesW';
-function EnumSystemCodePagesW(lpCodePageEnumProc:CODEPAGE_ENUMPROC; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumSystemCodePagesW';
+function EnumSystemLocalesW(lpLocaleEnumProc:LOCALE_ENUMPROCW; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumSystemLocalesW';
+function EnumSystemCodePagesW(lpCodePageEnumProc:CODEPAGE_ENUMPROCW; dwFlags:DWORD):WINBOOL; external 'kernel32' name 'EnumSystemCodePagesW';
 function PeekConsoleInputW(hConsoleInput:HANDLE; lpBuffer:PINPUTRECORD; nLength:DWORD; lpNumberOfEventsRead:LPDWORD):WINBOOL; external 'kernel32' name 'PeekConsoleInputW';
 function ReadConsoleInputW(hConsoleInput:HANDLE; lpBuffer:PINPUTRECORD; nLength:DWORD; lpNumberOfEventsRead:LPDWORD):WINBOOL; external 'kernel32' name 'ReadConsoleInputW';
 function WriteConsoleInputW(hConsoleInput:HANDLE; lpBuffer:PINPUTRECORD; nLength:DWORD; lpNumberOfEventsWritten:LPDWORD):WINBOOL; external 'kernel32' name 'WriteConsoleInputW';
@@ -429,38 +429,38 @@ function ReadConsoleW(hConsoleInput:HANDLE; lpBuffer:LPVOID; nNumberOfCharsToRea
 function WriteConsoleW(hConsoleOutput:HANDLE;lpBuffer:pointer; nNumberOfCharsToWrite:DWORD; lpNumberOfCharsWritten:LPDWORD; lpReserved:LPVOID):WINBOOL; external 'kernel32' name 'WriteConsoleW';
 function GetCPInfoExW(Codepage:UINT; dwFlags:DWORD; CPinfoEx:LPCPINFOEXW):WINBOOL; external 'kernel32' name 'GetCPInfoExW';
 function WNetAddConnectionW(lpRemoteName:LPCWSTR; lpPassword:LPCWSTR; lpLocalName:LPCWSTR):DWORD; external 'mpr' name 'WNetAddConnectionW';
-function WNetAddConnection2W(lpNetResource:LPNETRESOURCE; lpPassword:LPCWSTR; lpUserName:LPCWSTR; dwFlags:DWORD):DWORD; external 'mpr' name 'WNetAddConnection2W';
-function WNetAddConnection3W(hwndOwner:HWND; lpNetResource:LPNETRESOURCE; lpPassword:LPCWSTR; lpUserName:LPCWSTR; dwFlags:DWORD):DWORD; external 'mpr' name 'WNetAddConnection3W';
+function WNetAddConnection2W(lpNetResource:LPNETRESOURCEW; lpPassword:LPCWSTR; lpUserName:LPCWSTR; dwFlags:DWORD):DWORD; external 'mpr' name 'WNetAddConnection2W';
+function WNetAddConnection3W(hwndOwner:HWND; lpNetResource:LPNETRESOURCEW; lpPassword:LPCWSTR; lpUserName:LPCWSTR; dwFlags:DWORD):DWORD; external 'mpr' name 'WNetAddConnection3W';
 function WNetCancelConnectionW(lpName:LPCWSTR; fForce:WINBOOL):DWORD; external 'mpr' name 'WNetCancelConnectionW';
 function WNetCancelConnection2W(lpName:LPCWSTR; dwFlags:DWORD; fForce:WINBOOL):DWORD; external 'mpr' name 'WNetCancelConnection2W';
 function WNetGetConnectionW(lpLocalName:LPCWSTR; lpRemoteName:LPWSTR; lpnLength:LPDWORD):DWORD; external 'mpr' name 'WNetGetConnectionW';
-function WNetUseConnectionW(hwndOwner:HWND; lpNetResource:LPNETRESOURCE; lpUserID:LPCWSTR; lpPassword:LPCWSTR; dwFlags:DWORD;lpAccessName:LPWSTR; lpBufferSize:LPDWORD; lpResult:LPDWORD):DWORD; external 'mpr' name 'WNetUseConnectionW';
+function WNetUseConnectionW(hwndOwner:HWND; lpNetResource:LPNETRESOURCEW; lpUserID:LPCWSTR; lpPassword:LPCWSTR; dwFlags:DWORD;lpAccessName:LPWSTR; lpBufferSize:LPDWORD; lpResult:LPDWORD):DWORD; external 'mpr' name 'WNetUseConnectionW';
 function WNetSetConnectionW(lpName:LPCWSTR; dwProperties:DWORD; pvValues:LPVOID):DWORD; external 'mpr' name 'WNetSetConnectionW';
-function WNetConnectionDialog1W(lpConnDlgStruct:LPCONNECTDLGSTRUCT):DWORD; external 'mpr' name 'WNetConnectionDialog1W';
-function WNetDisconnectDialog1W(lpConnDlgStruct:LPDISCDLGSTRUCT):DWORD; external 'mpr' name 'WNetDisconnectDialog1W';
-function WNetOpenEnumW(dwScope:DWORD; dwType:DWORD; dwUsage:DWORD; lpNetResource:LPNETRESOURCE; lphEnum:LPHANDLE):DWORD; external 'mpr' name 'WNetOpenEnumW';
+function WNetConnectionDialog1W(lpConnDlgStruct:LPCONNECTDLGSTRUCTW):DWORD; external 'mpr' name 'WNetConnectionDialog1W';
+function WNetDisconnectDialog1W(lpConnDlgStruct:LPDISCDLGSTRUCTW):DWORD; external 'mpr' name 'WNetDisconnectDialog1W';
+function WNetOpenEnumW(dwScope:DWORD; dwType:DWORD; dwUsage:DWORD; lpNetResource:LPNETRESOURCEW                      ; lphEnum:LPHANDLE):DWORD; external 'mpr' name 'WNetOpenEnumW';
 function WNetEnumResourceW(hEnum:HANDLE; lpcCount:LPDWORD; lpBuffer:LPVOID; lpBufferSize:LPDWORD):DWORD; external 'mpr' name 'WNetEnumResourceW';
 function WNetGetUniversalNameW(lpLocalPath:LPCWSTR; dwInfoLevel:DWORD; lpBuffer:LPVOID; lpBufferSize:LPDWORD):DWORD; external 'mpr' name 'WNetGetUniversalNameW';
 function WNetGetUserW(lpName:LPCWSTR; lpUserName:LPWSTR; lpnLength:LPDWORD):DWORD; external 'mpr' name 'WNetGetUserW';
 function WNetGetProviderNameW(dwNetType:DWORD; lpProviderName:LPWSTR; lpBufferSize:LPDWORD):DWORD; external 'mpr' name 'WNetGetProviderNameW';
 function WNetGetNetworkInformationW(lpProvider:LPCWSTR; lpNetInfoStruct:LPNETINFOSTRUCT):DWORD; external 'mpr' name 'WNetGetNetworkInformationW';
 function WNetGetLastErrorW(lpError:LPDWORD; lpErrorBuf:LPWSTR; nErrorBufSize:DWORD; lpNameBuf:LPWSTR; nNameBufSize:DWORD):DWORD; external 'mpr' name 'WNetGetLastErrorW';
-function MultinetGetConnectionPerformanceW(lpNetResource:LPNETRESOURCE; lpNetConnectInfoStruct:LPNETCONNECTINFOSTRUCT):DWORD; external 'mpr' name 'MultinetGetConnectionPerformanceW';
+function MultinetGetConnectionPerformanceW(lpNetResource:LPNETRESOURCEW; lpNetConnectInfoStruct:LPNETCONNECTINFOSTRUCT):DWORD; external 'mpr' name 'MultinetGetConnectionPerformanceW';
 function ChangeServiceConfigW(hService:SC_HANDLE; dwServiceType:DWORD; dwStartType:DWORD; dwErrorControl:DWORD; lpBinaryPathName:LPCWSTR;lpLoadOrderGroup:LPCWSTR; lpdwTagId:LPDWORD; lpDependencies:LPCWSTR; lpServiceStartName:LPCWSTR;
   lpPassword:LPCWSTR;lpDisplayName:LPCWSTR):WINBOOL; external 'advapi32' name 'ChangeServiceConfigW';
 function CreateServiceW(hSCManager:SC_HANDLE; lpServiceName:LPCWSTR; lpDisplayName:LPCWSTR; dwDesiredAccess:DWORD; dwServiceType:DWORD;dwStartType:DWORD; dwErrorControl:DWORD; lpBinaryPathName:LPCWSTR; lpLoadOrderGroup:LPCWSTR;
   lpdwTagId:LPDWORD;lpDependencies:LPCWSTR; lpServiceStartName:LPCWSTR; lpPassword:LPCWSTR):SC_HANDLE; external 'advapi32' name 'CreateServiceW';
-function EnumDependentServicesW(hService:SC_HANDLE; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUS; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD;lpServicesReturned:LPDWORD):WINBOOL; external 'advapi32' name 'EnumDependentServicesW';
-function EnumServicesStatusW(hSCManager:SC_HANDLE; dwServiceType:DWORD; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUS; cbBufSize:DWORD;pcbBytesNeeded:LPDWORD; lpServicesReturned:LPDWORD; lpResumeHandle:LPDWORD):WINBOOL;
+function EnumDependentServicesW(hService:SC_HANDLE; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUSW; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD;lpServicesReturned:LPDWORD):WINBOOL; external 'advapi32' name 'EnumDependentServicesW';
+function EnumServicesStatusW(hSCManager:SC_HANDLE; dwServiceType:DWORD; dwServiceState:DWORD; lpServices:LPENUM_SERVICE_STATUSW; cbBufSize:DWORD;pcbBytesNeeded:LPDWORD; lpServicesReturned:LPDWORD; lpResumeHandle:LPDWORD):WINBOOL;
   external 'advapi32' name 'EnumServicesStatusW';
 function GetServiceKeyNameW(hSCManager:SC_HANDLE; lpDisplayName:LPCWSTR; lpServiceName:LPWSTR; lpcchBuffer:LPDWORD):WINBOOL; external 'advapi32' name 'GetServiceKeyNameW';
 function GetServiceDisplayNameW(hSCManager:SC_HANDLE; lpServiceName:LPCWSTR; lpDisplayName:LPWSTR; lpcchBuffer:LPDWORD):WINBOOL; external 'advapi32' name 'GetServiceDisplayNameW';
 function OpenSCManagerW(lpMachineName:LPCWSTR; lpDatabaseName:LPCWSTR; dwDesiredAccess:DWORD):SC_HANDLE; external 'advapi32' name 'OpenSCManagerW';
 function OpenServiceW(hSCManager:SC_HANDLE; lpServiceName:LPCWSTR; dwDesiredAccess:DWORD):SC_HANDLE; external 'advapi32' name 'OpenServiceW';
-function QueryServiceConfigW(hService:SC_HANDLE; lpServiceConfig:LPQUERY_SERVICE_CONFIG; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceConfigW';
-function QueryServiceLockStatusW(hSCManager:SC_HANDLE; lpLockStatus:LPQUERY_SERVICE_LOCK_STATUS; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceLockStatusW';
+function QueryServiceConfigW(hService:SC_HANDLE; lpServiceConfig:LPQUERY_SERVICE_CONFIGW; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceConfigW';
+function QueryServiceLockStatusW(hSCManager:SC_HANDLE; lpLockStatus:LPQUERY_SERVICE_LOCK_STATUSW; cbBufSize:DWORD; pcbBytesNeeded:LPDWORD):WINBOOL; external 'advapi32' name 'QueryServiceLockStatusW';
 function RegisterServiceCtrlHandlerW(lpServiceName:LPCWSTR; lpHandlerProc:LPHANDLER_FUNCTION):SERVICE_STATUS_HANDLE; external 'advapi32' name 'RegisterServiceCtrlHandlerW';
-function StartServiceCtrlDispatcherW(lpServiceStartTable:LPSERVICE_TABLE_ENTRY):WINBOOL; external 'advapi32' name 'StartServiceCtrlDispatcherW';
+function StartServiceCtrlDispatcherW(lpServiceStartTable:LPSERVICE_TABLE_ENTRYW):WINBOOL; external 'advapi32' name 'StartServiceCtrlDispatcherW';
 function StartServiceW(hService:SC_HANDLE; dwNumServiceArgs:DWORD; lpServiceArgVectors:LPPCWSTR):WINBOOL; external 'advapi32' name 'StartServiceW';
 function DragQueryFileW(_para1:HDROP; _para2:cardinal; _para3:LPCWSTR; _para4:cardinal):cardinal; external 'shell32' name 'DragQueryFileW';
 function ExtractAssociatedIconW(_para1:HINST; _para2:LPCWSTR; _para3:LPWORD):HICON; external 'shell32' name 'ExtractAssociatedIconW';
@@ -468,7 +468,7 @@ function ExtractIconW(_para1:HINST; _para2:LPCWSTR; _para3:cardinal):HICON; exte
 function FindExecutableW(_para1:LPCWSTR; _para2:LPCWSTR; _para3:LPCWSTR):HINST; external 'shell32' name 'FindExecutableW';
 function ShellAboutW(_para1:HWND; _para2:LPCWSTR; _para3:LPCWSTR; _para4:HICON):longint; external 'shell32' name 'ShellAboutW';
 function ShellExecuteW(_para1:HWND; _para2:LPCWSTR; _para3:LPCWSTR; _para4:LPCWSTR; _para5:LPCWSTR;_para6:longint):HINST; external 'shell32' name 'ShellExecuteW';
-function Shell_NotifyIconW(dwMessage: DWORD; lpData: PNotifyIconDataA): BOOL; external 'shell32' name 'Shell_NotifyIconW';
+function Shell_NotifyIconW(dwMessage: DWORD; lpData: PNotifyIconDataW): BOOL; external 'shell32' name 'Shell_NotifyIconW';
 function DdeCreateStringHandleW(_para1:DWORD; _para2:LPCWSTR; _para3:longint):HSZ; external 'user32' name 'DdeCreateStringHandleW';
 function DdeInitializeW(_para1:LPDWORD; _para2:PFNCALLBACK; _para3:DWORD; _para4:DWORD):UINT; external 'user32' name 'DdeInitializeW';
 function DdeQueryStringW(_para1:DWORD; _para2:HSZ; _para3:LPCWSTR; _para4:DWORD; _para5:longint):DWORD; external 'user32' name 'DdeQueryStringW';
@@ -481,6 +481,7 @@ function OpenWaitableTimerW(dwDesiredAccess:DWORD;bInheritHandle:BOOL;lpTimerNam
 function FindFirstFileExW(lpfilename : LPCWStr;fInfoLevelId:FINDEX_INFO_LEVELS ;lpFindFileData:pointer;fSearchOp : FINDEX_SEARCH_OPS;lpSearchFilter:pointer;dwAdditionalFlags:dword):Handle; stdcall; external 'kernel32' name 'FindFirstFileExW';
 // winver>$0600 
 function FindFirstFileTransactedW(lpfilename : LPCWStr;fInfoLevelId:FINDEX_INFO_LEVELS ;lpFindFileData:pointer;fSearchOp : FINDEX_SEARCH_OPS;lpSearchFilter:pointer;dwAdditionalFlags:dword;htransaction : HANDLE):Handle; stdcall; external 'kernel32' name 'FindFirstFileTransactedW';
+function CopyFileExW(lpExistingFileName,lpNewFileName : LPCWSTR;lpProgressRoutine:LPPROGRESS_ROUTINE;lpdata:Pointer;pbcancel:LPBOOL;dwCopyFlags:DWord):DWord; stdcall; external 'kernel32' name 'CopyFileExW';
 
 {$endif read_interface}
 

rtl/win32/windows.pp

@@ -22,6 +22,8 @@ unit windows;
 
 { stuff like array of const is used }
 {$mode objfpc}
+{$modeswitch ADVANCEDRECORDS}
+{$modeswitch class}
 {$inline on}
 {$calling stdcall}
 

rtl/win64/windows.pp

@@ -22,6 +22,8 @@ unit windows;
 
 { stuff like array of const is used }
 {$mode objfpc}
+{$modeswitch ADVANCEDRECORDS}
+{$modeswitch class}
 {$inline on}
 {$calling stdcall}
 

rtl/wince/windows.pp

@@ -25,6 +25,8 @@ unit windows;
 
 { stuff like array of const is used }
 {$mode objfpc}
+{$modeswitch ADVANCEDRECORDS}
+{$modeswitch class}
 { convention is cdecl for WinCE API}
 {$calling cdecl}
 

rtl/wince/wininc/struct.inc

@@ -53,7 +53,9 @@
 {$ifdef read_interface}
 
   type
-
+    {$calling default}
+    {$i typshrdh.inc}
+    {$calling cdecl}
     { WARNING
       the variable argument list
       is not implemented for FPC
@@ -265,26 +267,14 @@
      TANIMATIONINFO = ANIMATIONINFO;
      PANIMATIONINFO = ^ANIMATIONINFO;
 
-     POINT = record
-          x : LONG;
-          y : LONG;
-       end;
-     LPPOINT = ^POINT;
-     tagPOINT = POINT;
-     TPOINT = POINT;
-     PPOINT = ^POINT;
+     POINT = TPOINT;
+     LPPOINT = PPOINT;
+     tagPOINT = TPOINT;
 
-     RECT = record
-          case Integer of
-             0: (Left,Top,Right,Bottom : Longint);
-             1: (TopLeft,BottomRight : TPoint);
-       end;
-     LPRECT = ^RECT;
-     LPCRECT = ^RECT;
+     RECT = TRect;
+     LPRECT = PRECT;
      _RECT = RECT;
-     TRECT = RECT;
-     PRECT = ^RECT;
-     tagRECT = RECT; //+windef
+     LPRCECT = PRECT;
 
      RECTL = record
           left : LONG;
@@ -539,12 +529,6 @@
      TPOINTL = POINTL;
      PPOINTL = ^POINTL;
 
-     TSmallPoint = record
-       X,
-       Y : SmallInt;
-       end;
-
-
      POINTS = record
           x : SHORT;
           y : SHORT;
@@ -3245,14 +3229,9 @@
      TEMRFORMAT = EMRFORMAT;
      PEMRFORMAT = ^EMRFORMAT;
 
-     SIZE = record
-          cx : LONG;
-          cy : LONG;
-       end;
-     LPSIZE = ^SIZE;
+     SIZE = TSize;
+     LPSIZE = PSIZE;
      tagSIZE = SIZE;
-     TSIZE = SIZE;
-     PSIZE = ^SIZE;
 
      SIZEL = SIZE;        //windef
      TSIZEL = SIZE;       //windef
@@ -8234,5 +8213,8 @@ type
        a.flag0:=a.flag0 or ((__fAckReq shl bp_DDEUP_fAckReq) and bm_DDEUP_fAckReq);
     end;
 
+ {$calling default}
+ {$i typshrd.inc}
+ {$calling cdecl}
 {$endif read_implementation}