PointerHandler.c

Go to the documentation of this file.

 
#include <AppleMacEfi.h>
 
#include <Guid/AppleVariable.h>
 
#include <Protocol/GraphicsOutput.h>
#include <Protocol/UgaDraw.h>
#include <Protocol/SimplePointer.h>
 
#include <Library/AppleEventLib.h>
#include <Library/OcAppleEventLib.h>
#include <Library/BaseLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/UefiLib.h>
#include <Library/UefiRuntimeServicesTableLib.h>
#include <Library/TimerLib.h>
 
#include "AppleEventInternal.h"
 
#include <Library/BaseLib.h>
 
//
// CHANGE: Apple polls with a frequency of 2 ms, however this is infeasible on
//         most machines. Poll with 10 ms, which matches the keyboard behaviour,
//         and also is the minimum for QEMU.
//
#define MIN_POINTER_POLL_PERIOD  10
#define MAX_POINTER_POLL_PERIOD  80
 
#define MAX_CLICK_DURATION      148  // 74 for 2 ms
#define MAX_DOUBLE_CLICK_SPEED  748  // 374 for 2 ms
 
#define MAX_POLL_DURATION  ((MAX_UINT32 / 10000) / MAX_DOUBLE_CLICK_SPEED)
 
GLOBAL_REMOVE_IF_UNREFERENCED UINT32  mPointerSpeedDiv = 0;
GLOBAL_REMOVE_IF_UNREFERENCED UINT32  mPointerSpeedMul = 0;
 
STATIC UINT16  mMaximumDoubleClickSpeed = 0;
STATIC UINT16  mMaximumClickDuration    = 0;
 
// MINIMAL_MOVEMENT
#define MINIMAL_MOVEMENT  5
 
// POINTER_BUTTON_INFORMATION
typedef struct {
  APPLE_EVENT_TYPE    EventType;
  UINTN               ButtonTicksHold;
  UINTN               ButtonTicksSinceClick;
  UINTN               PreviousClickEventType;
  BOOLEAN             PreviousButton;
  BOOLEAN             CurrentButton;
  DIMENSION           MouseDownPosition;
  DIMENSION           ClickPosition;
} POINTER_BUTTON_INFORMATION;
 
// SIMPLE_POINTER_INSTANCE
typedef struct {
  EFI_HANDLE                     Handle;     
  EFI_SIMPLE_POINTER_PROTOCOL    *Interface; 
  BOOLEAN                        Installed;  
} SIMPLE_POINTER_INSTANCE;
 
// mSimplePointerInstallNotifyEvent
STATIC EFI_EVENT  mSimplePointerInstallNotifyEvent = NULL;
 
// mSimplePointerInstallNotifyRegistration
STATIC VOID  *mSimplePointerInstallNotifyRegistration = NULL;
 
// mSimplePointerInstances
STATIC SIMPLE_POINTER_INSTANCE  *mPointerProtocols = NULL;
 
// mNoSimplePointerInstances
STATIC UINTN  mNumberOfPointerProtocols = 0;
 
// mSimplePointerPollEvent
STATIC EFI_EVENT  mSimplePointerPollEvent = NULL;
 
// mSimplePointerPollTime
STATIC UINT32  mSimplePointerPollTime    = 0;
STATIC UINT32  mSimplePointerMinPollTime = 0;
STATIC UINT32  mSimplePointerMaxPollTime = 0;
 
STATIC UINT32  mSimplePointerPollMask = POINTER_POLL_ALL_MASK;
 
// mUiScale
STATIC UINT8  mUiScale = 1;
 
// mLeftButtonInfo
STATIC POINTER_BUTTON_INFORMATION  mLeftButtonInfo = {
  APPLE_EVENT_TYPE_LEFT_BUTTON,
  0,
  0,
  0,
  FALSE,
  FALSE,
  { 0,                         0  },
  { 0,                         0  }
};
 
// mRightButtonInfo
STATIC POINTER_BUTTON_INFORMATION  mRightButtonInfo = {
  APPLE_EVENT_TYPE_RIGHT_BUTTON,
  0,
  0,
  0,
  FALSE,
  FALSE,
  { 0,                          0  },
  { 0,                          0  }
};
 
// mCursorPosition
STATIC DIMENSION  mCursorPosition;
 
// mMouseMoved
STATIC BOOLEAN  mMouseMoved;
 
// mScreenResolution
STATIC DIMENSION  mResolution = { 800, 600 };
 
STATIC UINT64  mMaxPointerResolutionX = 1;
STATIC UINT64  mMaxPointerResolutionY = 1;
 
STATIC UINT64  mPointerRawX;
STATIC UINT64  mPointerRawY;
 
STATIC UINT32     mDwellClickTimeout;
STATIC UINT32     mDwellDoubleClickTimeout;
STATIC UINT32     mDwellClickRadiusSqr;
STATIC DIMENSION  mDwellPosition;
STATIC UINT32     mDwellClickTime;
 
VOID
InternalInitializePointerUiScale (
  VOID
  )
{
  EFI_STATUS  Status;
  UINTN       DataSize;
 
  DataSize = sizeof (mUiScale);
  Status   = gRT->GetVariable (
                    APPLE_UI_SCALE_VARIABLE_NAME,
                    &gAppleVendorVariableGuid,
                    NULL,
                    &DataSize,
                    (VOID *)&mUiScale
                    );
  if (EFI_ERROR (Status) || (mUiScale != 2)) {
    mUiScale = 1;
  }
}
 
VOID
InternalSetPointerPolling (
  IN UINT32  PointerPollMin,
  IN UINT32  PointerPollMax,
  IN UINT32  PointerPollMask
  )
{
  if (PointerPollMin == POINTER_POLL_DEFAULT) {
    PointerPollMin = MIN_POINTER_POLL_PERIOD;
  } else if (PointerPollMin > MAX_POLL_DURATION) {
    PointerPollMin = MAX_POLL_DURATION;
  }
 
  mSimplePointerMinPollTime = PointerPollMin * 10000;
 
  mMaximumClickDuration    = (UINT16)(MAX_CLICK_DURATION / PointerPollMin);
  mMaximumDoubleClickSpeed = (UINT16)(MAX_DOUBLE_CLICK_SPEED / PointerPollMin);
 
  if (PointerPollMax == POINTER_POLL_DEFAULT) {
    PointerPollMax = MAX_POINTER_POLL_PERIOD;
  } else if (PointerPollMax > MAX_POLL_DURATION) {
    PointerPollMax = MAX_POLL_DURATION;
  }
 
  mSimplePointerMaxPollTime = PointerPollMax * 10000;
 
  mSimplePointerPollMask = PointerPollMask;
}
 
VOID
InternalSetPointerSpeed (
  IN UINT16  PointerSpeedDiv,
  IN UINT16  PointerSpeedMul
  )
{
  if (PointerSpeedDiv != 0) {
    mPointerSpeedDiv = PointerSpeedDiv;
  } else {
    DEBUG ((
      DEBUG_WARN,
      "OCAE: Illegal PointerSpeedDiv value 0, using 1\n",
      mPointerSpeedDiv
      ));
    mPointerSpeedDiv = 1;
  }
 
  mPointerSpeedMul = PointerSpeedMul;
}
 
VOID
InternalSetDwellClicking (
  IN UINT16  ClickTimeout,
  IN UINT16  DoubleClickTimeout,
  IN UINT16  Radius
  )
{
  mDwellClickTimeout       = (UINT32)ClickTimeout * 10000;
  mDwellDoubleClickTimeout = (UINT32)DoubleClickTimeout * 10000;
  mDwellClickRadiusSqr     = ((UINT32)Radius * Radius) * (mUiScale * mUiScale);
}
 
// InternalRegisterSimplePointerInterface
STATIC
VOID
InternalRegisterSimplePointerInterface (
  IN EFI_HANDLE                   Handle,
  IN EFI_SIMPLE_POINTER_PROTOCOL  *SimplePointer
  )
{
  SIMPLE_POINTER_INSTANCE  *Instance;
  UINTN                    Index;
 
  DEBUG ((DEBUG_VERBOSE, "InternalRegisterSimplePointerInterface\n"));
 
  Instance = AllocateZeroPool (
               (mNumberOfPointerProtocols + 1) * sizeof (*Instance)
               );
 
  if (Instance != NULL) {
    //
    // Apple did not check against NULL here and below as of boot.efi
    //
    if (mPointerProtocols != NULL) {
      CopyMem (
        Instance,
        mPointerProtocols,
        (mNumberOfPointerProtocols * sizeof (*Instance))
        );
    }
 
    Index = mNumberOfPointerProtocols;
 
    ++mNumberOfPointerProtocols;
 
    Instance[Index].Handle    = Handle;
    Instance[Index].Interface = SimplePointer;
    Instance[Index].Installed = TRUE;
 
    if (mPointerProtocols != NULL) {
      FreePool ((VOID *)mPointerProtocols);
    }
 
    mPointerProtocols = Instance;
 
    if (SimplePointer->Mode->ResolutionX > mMaxPointerResolutionX) {
      mPointerRawX = MultU64x64 (mPointerRawX, mMaxPointerResolutionX);
      mPointerRawX = DivU64x64Remainder (
                       mPointerRawX,
                       SimplePointer->Mode->ResolutionX,
                       NULL
                       );
      mMaxPointerResolutionX = SimplePointer->Mode->ResolutionX;
    }
 
    if (SimplePointer->Mode->ResolutionY > mMaxPointerResolutionY) {
      mPointerRawY = MultU64x64 (mPointerRawY, mMaxPointerResolutionY);
      mPointerRawY = DivU64x64Remainder (
                       mPointerRawY,
                       SimplePointer->Mode->ResolutionY,
                       NULL
                       );
      mMaxPointerResolutionY = SimplePointer->Mode->ResolutionY;
    }
  }
}
 
// EventSimplePointerDesctructor
VOID
EventSimplePointerDesctructor (
  VOID
  )
{
  DEBUG ((DEBUG_VERBOSE, "EventSimplePointerDesctructor\n"));
 
  if (mPointerProtocols != NULL) {
    FreePool ((VOID *)mPointerProtocols);
    //
    // Apple did not null the pointer here (not an error)
    //
    mPointerProtocols = NULL;
  }
}
 
// InternalRemoveUninstalledInstances
STATIC
VOID
InternalRemoveUninstalledInstances (
  IN OUT SIMPLE_POINTER_INSTANCE  **InstancesPtr,
  IN     UINTN                    *NumberOfInstances,
  IN     EFI_GUID                 *Protocol
  )
{
  EFI_STATUS               Status;
  UINTN                    NumberHandles;
  EFI_HANDLE               *Buffer;
  SIMPLE_POINTER_INSTANCE  *Instance;
  UINTN                    Index;
  UINTN                    Index2;
  SIMPLE_POINTER_INSTANCE  *OrgInstances;
  SIMPLE_POINTER_INSTANCE  *NewInstances;
  UINTN                    NumberOfMatches;
 
  DEBUG ((DEBUG_VERBOSE, "InternalRemoveUninstalledInstances\n"));
 
  OrgInstances = *InstancesPtr;
 
  Status = gBS->LocateHandleBuffer (
                  ByProtocol,
                  Protocol,
                  NULL,
                  &NumberHandles,
                  &Buffer
                  );
 
  if (!EFI_ERROR (Status)) {
    if (*NumberOfInstances > 0) {
      NumberOfMatches = 0;
 
      for (Index = 0; Index < *NumberOfInstances; ++Index) {
        Instance = &OrgInstances[Index];
 
        if (Instance->Installed) {
          for (Index2 = 0; Index2 < NumberHandles; ++Index2) {
            if (Instance->Handle == Buffer[Index2]) {
              ++NumberOfMatches;
              break;
            }
          }
 
          if (NumberHandles == Index2) {
            Instance->Installed = FALSE;
          }
        }
      }
 
      if (NumberOfMatches != *NumberOfInstances) {
        //
        // Apple did not check for NumberOfMatches being > 0.
        //
        NewInstances = NULL;
        if (NumberOfMatches > 0) {
          NewInstances = AllocateZeroPool (
                           NumberOfMatches * sizeof (*NewInstances)
                           );
        }
 
        if (NewInstances != NULL) {
          Index2 = 0;
          for (Index = 0; Index < *NumberOfInstances; ++Index) {
            Instance = &OrgInstances[Index];
            if (Instance->Installed) {
              CopyMem (
                (VOID *)&NewInstances[Index2],
                (VOID *)Instance,
                sizeof (*Instance)
                );
 
              ++Index2;
            }
          }
 
          FreePool (OrgInstances);
 
          *InstancesPtr      = NewInstances;
          *NumberOfInstances = NumberOfMatches;
        }
      }
    }
 
    FreePool (Buffer);
  } else {
    if (OrgInstances != NULL) {
      FreePool (OrgInstances);
    }
 
    *InstancesPtr      = NULL;
    *NumberOfInstances = 0;
  }
}
 
// InternalSimplePointerInstallNotifyFunction
STATIC
VOID
EFIAPI
InternalSimplePointerInstallNotifyFunction (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  EFI_STATUS                   Status;
  UINTN                        NumberHandles;
  EFI_HANDLE                   *Buffer;
  UINTN                        Index;
  EFI_SIMPLE_POINTER_PROTOCOL  *SimplePointer;
 
  DEBUG ((DEBUG_VERBOSE, "InternalSimplePointerInstallNotifyFunction\n"));
 
  if (Event != NULL) {
    Status = gBS->LocateHandleBuffer (
                    ByRegisterNotify,
                    NULL,
                    mSimplePointerInstallNotifyRegistration,
                    &NumberHandles,
                    &Buffer
                    );
  } else {
    Status = gBS->LocateHandleBuffer (
                    ByProtocol,
                    &gEfiSimplePointerProtocolGuid,
                    NULL,
                    &NumberHandles,
                    &Buffer
                    );
  }
 
  if (!EFI_ERROR (Status)) {
    for (Index = 0; Index < NumberHandles; ++Index) {
      Status = gBS->HandleProtocol (
                      Buffer[Index],
                      &gEfiSimplePointerProtocolGuid,
                      (VOID **)&SimplePointer
                      );
 
      if (!EFI_ERROR (Status)) {
        InternalRegisterSimplePointerInterface (Buffer[Index], SimplePointer);
      }
    }
 
    FreePool ((VOID *)Buffer);
  }
}
 
// EventCreateSimplePointerInstallNotifyEvent
EFI_STATUS
EventCreateSimplePointerInstallNotifyEvent (
  VOID
  )
{
  EFI_STATUS  Status;
 
  DEBUG ((DEBUG_VERBOSE, "EventCreateSimplePointerInstallNotifyEvent\n"));
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  InternalSimplePointerInstallNotifyFunction,
                  NULL,
                  &mSimplePointerInstallNotifyEvent
                  );
 
  if (!EFI_ERROR (Status)) {
    Status = gBS->RegisterProtocolNotify (
                    &gEfiSimplePointerProtocolGuid,
                    mSimplePointerInstallNotifyEvent,
                    &mSimplePointerInstallNotifyRegistration
                    );
 
    if (EFI_ERROR (Status)) {
      gBS->CloseEvent (mSimplePointerInstallNotifyEvent);
 
      mSimplePointerInstallNotifyEvent = NULL;
    } else {
      InternalSimplePointerInstallNotifyFunction (NULL, NULL);
    }
  }
 
  return Status;
}
 
// EventCreateSimplePointerInstallNotifyEvent
VOID
EventCloseSimplePointerInstallNotifyEvent (
  VOID
  )
{
  DEBUG ((DEBUG_VERBOSE, "EventCloseSimplePointerInstallNotifyEvent\n"));
 
  if (mSimplePointerInstallNotifyEvent != NULL) {
    gBS->CloseEvent (mSimplePointerInstallNotifyEvent);
  }
}
 
// InternalGetScreenResolution
STATIC
VOID
InternalGetScreenResolution (
  VOID
  )
{
  EFI_STATUS                            Status;
  EFI_GRAPHICS_OUTPUT_PROTOCOL          *GraphicsOutput;
  EFI_UGA_DRAW_PROTOCOL                 *UgaDraw;
  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *Info;
  UINT32                                HorizontalResolution;
  UINT32                                VerticalResolution;
  UINT32                                ColorDepth;
  UINT32                                RefreshRate;
 
  DEBUG ((DEBUG_VERBOSE, "InternalGetScreenResolution\n"));
 
  //
  // CHANGE: Do not cache screen resolution to account for changes.
  //
 
  HorizontalResolution = 0;
  VerticalResolution   = 0;
 
  Status = gBS->HandleProtocol (
                  gST->ConsoleOutHandle,
                  &gEfiGraphicsOutputProtocolGuid,
                  (VOID **)&GraphicsOutput
                  );
  if (!EFI_ERROR (Status)) {
    Info                 = GraphicsOutput->Mode->Info;
    HorizontalResolution = Info->HorizontalResolution;
    VerticalResolution   = Info->VerticalResolution;
  } else if (Status == EFI_UNSUPPORTED) {
    Status = gBS->HandleProtocol (
                    gST->ConsoleOutHandle,
                    &gEfiUgaDrawProtocolGuid,
                    (VOID **)&UgaDraw
                    );
    DEBUG ((
      DEBUG_INFO,
      "OCAE: Failed to handle GOP, discovering UGA - %r\n",
      Status
      ));
 
    if (!EFI_ERROR (Status)) {
      Status = UgaDraw->GetMode (
                          UgaDraw,
                          &HorizontalResolution,
                          &VerticalResolution,
                          &ColorDepth,
                          &RefreshRate
                          );
    }
  }
 
  if (!EFI_ERROR (Status)) {
    if ((HorizontalResolution > 0) && (VerticalResolution > 0)) {
      mResolution.Horizontal = (INT32)HorizontalResolution;
      mResolution.Vertical   = (INT32)VerticalResolution;
 
      if (mCursorPosition.Horizontal >= mResolution.Horizontal) {
        mCursorPosition.Horizontal = mResolution.Horizontal - 1;
      }
 
      if (mCursorPosition.Vertical >= mResolution.Vertical) {
        mCursorPosition.Vertical = mResolution.Vertical - 1;
      }
 
      DEBUG ((
        DEBUG_INFO,
        "OCAE: Set screen resolution to %dx%d - %r\n",
        mResolution.Horizontal,
        mResolution.Vertical,
        Status
        ));
    } else {
      DEBUG ((DEBUG_INFO, "OCAE: Screen resolution has 0-dimension\n"));
    }
  } else {
    DEBUG ((
      DEBUG_INFO,
      "OCAE: Failed to get screen resolution - %r\n",
      Status
      ));
  }
}
 
// InternalGetUiScaleData
STATIC
INT64
InternalGetUiScaleData (
  IN INT64  Movement
  )
{
  INT64  AbsoluteValue;
  INTN   Value;
  INT64  Factor;
 
  DEBUG ((DEBUG_VERBOSE, "InternalGetUiScaleData\n"));
 
  AbsoluteValue = ABS (Movement);
  Value         = HighBitSet64 ((UINT64)(AbsoluteValue));
  Factor        = 5;
 
  if (Value <= 3) {
    Factor = (HighBitSet64 ((UINT64)(AbsoluteValue) + 1));
  }
 
  return (INT64)(MultS64x64 (
                   (INT64)(INT32)mUiScale,
                   MultS64x64 (Movement, Factor)
                   ));
}
 
// InternalCreatePointerEventQueueInformation
STATIC
APPLE_EVENT_INFORMATION *
InternalCreatePointerEventQueueInformation (
  IN APPLE_EVENT_TYPE    EventType,
  IN APPLE_MODIFIER_MAP  Modifiers
  )
{
  UINT32            FinalEventType;
  APPLE_EVENT_DATA  EventData;
 
  DEBUG ((DEBUG_VERBOSE, "InternalCreatePointerEventQueueInformation\n"));
 
  FinalEventType = APPLE_EVENT_TYPE_MOUSE_MOVED;
 
  if ((EventType & APPLE_EVENT_TYPE_MOUSE_MOVED) == 0) {
    FinalEventType = APPLE_ALL_MOUSE_EVENTS;
 
    if ((EventType & APPLE_CLICK_MOUSE_EVENTS) != 0) {
      FinalEventType = APPLE_CLICK_MOUSE_EVENTS;
    }
  }
 
  EventData.PointerEventType = EventType;
 
  return EventCreateAppleEventQueueInfo (
           EventData,
           FinalEventType,
           &mCursorPosition,
           Modifiers
           );
}
 
// InternalHandleButtonInteraction
STATIC
VOID
InternalHandleButtonInteraction (
  IN     EFI_STATUS                  PointerStatus,
  IN OUT POINTER_BUTTON_INFORMATION  *Pointer,
  IN     APPLE_MODIFIER_MAP          Modifiers
  )
{
  APPLE_EVENT_INFORMATION  *Information;
  INT32                    HorizontalMovement;
  INT32                    VerticalMovement;
  APPLE_EVENT_TYPE         EventType;
 
  DEBUG ((DEBUG_VERBOSE, "InternalHandleButtonInteraction\n"));
 
  if (!EFI_ERROR (PointerStatus)) {
    if (!Pointer->PreviousButton) {
      if (Pointer->CurrentButton) {
        Pointer->ButtonTicksHold   = 0;
        Pointer->MouseDownPosition = mCursorPosition;
 
        Information = InternalCreatePointerEventQueueInformation (
                        (Pointer->EventType | APPLE_EVENT_TYPE_MOUSE_DOWN),
                        Modifiers
                        );
 
        if (Information != NULL) {
          EventAddEventToQueue (Information);
        }
      }
    } else if (!Pointer->CurrentButton) {
      Information = InternalCreatePointerEventQueueInformation (
                      (Pointer->EventType | APPLE_EVENT_TYPE_MOUSE_UP),
                      Modifiers
                      );
 
      if (Information != NULL) {
        EventAddEventToQueue (Information);
      }
 
      if (Pointer->ButtonTicksHold <= mMaximumClickDuration) {
        HorizontalMovement = ABS (Pointer->MouseDownPosition.Horizontal - mCursorPosition.Horizontal);
        VerticalMovement   = ABS (Pointer->MouseDownPosition.Vertical - mCursorPosition.Vertical);
        //
        // CHANGE: Apple did not scale by UIScale.
        //
        if (  (HorizontalMovement <= mUiScale * MINIMAL_MOVEMENT)
           && (VerticalMovement <= mUiScale * MINIMAL_MOVEMENT))
        {
          EventType = APPLE_EVENT_TYPE_MOUSE_CLICK;
 
          if (  (Pointer->PreviousClickEventType == APPLE_EVENT_TYPE_MOUSE_CLICK)
             && (Pointer->ButtonTicksSinceClick <= mMaximumDoubleClickSpeed))
          {
            HorizontalMovement = ABS (Pointer->ClickPosition.Horizontal - mCursorPosition.Horizontal);
            VerticalMovement   = ABS (Pointer->ClickPosition.Vertical - mCursorPosition.Vertical);
 
            if (  (HorizontalMovement <= mUiScale * MINIMAL_MOVEMENT)
               && (VerticalMovement <= mUiScale * MINIMAL_MOVEMENT))
            {
              EventType = APPLE_EVENT_TYPE_MOUSE_DOUBLE_CLICK;
            }
          }
 
          Information = InternalCreatePointerEventQueueInformation (
                          (Pointer->EventType | EventType),
                          Modifiers
                          );
 
          if (Information != NULL) {
            EventAddEventToQueue (Information);
          }
 
          if (Pointer->PreviousClickEventType == APPLE_EVENT_TYPE_MOUSE_DOUBLE_CLICK) {
            EventType = ((Pointer->ButtonTicksSinceClick <= mMaximumDoubleClickSpeed)
                            ? APPLE_EVENT_TYPE_MOUSE_DOUBLE_CLICK
                            : APPLE_EVENT_TYPE_MOUSE_CLICK);
          }
 
          Pointer->PreviousClickEventType = EventType;
          Pointer->ClickPosition          = mCursorPosition;
          Pointer->ButtonTicksSinceClick  = 0;
        }
      }
    }
 
    Pointer->PreviousButton = Pointer->CurrentButton;
  }
 
  if (Pointer->PreviousButton && Pointer->CurrentButton) {
    ++Pointer->ButtonTicksHold;
  }
 
  ++Pointer->ButtonTicksSinceClick;
}
 
STATIC
VOID
InternalResetDwellClicking (
  VOID
  )
{
  mDwellClickTime = 0;
  CopyMem (
    &mDwellPosition,
    &mCursorPosition,
    sizeof (mDwellPosition)
    );
}
 
STATIC
VOID
InternalQueueDwellClick (
  IN APPLE_EVENT_TYPE    EventType,
  IN APPLE_MODIFIER_MAP  Modifiers
  )
{
  APPLE_EVENT_INFORMATION  *Information;
 
  Information = InternalCreatePointerEventQueueInformation (
                  APPLE_EVENT_TYPE_LEFT_BUTTON | APPLE_EVENT_TYPE_MOUSE_DOWN,
                  Modifiers
                  );
  if (Information != NULL) {
    EventAddEventToQueue (Information);
  }
 
  Information = InternalCreatePointerEventQueueInformation (
                  APPLE_EVENT_TYPE_LEFT_BUTTON | APPLE_EVENT_TYPE_MOUSE_UP,
                  Modifiers
                  );
  if (Information != NULL) {
    EventAddEventToQueue (Information);
  }
 
  Information = InternalCreatePointerEventQueueInformation (
                  APPLE_EVENT_TYPE_LEFT_BUTTON | EventType,
                  Modifiers
                  );
  if (Information != NULL) {
    EventAddEventToQueue (Information);
  }
}
 
STATIC
VOID
InternalHandleDwellClicking (
  IN APPLE_MODIFIER_MAP  Modifiers
  )
{
  BOOLEAN  ClickDisabled;
  BOOLEAN  DoubleClickDisabled;
  INT32    DistX;
  INT32    DistY;
 
  ClickDisabled       = mDwellClickTimeout == 0;
  DoubleClickDisabled = mDwellDoubleClickTimeout == 0;
  if (ClickDisabled && DoubleClickDisabled) {
    return;
  }
 
  DistX = mCursorPosition.Horizontal - mDwellPosition.Horizontal;
  DistY = mCursorPosition.Vertical - mDwellPosition.Vertical;
  if ((UINT32)(DistX * DistX + DistY * DistY) <= mDwellClickRadiusSqr) {
    mDwellClickTime += mSimplePointerPollTime;
 
    if (!DoubleClickDisabled && (mDwellClickTime >= mDwellDoubleClickTimeout)) {
      InternalQueueDwellClick (APPLE_EVENT_TYPE_MOUSE_DOUBLE_CLICK, Modifiers);
      InternalResetDwellClicking ();
    } else if (!ClickDisabled && (mDwellClickTime >= mDwellClickTimeout)) {
      InternalQueueDwellClick (APPLE_EVENT_TYPE_MOUSE_CLICK, Modifiers);
      if (DoubleClickDisabled) {
        InternalResetDwellClicking ();
      }
    }
  } else {
    InternalResetDwellClicking ();
  }
}
 
// InternalSimplePointerPollNotifyFunction
STATIC
VOID
EFIAPI
InternalSimplePointerPollNotifyFunction (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  APPLE_MODIFIER_MAP           Modifiers;
  UINTN                        Index;
  SIMPLE_POINTER_INSTANCE      *Instance;
  EFI_SIMPLE_POINTER_PROTOCOL  *SimplePointer;
  EFI_STATUS                   Status;
  EFI_STATUS                   CommonStatus;
  EFI_SIMPLE_POINTER_STATE     State;
  INT64                        UiScaleX;
  INT64                        UiScaleY;
  INT64                        ScaledY;
  INT64                        ScaledX;
  DIMENSION                    NewPosition;
  APPLE_EVENT_INFORMATION      *Information;
  APPLE_EVENT_DATA             EventData;
  UINT64                       StartTime;
  UINT64                       EndTime;
  INT64                        MaxRawPointerX;
  INT64                        MaxRawPointerY;
  UINT32                       ClickTemp;
  UINT32                       DoubleClickTemp;
  UINT64                       SimplePointerPollTime;
 
  StartTime = GetPerformanceCounter ();
 
  DEBUG ((DEBUG_VERBOSE, "InternalSimplePointerPollNotifyFunction\n"));
 
  Modifiers = InternalGetModifierStrokes ();
 
  InternalRemoveUninstalledInstances (
    &mPointerProtocols,
    &mNumberOfPointerProtocols,
    &gEfiSimplePointerProtocolGuid
    );
 
  CommonStatus = EFI_UNSUPPORTED;
 
  if (mNumberOfPointerProtocols > 0) {
    CommonStatus = EFI_NOT_READY;
 
    for (Index = 0; Index < mNumberOfPointerProtocols; ++Index) {
      if (  (mSimplePointerPollMask != POINTER_POLL_ALL_MASK)
         && ((Index >= 32) || (((1U << Index) & mSimplePointerPollMask) == 0)))
      {
        continue;
      }
 
      Instance      = &mPointerProtocols[Index];
      SimplePointer = Instance->Interface;
      Status        = SimplePointer->GetState (SimplePointer, &State);
 
      if (!EFI_ERROR (Status)) {
        //
        // CHANGE: Apple scaled the deltas and due to rounding errors, this is
        //         unacceptable. Changed to scale all pointer deltas to the
        //         maximum pointer resolution and scaling down to display
        //         coordinates always based on the accurate raw input value.
        //
 
        UiScaleX = InternalGetUiScaleData ((INT64)State.RelativeMovementX);
        UiScaleX = MultS64x64 (UiScaleX, (INT64)mMaxPointerResolutionX);
        UiScaleX = MultS64x64 (UiScaleX, mPointerSpeedMul);
        UiScaleX = DivS64x64Remainder (UiScaleX, mPointerSpeedDiv, NULL);
 
        UiScaleY = InternalGetUiScaleData ((INT64)State.RelativeMovementY);
        UiScaleY = MultS64x64 (UiScaleY, (INT64)mMaxPointerResolutionY);
        UiScaleY = MultS64x64 (UiScaleY, mPointerSpeedMul);
        UiScaleY = DivS64x64Remainder (UiScaleY, mPointerSpeedDiv, NULL);
 
        if (SimplePointer->Mode->ResolutionX > 0) {
          UiScaleX = DivS64x64Remainder (
                       UiScaleX,
                       (INT64)SimplePointer->Mode->ResolutionX,
                       NULL
                       );
        }
 
        if (SimplePointer->Mode->ResolutionY > 0) {
          UiScaleY = DivS64x64Remainder (
                       UiScaleY,
                       (INT64)SimplePointer->Mode->ResolutionY,
                       NULL
                       );
        }
 
        //
        // CHANGE: Fix maximum coordinates.
        //
        ScaledX        = mPointerRawX + UiScaleX;
        MaxRawPointerX = MultU64x64 (
                           mResolution.Horizontal - 1,
                           mMaxPointerResolutionX
                           );
        if (ScaledX > MaxRawPointerX) {
          ScaledX = MaxRawPointerX;
        } else if (ScaledX < 0) {
          ScaledX = 0;
        }
 
        mPointerRawX = (UINT64)ScaledX;
 
        ScaledY        = mPointerRawY + UiScaleY;
        MaxRawPointerY = MultS64x64 (
                           mResolution.Vertical - 1,
                           (INT64)mMaxPointerResolutionY
                           );
        if (ScaledY > MaxRawPointerY) {
          ScaledY = MaxRawPointerY;
        } else if (ScaledY < 0) {
          ScaledY = 0;
        }
 
        mPointerRawY = (UINT64)ScaledY;
 
        ScaledX = DivU64x64Remainder (
                    ScaledX,
                    mMaxPointerResolutionX,
                    NULL
                    );
 
        ScaledY = DivS64x64Remainder (
                    ScaledY,
                    (INT64)mMaxPointerResolutionY,
                    NULL
                    );
 
        NewPosition.Horizontal = (INT32)ScaledX;
        NewPosition.Vertical   = (INT32)ScaledY;
 
        if (  (mCursorPosition.Horizontal != NewPosition.Horizontal)
           || (mCursorPosition.Vertical != NewPosition.Vertical))
        {
          CopyMem (
            &mCursorPosition,
            &NewPosition,
            sizeof (mCursorPosition)
            );
 
          mMouseMoved = TRUE;
        }
 
        mLeftButtonInfo.PreviousButton  = mLeftButtonInfo.CurrentButton;
        mLeftButtonInfo.CurrentButton   = State.LeftButton;
        mRightButtonInfo.PreviousButton = mRightButtonInfo.CurrentButton;
        mRightButtonInfo.CurrentButton  = State.RightButton;
        CommonStatus                    = Status;
      }
    }
 
    InternalHandleButtonInteraction (CommonStatus, &mLeftButtonInfo, Modifiers);
    InternalHandleButtonInteraction (CommonStatus, &mRightButtonInfo, Modifiers);
 
    InternalHandleDwellClicking (Modifiers);
  }
 
  if (EFI_ERROR (CommonStatus)) {
    if (CommonStatus == EFI_UNSUPPORTED) {
      EventLibCancelEvent (mSimplePointerPollEvent);
 
      mSimplePointerPollEvent = NULL;
    }
  } else if (mMouseMoved != FALSE) {
    mMouseMoved = FALSE;
 
    EventData.PointerEventType = APPLE_EVENT_TYPE_MOUSE_MOVED;
    Information                = EventCreateAppleEventQueueInfo (
                                   EventData,
                                   APPLE_EVENT_TYPE_MOUSE_MOVED,
                                   &mCursorPosition,
                                   Modifiers
                                   );
 
    if (Information != NULL) {
      EventAddEventToQueue (Information);
    }
  }
 
  //
  // This code is here to workaround very slow mouse polling performance on some computers,
  // like most of Dell laptops (one of the worst examples is Dell Latitude 3330 with ~50 ms).
  // Even if we try all the hacks we could make this code approximately only twice faster,
  // which is still far from enough. The event system on these laptops is pretty broken,
  // and even adding gBS->CheckEvent prior to GetState almost does not reduce the time spent.
  //
  if ((mSimplePointerPollEvent != NULL) && (mSimplePointerPollTime < mSimplePointerMaxPollTime)) {
    EndTime = GetPerformanceCounter ();
    if (StartTime > EndTime) {
      EndTime = StartTime;
    }
 
    EndTime = GetTimeInNanoSecond (EndTime - StartTime);
    // Maximum time allowed in this function is half the interval plus some margin (0.55 * 100ns)
    if (EndTime > mSimplePointerPollTime * 55) {
      ClickTemp       = mSimplePointerPollTime * mMaximumClickDuration;
      DoubleClickTemp = mSimplePointerPollTime * mMaximumDoubleClickSpeed;
 
      SimplePointerPollTime = DivU64x32 (EndTime, 50);
      if (SimplePointerPollTime <= mSimplePointerMaxPollTime) {
        mSimplePointerPollTime = (UINT32)SimplePointerPollTime;
      } else {
        mSimplePointerPollTime = mSimplePointerMaxPollTime;
      }
 
      mMaximumClickDuration    = (UINT16)(ClickTemp / mSimplePointerPollTime);
      mMaximumDoubleClickSpeed = (UINT16)(DoubleClickTemp / mSimplePointerPollTime);
 
      gBS->SetTimer (mSimplePointerPollEvent, TimerPeriodic, mSimplePointerPollTime);
    }
  }
}
 
// EventCreateSimplePointerPollEvent
EFI_STATUS
EventCreateSimplePointerPollEvent (
  VOID
  )
{
  EFI_STATUS  Status;
  UINTN       Index;
 
  DEBUG ((DEBUG_VERBOSE, "EventCreateSimplePointerPollEvent\n"));
 
  InternalRemoveUninstalledInstances (
    &mPointerProtocols,
    &mNumberOfPointerProtocols,
    &gEfiSimplePointerProtocolGuid
    );
 
  for (Index = 0; Index < mNumberOfPointerProtocols; ++Index) {
    mPointerProtocols[Index].Interface->Reset (
                                          mPointerProtocols[Index].Interface,
                                          FALSE
                                          );
  }
 
  InternalGetScreenResolution ();
  ZeroMem (&mCursorPosition, sizeof (mCursorPosition));
 
  mSimplePointerPollTime  = mSimplePointerMinPollTime;
  mSimplePointerPollEvent = EventLibCreateNotifyTimerEvent (
                              InternalSimplePointerPollNotifyFunction,
                              NULL,
                              mSimplePointerPollTime,
                              TRUE
                              );
 
  Status = EFI_OUT_OF_RESOURCES;
 
  if (mSimplePointerPollEvent != NULL) {
    mRightButtonInfo.CurrentButton  = FALSE;
    mLeftButtonInfo.CurrentButton   = FALSE;
    mRightButtonInfo.PreviousButton = FALSE;
    mLeftButtonInfo.PreviousButton  = FALSE;
 
    Status = EFI_SUCCESS;
  }
 
  return Status;
}
 
// EventCancelSimplePointerPollEvent
VOID
EventCancelSimplePointerPollEvent (
  VOID
  )
{
  DEBUG ((DEBUG_VERBOSE, "EventCancelSimplePointerPollEvent\n"));
 
  EventLibCancelEvent (mSimplePointerPollEvent);
 
  mSimplePointerPollEvent = NULL;
}
 
// EventSetCursorPositionImpl
EFI_STATUS
EventSetCursorPositionImpl (
  IN DIMENSION  *Position
  )
{
  EFI_STATUS  Status;
 
  DEBUG ((DEBUG_VERBOSE, "EventSetCursorPositionImpl\n"));
 
  InternalGetScreenResolution ();
 
  Status = EFI_INVALID_PARAMETER;
 
  //
  // Apple did not check for negatives here.
  //
 
  if (  (Position->Horizontal >= 0) && (Position->Vertical >= 0)
     && (Position->Horizontal < mResolution.Horizontal)
     && (Position->Vertical < mResolution.Vertical))
  {
    mCursorPosition.Horizontal = Position->Horizontal;
    mCursorPosition.Vertical   = Position->Vertical;
    mPointerRawX               = MultS64x64 (
                                   mCursorPosition.Horizontal,
                                   (INT64)mMaxPointerResolutionX
                                   );
    mPointerRawY = MultS64x64 (
                     mCursorPosition.Vertical,
                     (INT64)mMaxPointerResolutionY
                     );
    Status = EFI_SUCCESS;
  }
 
  return Status;
}