A TPoint parameter shows correct values in Win32, but not in Win64

Question

Migrating delphi Win32 code to Win64 with Delphi code, especially when using event handlers or an function taking a TPoint parameter: in Win32 this showed correct values for the point’s x and y coordinates, but in Win64 reading x and y gave ‘junk’ values or some time same as value pass to it.

In my case TDM_Point(Msg.lParam) Msg.lParam do have value {3997726 } and after casting to TPoint variable P contain { x=30,y=61} in win32 bit and in win64 Msg.lParam do have value {3997726 } as same in win32 but after casting to TPoint variable P contain {x=3997723,y=0} )

Conditional defined as follows:

{$IFDEF WIN32}
    TDM_Point = TSmallPoint;
{$ELSE}
    TDM_Point = TPoint;
{$ENDIF}

Sample code as follows :

Function process
begin
  If Form.Handle = Msg.hWnd Then
  begin
    Control := SearchControl ( Form, TDM_Point(Msg.lParam) );         
    //Msg is type of tagMSG 
  end
end


Function Form.SearchControl ( Parent : tWinControl; P : TDM_Point ) : tControl;
Var
  Index   : Integer;
  Control : tControl;
  Rect    : tRect;
  tmpPoint : TPoint;
Begin            
  //code            
end 

Msg value is set by value return by Process Message

[UIPermission(SecurityAction.LinkDemand, Window=UIPermissionWindow.AllWindows)]
procedure TApplication.HandleMessage;
var
  Msg: TMsg;
begin
  if not ProcessMessage(Msg) then Idle(Msg);
end;  

Value is set as follows :

If Drawing Then
Begin
{$IFNDEF WIN32}
  { Map coordinates to parent of chosen control,
    or to form in no control is chosen }
  If EditControls.Count > 0 Then
     MapWindowPoints ( Msg.hWnd,
                       tControl(EditControls.Objects[0]).Parent.Handle,
                       Msg.lParam, 1 )
  Else
     MapWindowPoints ( Msg.hWnd, fEditForm.Handle,
                       Msg.lParam, 1 );
{$ELSE}
  x:=GetSystemMetrics(SM_CXFRAME);
  if abs((Msg.Pt.X-fEditForm.left-x) - TDM_Point(Msg.lParam).X)  > 0 then
    TDM_Point(Msg.lParam).X:=Msg.Pt.X-fEditForm.left-x;

  x:=GetSystemMetrics(SM_CYCAPTION)+GetSystemMetrics(SM_CYFRAME);
  if abs((Msg.Pt.Y-fEditForm.top-x) - TDM_Point(Msg.lParam).Y)  > 0 then
    TDM_Point(Msg.lParam).Y:=Msg.Pt.Y-fEditForm.top-x;
{$ENDIF}
  Start.X   := TDM_Point(Msg.lParam).X;
  Start.Y   := TDM_Point(Msg.lParam).Y;
  Last    := Start;
  SetSelection;
  SetClipRect;
End;      

please find the call stack below. we did not prepare any message. this is prepared by system when we click on label control of the form. top two functions of call stack are our functions,in which we get the msg value from processmessage of vcl.forms

Answer 1

The conditional define you use is wrong: You say that Msg.lParam is 3997726 in both cases. That can only mean one thing: you always receive a TSmallPoint, and never a TPoint.

3997726 is hex $003D001E which shows 16 bit values (two Smallint values),

X = $001E (decimal value 30) 
Y = $003D (decimal value 61). 

Obviously you are receiving a TSmallPoint as Msg.lParam, even in Win64. So always cast to TSmallPoint, never cast to TPoint (I can't imagine you cast to to TPoint in Win32, you probably cast to TDM_Point).

Since Msg.lParam is 64 bit in Win64, you can't directly cast it to TDM_Point^[1] (or to TSmallPoint) — I guess that is why you made it a TPoint in Win64: to match the size of Msg.lParam.

But integral types of different sizes can be cast to each other. So you can use an intermediate cast to an integral type of the right size (UInt32 here, which is a 32 bit unsigned integer), e.g. something like:

type
  // No conditional define! Always TSmallPoint!
  TDM_Point = TSmallPoint; // 2 x 16 bit = 32 bit

and later on in your code:

begin
  X := TDM_Point(UInt32(Msg.lParam)).X; // or: TSmallPoint(UInt32(Msg.lParam)).X
  Y := TDM_Point(UInt32(Msg.lParam)).Y; // or: TSmallPoint(UInt32(Msg.lParam)).Y

So again: the message you receive always seems to contain a TSmallPoint. Do not define TDM_Point differently for different platforms.

UPDATE

The screenshot you added shows that the message is WM_LBUTTONDOWN, which is very well documented:

lParam

The low-order word specifies the x-coordinate of the cursor. The coordinate is relative to the upper-left corner of the client area.

The high-order word specifies the y-coordinate of the cursor. The coordinate is relative to the upper-left corner of the client area.

---

^[1] As David Heffernan confirmed.

Answer 2

The reason why this is happening is becouse TSmallPoint is a recoed whose X and Y fields are stored as Smallint (16 bit integer) while TPoint stores its X and Y fields as FixedInt (32 bit integer)

System.Types.TSmallPoint

System.Types.TPoint

Internal Data Formats (Delphi)

So when you are typecasting your data to TPoint structure in your 64 bit application reading X value actually reads memory block that holds both X and Y values especially if the messege was created in 32 bit application which uses TSmallPoint structure.

Therefore in order to solve your problem you will have to unify your data structure on both 32 bit and 64 version of your application in order to be able to send messages between the two of them.