zoukankan      html  css  js  c++  java
  • 一种居于JvMouseGesture.pas的鼠标手势系统

    尽管高版本的Delphi已经提供强悍的手势功能,也非常好用,我还是没能用上,所以自己结合实际,参阅多个组件源码,改造了JvMouseGesture.pas单元,弄出一个实用的鼠标手势管理功能,记在这里,以免硬盘坏了,又要重来。

    改造过的JvMouseGesture.pas单元代码:

    unit JvMouseGesture;
    
    {$I jvcl.inc}
    
    interface
    
    uses
      {$IFDEF UNITVERSIONING}
      JclUnitVersioning,
      {$ENDIF UNITVERSIONING}
      SysUtils, Classes, Controls, Windows, Messages,Forms,Graphics,
      JvComponentBase;
    
    type
      { Description
        Defines, whether or not the hook will be activated automatically or not.
      }
      TJvActivationMode = (amAppStart, amManual);
    
      { Description
        Defines a complex gesture (two or more letters event)
    
      }
      TOnMouseGestureCustomInterpretation = procedure(Sender: TObject;const AGesture: string) of object;
    
      { Description
        This class implements the basic interpreter. It can be used
        to enhance single components, too. E.g., if you want to
        enable a grid with gesture feature. For this purpose you have
        to do 4 steps:
    
        1) Fill the "OnMouseDown" event with code like
    
    
        <CODE>
          if Button = mbRight then
            JvMouseGesture1.StartMouseGesture(x,y);
        </CODE>
    
    
        2) Fill the OnMouseMove event with something like
    
    
        <CODE>
          if JvMouseGesture1.TrailActive then
            JvMouseGesture1.TrailMouseGesture(x,y);
        </CODE>
    
    
        3) Now fill the OnMouseUp event
    
    
        <CODE>
          if JvMouseGesture1.TrailActive then
            JvMouseGesture1.EndMouseGesture;
        </CODE>
    
    
        4) Last but not least fill components
    
        OnJvMouseGestureCustomInterpretation
    
        XOR
    
        OnJvMouseGesture<xyz>
    
        event
    
        Note:
    
    
        If CustomInterpreation is filled the other events are not
        fired!
    
        See Also
    
        TJvMouseGestureHook
      }
      {$IFDEF RTL230_UP}
      [ComponentPlatformsAttribute(pidWin32 or pidWin64 or pidOSX32)]
      {$ENDIF RTL230_UP}
      TJvMouseGesture = class(TJvComponent)
      private
        FForm: TForm;
        FActive: Boolean;
        FHided: Boolean;
        FTrailX: Integer;
        FTrailY: Integer;
        FTrailLength: Integer;
        FTrailActive: Boolean;
        FTrailStartTime: TDateTime;
        FdTolerance: Integer;
        FTrailLimit: Integer;
        FTrackWidth: Cardinal;
        FTrackColor: TColor;
        FDelay: Integer;
        FTrailInterval: Integer;
        FGrid: Integer; // tolerance for diagonal movement. See TrailMouseGesture
        FGridHalf: Integer; // half of grid, needed for performance
        FLastPushed: String;
        FGesture: string;
        FGestureList: TStringList;
        FLastWndProc: TWndMethod;
    
        FOnMouseGestureRight: TNotifyEvent;
        FOnMouseGestureLeft: TNotifyEvent;
        FOnMouseGestureUp: TNotifyEvent;
        FOnMouseGestureDown: TNotifyEvent;
        FOnMouseGestureLeftLowerEdge: TNotifyEvent;
        FOnMouseGestureRightUpperEdge: TNotifyEvent;
        FOnMouseGestureLeftUpperEdge: TNotifyEvent;
        FOnMouseGestureRightLowerEdge: TNotifyEvent;
        FOnMouseGestureCancelled: TNotifyEvent;
        FOnTrailingMouseGesture: TNotifyEvent;
        FOnMouseGestureCustomInterpretation: TOnMouseGestureCustomInterpretation;
        { Description
          Adds a detected sub gesture to gesture string
        }
        procedure AddGestureChar(AChar: String);
        procedure SetTrailLimit(const Value: Integer);
        procedure SetTrailInterval(const Value: Integer);
        procedure SetDelay(const Value: Integer);
        procedure SetGrid(const Value: Integer);
        procedure SetTrackColor(const Value: TColor);
        { Description
          Loads the known gestures for matching events
    
          Note:
          In this version only evaluation of simple mouse gestures are implemented
        }
        procedure LoadGestureTable;
        { Description
          Standard setter method for Active
        }
        procedure SetActive(const Value: Boolean);
        procedure Hide; // 内部函数,用来隐藏当前窗体(Internal function to hide the form)
        procedure AdjustSize;
        procedure WndProc(var Msg: TMessage);
      protected
        procedure DoMouseGestureRight; virtual;
        procedure DoMouseGestureLeft; virtual;
        procedure DoMouseGestureUp; virtual;
        procedure DoMouseGestureDown; virtual;
        procedure DoMouseGestureLeftLowerEdge; virtual;
        procedure DoMouseGestureRightUpperEdge; virtual;
        procedure DoMouseGestureLeftUpperEdge; virtual;
        procedure DoMouseGestureRightLowerEdge; virtual;
        procedure DoMouseGestureCancelled; virtual;
        procedure DoOnTrailingMouseGesture; virtual;
        function DoMouseGestureCustomInterpretation(const AGesture: string): Boolean; virtual;
      public
        { Description
          Standard constructor
        }
        constructor Create(AOwner: TComponent); override;
        { Description
          Standard destructor
        }
        destructor Destroy; override;
        { Description
          Starts the mouse gesture interpretation
    
          Parameters:
          AMouseX: X coordinate of mouse cursor
          AMouseY: Y coordinate of mouse cursor
        }
        procedure StartMouseGesture(AMouseX, AMouseY: Integer);
        { Description
          Continues the mouse gesture interpretation during mouse move
    
          Parameters:
          AMouseX: X coordinate of mouse cursor
          AMouseY: Y coordinate of mouse cursor
        }
        procedure TrailMouseGesture(AMouseX, AMouseY: Integer);
        { Description
          Ends the mouse gesture interpretation and fires an event if a gesture
          was found
        }
        procedure EndMouseGesture(AMouseX, AMouseY: Integer);
        { Description
          The actual length of trail (not of gesture string!!!)
        }
        procedure DrawGestureText(GText:String);
        property TrailLength: Integer read FTrailLength;
        { Description
          TRUE, if in detection, otherwise FALSE
        }
        property TrailActive: Boolean read FTrailActive;
        { Description
          The gesture string. For string content see description of unit.
        }
        property Gesture: string read FGesture;
      published
        { Description
          The maximum length of trail (not of gesture string!!!)
          Normally never been changed
        }
        property TrailLimit: Integer read FTrailLimit write SetTrailLimit;
        { Description
          Trail interval
          Normally never been changed
        }
        property TrailInterval: Integer read FTrailInterval write SetTrailInterval;
        { Description
          Grid size for detection
          Normally never been changed
        }
        property Grid: Integer read FGrid write SetGrid;
        { Description
          The maximum delay before cancelling a gesture
          Normally never been changed
        }
        property Delay: Integer read FDelay write SetDelay;
        { Description
          TRUE if component is active, otherwise FALSE
        }
        property Active: Boolean read FActive write SetActive;
        { Description
          Event for own evaluation of detected gesture. If this event is used all
          others will be ignored!
        }
        property TrackColor
            : TColor read FTrackColor write SetTrackColor default clRed;
        // 轨迹宽度,默认5px
        property TrackWidth: Cardinal read FTrackWidth write FTrackWidth default 5;
        property OnMouseGestureCustomInterpretation: TOnMouseGestureCustomInterpretation read
          FOnMouseGestureCustomInterpretation write FOnMouseGestureCustomInterpretation;
        { Description
          Event for a simple MOUSE UP gesture
        }
        property OnMouseGestureCancelled: TNotifyEvent read FOnMouseGestureCancelled write FOnMouseGestureCancelled;
        property OnMouseGestureUp: TNotifyEvent read FOnMouseGestureUp write FOnMouseGestureUp;
        { Description
          Event for a simple MOUSE DOWN gesture
        }
        property OnMouseGestureDown: TNotifyEvent read FOnMouseGestureDown write FOnMouseGestureDown;
        { Description
          Event for a simple MOUSE LEFT gesture
        }
        property OnMouseGestureLeft: TNotifyEvent read FOnMouseGestureLeft write FOnMouseGestureLeft;
        { Description
          Event for a simple MOUSE RIGHT gesture
        }
        property OnMouseGestureRight: TNotifyEvent read FOnMouseGestureRight write FOnMouseGestureRight;
        { Description
          Event for a simple diagonally MOUSE LEFT LOWER EDGE (point 1 in grid) gesture
        }
        property OnMouseGestureLeftLowerEdge: TNotifyEvent read FOnMouseGestureLeftLowerEdge write
          FOnMouseGestureLeftLowerEdge;
        { Description
          Event for a simple diagonally MOUSE RIGHT LOWER EDGE (point 3 in grid) gesture
        }
        property OnMouseGestureRightLowerEdge: TNotifyEvent read FOnMouseGestureRightLowerEdge write
          FOnMouseGestureRightLowerEdge;
        { Description
          Event for a simple diagonally MOUSE LEFT UPPER EDGE (point 7 in grid) gesture
        }
        property OnMouseGestureLeftUpperEdge: TNotifyEvent read FOnMouseGestureLeftUpperEdge write
          FOnMouseGestureLeftUpperEdge;
        { Description
          Event for a simple diagonally MOUSE RIGHT UPPER EDGE (point 9 in grid) gesture
        }
        property OnMouseGestureRightUpperEdge: TNotifyEvent read FOnMouseGestureRightUpperEdge write
          FOnMouseGestureRightUpperEdge;
        property OnTrailingMouseGesture: TNotifyEvent  read FOnTrailingMouseGesture write FOnTrailingMouseGesture;
      end;
    
      { Description
        This class implements a application wide mouse hook for mouse gestures.
        Programmers get only one event for a detected mouse gesture:
    
        OnMouseGestureCustomInterpretation
    
        See Also
        TJvMouseGesture
      }
      {$IFDEF RTL230_UP}
      [ComponentPlatformsAttribute(pidWin32 or pidWin64 or pidOSX32)]
      {$ENDIF RTL230_UP}
      TJvMouseGestureHook = class(TJvComponent)
      private
        FTrailLimit: Integer;
        FTrackWidth: Cardinal;
        FTrackColor: TColor;
        FDelay: Integer;
        FTrailInterval: Integer;
        FGrid: Integer;
        { Description
          True if a hook is installed
        }
        FHookInstalled: Boolean;
        { Description
          Field for hook handle
        }
        FCurrentHook: HHook;
        { Description
          Field for method pointer
        }
        FOnMouseGestureCustomInterpretation: TOnMouseGestureCustomInterpretation;
        { Description
          Field for active state of component
        }
        FOnCustomTrailingMouseGesture: TNotifyEvent;
        FActive: Boolean;
        { Description
          Field for mouse key
        }
        FMouseButton: TMouseButton;
        { Description
          Field for activation mode
        }
        FActivationMode: TJvActivationMode;
        { Description
          Standard setter method for evaluation of detected gesture
        }
        { Description
          Standard setter method for Active
        }
        procedure SetActive(const Value: Boolean);
        { Description
          Standard setter method for MouseButton
        }
        procedure SetMouseButton(const Value: TMouseButton);
        { Description
          Standard setter method for ActivationMode
        }
        procedure SetTrailLimit(const Value: Integer);
        procedure SetTrailInterval(const Value: Integer);
        procedure SetDelay(const Value: Integer);
        procedure SetGrid(const Value: Integer);
        procedure SetTrackColor(const Value: TColor);
        procedure SetTrackWidth(const Value: Cardinal);
        procedure SetActivationMode(const Value: TJvActivationMode);
        procedure SetMouseGestureCustomInterpretation(const Value: TOnMouseGestureCustomInterpretation);
        procedure SetTrailingMouseGesture(const Value: TNotifyEvent);
        function GetMouseGesture: TJvMouseGesture;
      protected
        { Description
          Create the hook. Maybe used in a later version as a new constructor
          to enable system wide hooks ...
        }
        procedure CreateForThreadOrSystem(AOwner: TComponent; ADwThreadID: Cardinal);
        function DoMouseGestureCustomInterpretation(const AGesture: string): Boolean; virtual;
      public
        { Description
          Standard constructor
        }
        constructor Create(AOwner: TComponent); override;
        { Description
          Standard destructor
        }
        destructor Destroy; override;
        { Description
          TRUE if hook was installed successfully
        }
        property HookInstalled: Boolean read FHookInstalled; //True if a hook is installed
        { Description
          handle of hook
        }
        property CurrentHook: HHook read FCurrentHook; //contains the handle of the currently installed hook
        property MouseGesture: TJvMouseGesture read GetMouseGesture;
      published
        property TrailLimit:Integer  read FTrailLimit write SetTrailLimit;
        property TrackWidth:Cardinal  read FTrackWidth write SetTrackWidth;
        property TrackColor:TColor  read FTrackColor write SetTrackColor;
        property Delay:Integer  read FDelay write SetDelay;
        property TrailInterval:Integer  read FTrailInterval write SetTrailInterval;
        property Grid:Integer  read FGrid write SetGrid;
    
        { Description
          TRUE if component is active, otherwise FALSE. Can be changed during runtime
        }
        property Active: Boolean read FActive write SetActive;
        { Description
          If property is set to <code>JvOnAppStart</code> then component will be
          activated on start of application, with <code>JvManually</code> you
          have to activate detection on your own
        }
        property ActivationMode: TJvActivationMode read FActivationMode write SetActivationMode;
        { Description
          Set the mouse key to be used for start/stop gesture
    
          See Also
          TMouseButton
        }
        property MouseButton: TMouseButton read FMouseButton write SetMouseButton default mbRight;
        { Description
          Set the event to be executed if a gesture will be detected
        }
        property OnMouseGestureCustomInterpretation: TOnMouseGestureCustomInterpretation read FOnMouseGestureCustomInterpretation write SetMouseGestureCustomInterpretation;
        property OnCustomTrailingMouseGesture: TNotifyEvent  read FOnCustomTrailingMouseGesture write SetTrailingMouseGesture;
      end;
    
    
      { Description
        Hook call back function.
        DO NOT USE EXTERN!
      }
    function JvMouseGestureHook(Code: Integer; wParam: Word; lParam: Longword): Longword; stdcall;
    
    
    
    {$IFDEF UNITVERSIONING}
    const
      UnitVersioning: TUnitVersionInfo = (
        RCSfile: '$URL: https://jvcl.svn.sourceforge.net/svnroot/jvcl/branches/JVCL3_47_PREPARATION/run/JvMouseGesture.pas $';
        Revision: '$Revision: 13104 $';
        Date: '$Date: 2011-09-07 08:50:43 +0200 (mer. 07 sept. 2011) $';
        LogPath: 'JVCL
    un'
      );
    {$ENDIF UNITVERSIONING}
    
    implementation
    
    uses
      JvResources, JvTypes;
    
    const
      JVMG_LEFT = 0;
      JVMG_RIGHT = 1;
      JVMG_UP = 2;
      JVMG_DOWN = 3;
      JVMG_LEFTUPPER = 4;
      JVMG_RIGHTUPPER = 5;
      JVMG_LEFTLOWER = 6;
      JVMG_RIGHTLOWER = 7;
    
    var
      { Description
        Object pointer to interpreter class used by hook
      }
      JvMouseGestureInterpreter: TJvMouseGesture;
      { Description
        Some global vars to be accessed by call back function ...
      }
      JvMouseGestureHookAlreadyInstalled: Boolean = False;
      //<combine JvMouseGestureHookAlreadyInstalled>
      JvMouseGestureHookActive: Boolean = False;
      //<combine JvMouseGestureHookAlreadyInstalled>
      JvMouseButtonDown: Cardinal = WM_RBUTTONDOWN;
      //<combine JvMouseGestureHookAlreadyInstalled>
      JvMouseButtonUp: Cardinal = WM_RBUTTONUP;
    
      JvCurrentHook: HHook = 0; //contains the handle of the currently installed hook
    
    //=== { TJvMouseGesture } ====================================================
    
    constructor TJvMouseGesture.Create(AOwner: TComponent);
    begin
      inherited Create(AOwner);
      FGestureList := TStringList.Create;
      FGestureList.Sorted := True;
    
      FDelay := 500;
      FTrailLimit := 1000;
      FTrailInterval := 2;
      FGrid := 15;
      FTrackColor := clRed;
      FTrackWidth := 5;
      FGridHalf := FGrid div 2;
      FTrailActive := False;
      FdTolerance := 75; // tolerance for diagonal movement. see processCoordinates()
      begin
        FForm := TForm.Create(Self);
        FForm.TransparentColor := True;
        FForm.TransparentColorValue := clBlack;
        FForm.BorderStyle := bsNone;
        FForm.FormStyle := fsStayOnTop;
        FForm.DoubleBuffered := True;
        FForm.Color := clBlack;
        FLastWndProc := FForm.WindowProc;
        FForm.WindowProc := WndProc;
        AdjustSize;
        FForm.Canvas.Brush.Color := FForm.TransparentColorValue;
        FForm.Canvas.FillRect(FForm.ClientRect);
        ShowWindow(FForm.Handle,SW_SHOWNOACTIVATE);
        Hide;
        FHided := True;
      end;
      LoadGestureTable;
    
      FActive := not (csDesigning in ComponentState);
    end;
    
    destructor TJvMouseGesture.Destroy;
    begin
      FTrailActive := False;
      FreeAndNil(FGestureList);
      FForm.free;
      inherited Destroy;
    end;
    
    procedure TJvMouseGesture.LoadGestureTable;
    begin
      with FGestureList do
      begin
        AddObject('向左', TObject(JVMG_LEFT));
        AddObject('向右', TObject(JVMG_RIGHT));
        AddObject('向上', TObject(JVMG_UP));
        AddObject('向下', TObject(JVMG_DOWN));
        AddObject('向左斜下', TObject(JVMG_LEFTLOWER));
        AddObject('向右斜下', TObject(JVMG_RIGHTLOWER));
        AddObject('向左斜上', TObject(JVMG_LEFTUPPER));
        AddObject('向右斜上', TObject(JVMG_RIGHTUPPER));
      end;
    end;
    
    procedure TJvMouseGesture.SetActive(const Value: Boolean);
    begin
      if csDesigning in ComponentState then
        FActive := False
      else
        FActive := Value;
    end;
    
    procedure TJvMouseGesture.Hide;
    begin
      if not FHided then
      begin
        FForm.Canvas.Brush.Color := FForm.TransparentColorValue;
        FForm.Canvas.FillRect(FForm.ClientRect);
        FHided := True;
      end;
    end;
    
    procedure TJvMouseGesture.AdjustSize;
    begin
      if not (csDesigning in ComponentState) then
      FForm.SetBounds(Screen.DesktopLeft, Screen.DesktopTop, Screen.DesktopWidth,
        Screen.DesktopWidth)
      else FForm.SetBounds(Screen.DesktopLeft, Screen.DesktopTop, 0,
           0);
    end;
    
    procedure TJvMouseGesture.WndProc(var Msg: TMessage);
    begin
      if Msg.Msg = WM_NCHITTEST then
        Msg.Result := HTTRANSPARENT
      else if Msg.Msg = (WM_APP + 1) then
        AdjustSize
      else if Msg.Msg = (WM_APP + 2) then
      begin
    
      end
      else
      begin
        FLastWndProc(Msg);
        if Msg.Msg = WM_DISPLAYCHANGE then
          PostMessage(FForm.Handle, WM_APP + 1, 0, 0)
        else if Msg.Msg = WM_WINDOWPOSCHANGED then //保持窗口在最前,以保证能够覆盖绘制轨迹,
          PostMessage(FForm.Handle, WM_APP + 2, 0, 0);
      end;
    end;
    
    procedure TJvMouseGesture.SetTrailLimit(const Value: Integer);
    begin
      FTrailLimit := Value;
      if (FTrailLimit < 100) or (FTrailLimit > 10000) then
        FTrailLimit := 1000;
    end;
    
    procedure TJvMouseGesture.SetTrailInterval(const Value: Integer);
    begin
      FTrailInterval := Value;
      if (FTrailInterval < 1) or (FTrailInterval > 100) then
        FTrailInterval := 2;
    end;
    
    procedure TJvMouseGesture.SetDelay(const Value: Integer);
    begin
      FDelay := Value;
      if FDelay < 500 then
        FDelay := 500;
    end;
    
    procedure TJvMouseGesture.SetGrid(const Value: Integer);
    begin
      FGrid := Value;
      if (FGrid < 10) or (FGrid > 500) then
        FGrid := 15;
    
      FGridHalf := FGrid div 2;
    end;
    
    procedure TJvMouseGesture.SetTrackColor(const Value: TColor);
    begin
      if FTrackColor <> Value then
      begin
        FTrackColor := Value;
        if FTrackColor = clBlack then
          FForm.Color := clWhite
        else
          FForm.Color := clBlack;
        FForm.TransparentColorValue := FForm.Color;
      end;
    end;
    
    procedure TJvMouseGesture.AddGestureChar(AChar: String);
    begin
      if AChar <> FLastPushed then
      begin
        FGesture := FGesture +''+ AChar;
        FLastPushed := AChar;
      end;
    end;
    
    procedure TJvMouseGesture.StartMouseGesture(AMouseX, AMouseY: Integer);
    begin
      if not FActive then
        Exit;
      FForm.Show;
      FForm.BringToFront;
      FForm.Canvas.MoveTo(AMouseX, AMouseY);
      FLastPushed := #0;
      FGesture := '';
      FTrailActive := True;
      FTrailLength := 0;
      FTrailX := AMouseX;
      FTrailY := AMouseY;
      FTrailStartTime := now;
      FHided:=False;
    end;
    
    procedure TJvMouseGesture.TrailMouseGesture(AMouseX, AMouseY: Integer);
    var
      locX: Integer;
      locY: Integer;
      x_dir: Integer;
      y_dir: Integer;
      tolerancePercent: Double;
      x_divide_y: Double;
      y_divide_x: Double;
    
      function InBetween(AValue, AMin, AMax: Double): Boolean;
      begin
        Result := (AValue >= AMin) and (AValue <= AMax);
      end;
    
    begin
      if not FActive then
        Exit;
    
      if (not FTrailActive) or (FTrailLength > FTrailLimit) then
      begin
        FTrailActive := False;
        Exit;
      end;
    
      try
        x_dir := AMouseX - FTrailX;
        y_dir := AMouseY - FTrailY;
        locX := abs(x_dir);
        locY := abs(y_dir);
    
        // process each half-grid
        if (locX >= FGridHalf) or (locY >= FGridHalf) then
        begin
          // diagonal movement:
          // dTolerance = 75 means that a movement is recognized as diagonal when
          // x/y or y/x is between 0.25 and 1
          if (GetTopWindow(0) <> FForm.Handle) and Application.Active then
          FForm.BringToFront;
          FForm.Canvas.Pen.Color := FTrackColor;
          FForm.Canvas.Pen.Width := FTrackWidth;
          FForm.Canvas.LineTo(AMouseX, AMouseY);
    
          tolerancePercent := 1 - FdTolerance / 100;
          if locY <> 0 then
            x_divide_y := locX / locY
          else
            x_divide_y := 0;
          if locX <> 0 then
            y_divide_x := locY / locX
          else
            y_divide_x := 0;
          if (FdTolerance <> 0) and
            (InBetween(x_divide_y, tolerancePercent, 1) or
            InBetween(y_divide_x, tolerancePercent, 1)) then
          begin
            if (x_dir < -9) and (y_dir > 9) then
            begin
              AddGestureChar('向左斜下');
            end
            else
            begin
              if (x_dir > 9) and (y_dir > 9) then
                AddGestureChar('向右斜下')
              else
              begin
                if (x_dir < -9) and (y_dir < -9) then
                  AddGestureChar('向左斜上')
                else
                begin
                  if (x_dir > 9) and (y_dir < -9) then
                    AddGestureChar('向右斜上');
                end;
              end;
            end;
          end // of diaognal
          else
          begin
            // horizontal movement:
            if locX > locY then
            begin
              if x_dir > 0 then
                AddGestureChar('向右')
              else
              begin
                if x_dir < 0 then
                  AddGestureChar('向左');
              end;
            end
            else
            begin
              // vertical movement:
              if locX < locY then
              begin
                if y_dir > 0 then
                  AddGestureChar('向下')
                else
                begin
                  if y_dir < 0 then
                    AddGestureChar('向上');
                end;
              end;
            end;
          end;
        end; // of half grid
      finally
        FTrailX := AMouseX;
        FTrailY := AMouseY;
      end;
      DoOnTrailingMouseGesture;
    end;
    
    procedure TJvMouseGesture.DrawGestureText(GText:String);
    begin
      FForm.Canvas.TextOut(300,300,GText);
    end;
    
    procedure TJvMouseGesture.EndMouseGesture(AMouseX, AMouseY: Integer);
    var
      Index: Integer;
    begin
      Hide;
      if not FActive then
        Exit;
    
      FTrailActive := False;
    
      if FGesture = '' then
      begin
        DoMouseGestureCancelled;
        Exit;
      end;
    
      // check for custom interpretation first
      if DoMouseGestureCustomInterpretation(FGesture) then
        Exit
      else Hide;
    
      // if no custom interpretation is implemented we chaeck for known gestures
      // and matching events
      // CASE indexes are stored sequence independent. So we have to find gesture
      // first and get CASE INDEX stored as TObject in Object property. It's a
      // simple trick, but works fine ...
      Index := FGestureList.IndexOf(FGesture);
      if Index > -1 then
        Index := Integer(FGestureList.Objects[Index]);
      case Index of
        JVMG_LEFT:
          begin
            DoMouseGestureLeft;
          end;
        JVMG_RIGHT:
          begin
            DoMouseGestureRight;
          end;
        JVMG_UP:
          begin
            DoMouseGestureUp;
          end;
        JVMG_DOWN:
          begin
            DoMouseGestureDown;
          end;
        JVMG_LEFTLOWER:
          begin
            DoMouseGestureLeftLowerEdge;
          end;
        JVMG_RIGHTLOWER:
          begin
            DoMouseGestureRightLowerEdge;
          end;
        JVMG_LEFTUPPER:
          begin
            DoMouseGestureLeftUpperEdge;
          end;
        JVMG_RIGHTUPPER:
          begin
            DoMouseGestureRightUpperEdge;
          end;
      end;
    end;
    
    procedure TJvMouseGesture.DoMouseGestureCancelled;
    begin
      if Assigned(FOnMouseGestureCancelled) then
        FOnMouseGestureCancelled(Self);
    end;
    
    procedure TJvMouseGesture.DoOnTrailingMouseGesture;
    begin
      if Assigned(FOnTrailingMouseGesture) then
        FOnTrailingMouseGesture(Self);
    end;
    
    function TJvMouseGesture.DoMouseGestureCustomInterpretation(const AGesture: string): Boolean;
    begin
       Result := Assigned(FOnMouseGestureCustomInterpretation);
       if Result then
       begin
          FOnMouseGestureCustomInterpretation(Self,FGesture);
       end;
       Hide;
    end;
    
    procedure TJvMouseGesture.DoMouseGestureDown;
    begin
      if Assigned(FOnMouseGestureDown) then
        FOnMouseGestureDown(Self);
    end;
    
    procedure TJvMouseGesture.DoMouseGestureLeft;
    begin
      if Assigned(FOnMouseGestureLeft) then
        FOnMouseGestureLeft(Self);
    end;
    
    procedure TJvMouseGesture.DoMouseGestureLeftLowerEdge;
    begin
      if Assigned(FOnMouseGestureLeftLowerEdge) then
        FOnMouseGestureLeftLowerEdge(Self);
    end;
    
    procedure TJvMouseGesture.DoMouseGestureLeftUpperEdge;
    begin
      if Assigned(FOnMouseGestureLeftUpperEdge) then
        FOnMouseGestureLeftUpperEdge(Self);
    end;
    
    procedure TJvMouseGesture.DoMouseGestureRight;
    begin
      if Assigned(FOnMouseGestureRight) then
        FOnMouseGestureRight(Self);
    end;
    
    procedure TJvMouseGesture.DoMouseGestureRightLowerEdge;
    begin
      if Assigned(FOnMouseGestureRightLowerEdge) then
        FOnMouseGestureRightLowerEdge(Self);
    end;
    
    procedure TJvMouseGesture.DoMouseGestureRightUpperEdge;
    begin
      if Assigned(FOnMouseGestureRightUpperEdge) then
        FOnMouseGestureRightUpperEdge(Self);
    end;
    
    procedure TJvMouseGesture.DoMouseGestureUp;
    begin
      if Assigned(FOnMouseGestureUp) then
        FOnMouseGestureUp(Self);
    end;
    
    //=== { TJvMouseGestureHook } ================================================
    
    constructor TJvMouseGestureHook.Create(AOwner: TComponent);
    begin
      inherited Create(AOwner);
      FDelay := 500;
      FTrailLimit := 1000;
      FTrailInterval := 2;
      FGrid := 15;
      FTrackColor := clRed;
      FTrackWidth := 5;
      CreateForThreadOrSystem(AOwner, MainThreadID); // hook for complete application
      JvMouseGestureInterpreter.Delay:=FDelay;
      JvMouseGestureInterpreter.Grid:=FGrid;
      JvMouseGestureInterpreter.TrackWidth:=FTrackWidth;
      JvMouseGestureInterpreter.TrackColor:=FTrackColor;
      JvMouseGestureInterpreter.TrailLimit:=FTrailLimit;
      JvMouseGestureInterpreter.TrailInterval:=FTrailInterval;
    end;
    
    destructor TJvMouseGestureHook.Destroy;
    
    begin
      FreeAndNil(JvMouseGestureInterpreter);
    
      if JvMouseGestureHookAlreadyInstalled then
        JvMouseGestureHookAlreadyInstalled := UnhookWindowsHookEx(JvCurrentHook);
      inherited Destroy;
    end;
    
    procedure TJvMouseGestureHook.SetTrailLimit(const Value: Integer);
    begin
      FTrailLimit := Value;
      if (FTrailLimit < 100) or (FTrailLimit > 10000) then
        FTrailLimit := 1000;
      JvMouseGestureInterpreter.TrailLimit:=FTrailLimit;
    end;
    
    procedure TJvMouseGestureHook.SetTrailInterval(const Value: Integer);
    begin
      FTrailInterval := Value;
      if (FTrailInterval < 1) or (FTrailInterval > 100) then
        FTrailInterval := 2;
      JvMouseGestureInterpreter.TrailInterval:=FTrailInterval;
    end;
    
    procedure TJvMouseGestureHook.SetDelay(const Value: Integer);
    begin
      FDelay := Value;
      if FDelay < 500 then
        FDelay := 500;
      JvMouseGestureInterpreter.Delay:=FDelay;
    end;
    
    procedure TJvMouseGestureHook.SetGrid(const Value: Integer);
    begin
      FGrid := Value;
      if (FGrid < 10) or (FGrid > 500) then
        FGrid := 15;
      JvMouseGestureInterpreter.Grid:=FGrid;
    end;
    
    procedure TJvMouseGestureHook.SetTrackColor(const Value: TColor);
    begin
      if FTrackColor <> Value then
      begin
        FTrackColor := Value;
        JvMouseGestureInterpreter.TrackColor:=FTrackColor;
        if FTrackColor = clBlack then
          JvMouseGestureInterpreter.FForm.Color := clWhite
        else
          JvMouseGestureInterpreter.FForm.Color := clBlack;
        JvMouseGestureInterpreter.FForm.TransparentColorValue := JvMouseGestureInterpreter.FForm.Color;
      end;
    end;
    
    procedure TJvMouseGestureHook.SetTrackWidth(const Value: Cardinal);
    begin
      FTrackWidth:=Value;
      JvMouseGestureInterpreter.TrackWidth:=FTrackWidth;
    end;
    
    procedure TJvMouseGestureHook.CreateForThreadOrSystem(AOwner: TComponent; ADwThreadID: Cardinal);
    
    begin
      if JvMouseGestureHookAlreadyInstalled then
        raise EJVCLException.CreateRes(@RsECannotHookTwice);
    
      JvMouseGestureInterpreter := TJvMouseGesture.Create(nil);
      FMouseButton := mbRight;
    
      if csDesigning in ComponentState then
      begin
        FActive := False;
        Exit;
      end;
    
      FActive := FActivationMode = amAppStart;
    
      //install hook
      FCurrentHook := SetWindowsHookEx(WH_MOUSE, @JvMouseGestureHook, 0, ADwThreadID);
    
      //return True if it worked (read only for user). User should never see a
      //global var like MouseGestureHookAlreadyInstalled
      FHookInstalled := FCurrentHook <> 0;
    
      // global remember, internal use only
      JvMouseGestureHookAlreadyInstalled := FHookInstalled;
      JvCurrentHook := FCurrentHook;
    
      // map event
      if Assigned(FOnMouseGestureCustomInterpretation) then
        JvMouseGestureInterpreter.OnMouseGestureCustomInterpretation :=
          FOnMouseGestureCustomInterpretation
      else
        JvMouseGestureInterpreter.OnMouseGestureCustomInterpretation := nil;
    end;
    
    function TJvMouseGestureHook.DoMouseGestureCustomInterpretation(const AGesture: string): Boolean;
    begin
      Result := Assigned(FOnMouseGestureCustomInterpretation);
      if Result then
        FOnMouseGestureCustomInterpretation(Self, AGesture);
    end;
    
    procedure TJvMouseGestureHook.SetActivationMode(const Value: TJvActivationMode);
    begin
      FActivationMode := Value;
    end;
    
    procedure TJvMouseGestureHook.SetActive(const Value: Boolean);
    begin
      if csDesigning in ComponentState then
        FActive := False
      else
        FActive := Value;
    
      JvMouseGestureHookActive := FActive;
    end;
    
    procedure TJvMouseGestureHook.SetMouseButton(const Value: TMouseButton);
    begin
      FMouseButton := Value;
      case Value of
        mbLeft:
          begin
            JvMouseButtonDown := WM_LBUTTONDOWN;
            JvMouseButtonUp := WM_LBUTTONUP;
          end;
        mbMiddle:
          begin
            JvMouseButtonDown := WM_MBUTTONDOWN;
            JvMouseButtonUp := WM_MBUTTONUP;
          end;
        mbRight:
          begin
            JvMouseButtonDown := WM_RBUTTONDOWN;
            JvMouseButtonUp := WM_RBUTTONUP;
          end;
      end;
    end;
    
    procedure TJvMouseGestureHook.SetMouseGestureCustomInterpretation(
      const Value: TOnMouseGestureCustomInterpretation);
    begin
      FOnMouseGestureCustomInterpretation := Value;
      if Assigned(JvMouseGestureInterpreter) then
        JvMouseGestureInterpreter.OnMouseGestureCustomInterpretation := Value;
    end;
    
    procedure TJvMouseGestureHook.SetTrailingMouseGesture(const Value: TNotifyEvent);
    begin
      FOnCustomTrailingMouseGesture:=Value;
      if Assigned(JvMouseGestureInterpreter) then
        JvMouseGestureInterpreter.OnTrailingMouseGesture := Value;
    end;
    
    function TJvMouseGestureHook.GetMouseGesture: TJvMouseGesture;
    begin
      Result := JvMouseGestureInterpreter;
    end;
    
    //============================================================================
    
    
    function JvMouseGestureHook(Code: Integer; wParam: Word; lParam: Longword): Longword; stdcall;
    var
      locY: Integer;
      locX: Integer;
    begin
      if (Code >= 0) and (JvMouseGestureHookActive) then
      begin
        with PMouseHookStruct(lParam)^ do
        begin
          locX := pt.X;
          locY := pt.Y;
        end;
        if wParam = WM_MOUSEMOVE then
        begin
          JvMouseGestureInterpreter.TrailMouseGesture(locX, locY);
        end;
        if wParam = JvMouseButtonDown then
        begin
          JvMouseGestureInterpreter.StartMouseGesture(locX, locY);
        end
        else
        if wParam = JvMouseButtonUp then
        begin
          JvMouseGestureInterpreter.EndMouseGesture(locX, locY);
        end;
    
      end;
      Result := CallNextHookEx(JvCurrentHook, Code, wParam, lParam);
    end;
    
    
    
    
    {$IFDEF UNITVERSIONING}
    initialization
      RegisterUnitVersion(HInstance, UnitVersioning);
    
    finalization
      UnregisterUnitVersion(HInstance);
    {$ENDIF UNITVERSIONING}
    
    end.
    改造过的JvMouseGesture

    增加了几个东西:

    FForm: TForm:用于绘制显示手势规矩

    FTrackWidth: Cardinal;手势轨迹宽度
    FTrackColor: TColor;手势轨迹颜色

    此外主要改造了以下几个过程、函数

    constructor TJvMouseGesture.Create(AOwner: TComponent);
    begin
      inherited Create(AOwner);
      FGestureList := TStringList.Create;
      FGestureList.Sorted := True;
    
      FDelay := 500;
      FTrailLimit := 1000;
      FTrailInterval := 2;
      FGrid := 15;
      FTrackColor := clRed;
      FTrackWidth := 5;
      FGridHalf := FGrid div 2;
      FTrailActive := False;
      FdTolerance := 75; // tolerance for diagonal movement. see processCoordinates()
      begin
        FForm := TForm.Create(Self);
        FForm.TransparentColor := True;
        FForm.TransparentColorValue := clBlack;
        FForm.BorderStyle := bsNone;
        FForm.FormStyle := fsStayOnTop;
        FForm.DoubleBuffered := True;
        FForm.Color := clBlack;
        FLastWndProc := FForm.WindowProc;
        FForm.WindowProc := WndProc;
        AdjustSize;
        FForm.Canvas.Brush.Color := FForm.TransparentColorValue;
        FForm.Canvas.FillRect(FForm.ClientRect);
        ShowWindow(FForm.Handle,SW_SHOWNOACTIVATE);
        Hide;
        FHided := True;
      end;
      LoadGestureTable;
    
      FActive := not (csDesigning in ComponentState);
    end;
    
    procedure TJvMouseGesture.LoadGestureTable;
    begin
      with FGestureList do
      begin
        AddObject('向左', TObject(JVMG_LEFT));
        AddObject('向右', TObject(JVMG_RIGHT));
        AddObject('向上', TObject(JVMG_UP));
        AddObject('向下', TObject(JVMG_DOWN));
        AddObject('向左斜下', TObject(JVMG_LEFTLOWER));
        AddObject('向右斜下', TObject(JVMG_RIGHTLOWER));
        AddObject('向左斜上', TObject(JVMG_LEFTUPPER));
        AddObject('向右斜上', TObject(JVMG_RIGHTUPPER));
      end;
    end;

    此处替换了原来的手势名称,改为中文,这样用户才看得懂

    procedure TJvMouseGesture.StartMouseGesture(AMouseX, AMouseY: Integer);
    begin
      if not FActive then
        Exit;
      FForm.Show;
      FForm.BringToFront;
      FForm.Canvas.MoveTo(AMouseX, AMouseY);
      FLastPushed := #0;
      FGesture := '';
      FTrailActive := True;
      FTrailLength := 0;
      FTrailX := AMouseX;
      FTrailY := AMouseY;
      FTrailStartTime := now;
      FHided:=False;
    end;
    
    procedure TJvMouseGesture.TrailMouseGesture(AMouseX, AMouseY: Integer);
    var
      locX: Integer;
      locY: Integer;
      x_dir: Integer;
      y_dir: Integer;
      tolerancePercent: Double;
      x_divide_y: Double;
      y_divide_x: Double;
    
      function InBetween(AValue, AMin, AMax: Double): Boolean;
      begin
        Result := (AValue >= AMin) and (AValue <= AMax);
      end;
    
    begin
      if not FActive then
        Exit;
    
      if (not FTrailActive) or (FTrailLength > FTrailLimit) then
      begin
        FTrailActive := False;
        Exit;
      end;
    
      try
        x_dir := AMouseX - FTrailX;
        y_dir := AMouseY - FTrailY;
        locX := abs(x_dir);
        locY := abs(y_dir);
    
        // process each half-grid
        if (locX >= FGridHalf) or (locY >= FGridHalf) then
        begin
          // diagonal movement:
          // dTolerance = 75 means that a movement is recognized as diagonal when
          // x/y or y/x is between 0.25 and 1
          if (GetTopWindow(0) <> FForm.Handle) and Application.Active then
          FForm.BringToFront;
          FForm.Canvas.Pen.Color := FTrackColor;
          FForm.Canvas.Pen.Width := FTrackWidth;
          FForm.Canvas.LineTo(AMouseX, AMouseY);
    
          tolerancePercent := 1 - FdTolerance / 100;
          if locY <> 0 then
            x_divide_y := locX / locY
          else
            x_divide_y := 0;
          if locX <> 0 then
            y_divide_x := locY / locX
          else
            y_divide_x := 0;
          if (FdTolerance <> 0) and
            (InBetween(x_divide_y, tolerancePercent, 1) or
            InBetween(y_divide_x, tolerancePercent, 1)) then
          begin
            if (x_dir < -9) and (y_dir > 9) then
            begin
              AddGestureChar('向左斜下');
            end
            else
            begin
              if (x_dir > 9) and (y_dir > 9) then
                AddGestureChar('向右斜下')
              else
              begin
                if (x_dir < -9) and (y_dir < -9) then
                  AddGestureChar('向左斜上')
                else
                begin
                  if (x_dir > 9) and (y_dir < -9) then
                    AddGestureChar('向右斜上');
                end;
              end;
            end;
          end // of diaognal
          else
          begin
            // horizontal movement:
            if locX > locY then
            begin
              if x_dir > 0 then
                AddGestureChar('向右')
              else
              begin
                if x_dir < 0 then
                  AddGestureChar('向左');
              end;
            end
            else
            begin
              // vertical movement:
              if locX < locY then
              begin
                if y_dir > 0 then
                  AddGestureChar('向下')
                else
                begin
                  if y_dir < 0 then
                    AddGestureChar('向上');
                end;
              end;
            end;
          end;
        end; // of half grid
      finally
        FTrailX := AMouseX;
        FTrailY := AMouseY;
      end;
      DoOnTrailingMouseGesture;
    end;
    StartMouseGesture

    这个地方也改造了

    此外还定义了一个新的组件,以方便用户自定义鼠标手势,其代码如下:

    unit UWSGestureREC;
    
    interface
    
    uses
      Windows,SysUtils, Messages ,Classes, Controls,Graphics,GraphUtil,
      Generics.Collections,Math,Dialogs;
    
    type
      TGesturePoints = TList<TPoint>;
    
      TOnMouseGestureCustomInterpretation = procedure(Sender: TObject;const AGesture: string) of object;
    
      TCustomUWSGestureRecord = class(TCustomControl)
      private
        { Private declarations }
        FGesture:string;
        FGestureLineColor: TColor;
        FGesturePointColor: TColor;
        FLastDrawnPoint: Integer;
        FPoints: TGesturePointArray;
        FRecordedPoints: TGesturePoints;
        FRecording: Boolean;
        FPlaying:Boolean ;
        FCaption: string;
        FLastPushed: String;
        FTrailX: Integer;
        FTrailY: Integer;
        FTrailLength: Integer;
        FTrailActive: Boolean;
        FTrailStartTime: TDateTime;
        FdTolerance: Integer;
        FTrailLimit: Integer;
        FGridHalf: Integer;
        FStandardGestures:TStringList;
        FBasicGestures:TStringList;
        FGestureFileName:string;
        FOnMouseGestureCustomInterpretation: TOnMouseGestureCustomInterpretation;
        FOnTrailingGesture: TOnMouseGestureCustomInterpretation;
    
        procedure AddGesturePoint(const LastPoint, NextPoint: TPoint);
        function PointsToArray(Source: TGesturePoints): TGesturePointArray;
        procedure SetCaption(const Value: string);
        procedure SetGestureLineColor(const Value: TColor);
        procedure SetGesturePointColor(const Value: TColor);
        procedure ShortGesture;
      protected
        { Protected declarations }
        procedure DrawPoint(const Point: TPoint); virtual;
        procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
        procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
        procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
        procedure Paint; override;
        procedure WndProc(var Message: TMessage); override;
        function DoMouseGestureCustomInterpretation(const AGesture: string): Boolean; virtual;
        function DoTrailingGesture(const AGesture: string): Boolean; virtual;
      public
        constructor Create(AOwner: TComponent); override;
        destructor Destroy; override;
        function NormalizePoints(const Points: array of TPoint): TGesturePointArray;
        procedure AddGestureChar(AChar: String);
        procedure StartMouseGesture(AMouseX, AMouseY: Integer);
        procedure TrailMouseGesture(AMouseX, AMouseY: Integer);
        procedure EndMouseGesture(AMouseX, AMouseY: Integer);
        procedure Play;
        procedure PlayStandard(aGesture:String);
        procedure ReRestSize;
        procedure PlayFromFile(aGestureFile:String);
        procedure SaveGesturePointtoFile(aGPFile:String);
        function IsStandardGesture(aGesture:String):Boolean;
        function GesturetoGestureFileName(aGesture:String):string;
        procedure ExpoertStandardGesture2List(Items:TStrings);
        property RecordedPoints: TGesturePoints read FRecordedPoints write FRecordedPoints;
        property Caption: string read FCaption write SetCaption;
        property Gesture:string read FGesture write FGesture;
        property GestureLineColor: TColor read FGestureLineColor
          write SetGestureLineColor default clBlue;
        property GesturePointColor: TColor read FGesturePointColor
          write SetGesturePointColor default clBlue;
        property GestureFileName:string read FGestureFileName;
        property OnMouseGestureCustomInterpretation: TOnMouseGestureCustomInterpretation read
          FOnMouseGestureCustomInterpretation write FOnMouseGestureCustomInterpretation;
        property OnTrailingGesture: TOnMouseGestureCustomInterpretation read
          FOnTrailingGesture write FOnTrailingGesture;
        property StandardGestures:TStringList read FStandardGestures;
      published
        { Published declarations }
      end;
    
      TUWSGestureRecord = class(TCustomUWSGestureRecord)
      private
        { Private declarations }
      protected
        { Protected declarations }
      public
        { Public declarations }
      published
        { Published declarations }
        property Align;
        property Anchors;
        property BevelEdges;
        property BevelInner;
        property BevelOuter;
        property BevelKind default bkNone;
        property BevelWidth;
        property BiDiMode;
        property Caption;
        property Color;
        property Constraints;
        property Ctl3D;
        property DoubleBuffered default True;
        property DragCursor;
        property DragKind;
        property DragMode;
        property Enabled;
        property Font;
        property GestureLineColor;
        property GesturePointColor;
        property Height default 200;
        property ParentBiDiMode;
        property ParentColor;
        property ParentDoubleBuffered default False;
        property ParentFont;
        property ParentShowHint;
        property PopupMenu;
        property ShowHint;
        property Visible;
        property Width default 200;
        property OnClick;
        property OnContextPopup;
        property OnEndDock;
        property OnEndDrag;
        property OnGesture;
        property OnDragDrop;
        property OnDragOver;
        property OnMouseActivate;
        property OnMouseDown;
        property OnMouseEnter;
        property OnMouseLeave;
        property OnMouseMove;
        property OnMouseUp;
        property OnResize;
        property OnStartDock;
        property OnStartDrag;
        property OnMouseGestureCustomInterpretation;
        property OnTrailingGesture;
      end;
    
    procedure Register;
    
    implementation
    
    procedure Register;
    begin
      RegisterComponents('uws Used', [TUWSGestureRecord]);
    end;
    
    constructor TCustomUWSGestureRecord.Create(AOwner: TComponent);
    begin
      inherited;
      AlignWithMargins:=True;
      Margins.Top:=7;
      Margins.Bottom:=7;
      Margins.Left:=7;
      Margins.Right:=7;
      FGesture :='';
      FGestureLineColor := clBlue;
      FGesturePointColor := clBlue;
      FRecordedPoints := TGesturePoints.Create;
      FTrailLimit := 1000;
      FGridHalf := 8;
      FTrailActive := False;
      FdTolerance := 75; // tol
      FRecording := False;
      Height := 200;
      Width := 200;
      ControlStyle := ControlStyle - [csGestures];
      DoubleBuffered := True;
      ParentDoubleBuffered := False;
      FStandardGestures:=TStringList.Create;
      FStandardGestures.Add('→向右');
      FStandardGestures.Add('→向左');
      FStandardGestures.Add('→向上');
      FStandardGestures.Add('→向下');
      FStandardGestures.Add('→向右斜上');
      FStandardGestures.Add('→向右斜下');
      FStandardGestures.Add('→向左斜上');
      FStandardGestures.Add('→向左斜下');
      FStandardGestures.Add('→向下→向右');
      FStandardGestures.Add('→向下→向左');
      FStandardGestures.Add('→向上→向右');
      FStandardGestures.Add('→向上→向左');
      FStandardGestures.Add('→向右→向下');
      FStandardGestures.Add('→向左→向下');
      FStandardGestures.Add('→向右→向上');
      FStandardGestures.Add('→向左→向上');
      FStandardGestures.Add('→向右→向左');
      FStandardGestures.Add('→向左→向右');
      FStandardGestures.Add('→向下→向上');
      FStandardGestures.Add('→向上→向下');
      FBasicGestures:=TStringList.Create;
      FBasicGestures.Add('向右');
      FBasicGestures.Add('向左');
      FBasicGestures.Add('向上');
      FBasicGestures.Add('向下');
      FBasicGestures.Add('向右斜上');
      FBasicGestures.Add('向右斜下');
      FBasicGestures.Add('向左斜上');
      FBasicGestures.Add('向左斜下');
    end;
    
    destructor TCustomUWSGestureRecord.Destroy;
    begin
      FreeAndNil(FRecordedPoints);
      FreeAndNil(FStandardGestures);
      FreeAndNil(FBasicGestures);
      inherited;
    end;
    
    procedure TCustomUWSGestureRecord.ReRestSize;
    begin
      if Height<200 then
      Height:=200;
      if Width<200 then
      Width:=200; 
      if Height<>width then
      Height:=Width ;
    end;
    
    procedure TCustomUWSGestureRecord.Play;
    var
      I:Integer;
      LRect: TRect;
    begin
      FPlaying:=True;
      LRect := ClientRect;
      Canvas.Brush.Color := Color;
      Canvas.FillRect(LRect);
      if FRecordedPoints.Count>0 then
      begin
        Canvas.MoveTo(FRecordedPoints[0].X, FRecordedPoints[0].Y);
        for I := 0 to FRecordedPoints.Count - 1 do
        begin
          DrawPoint(FRecordedPoints[I]);
          Sleep(10);
        end;
      end;
      FPlaying:=False;
    end;
    
    procedure TCustomUWSGestureRecord.PlayStandard(aGesture:String);
    var
      I,K,CC:Integer;
      LRect: TRect;
    begin
      if aGesture='' then Exit;
      FPlaying:=True;
      CC:=Min(Width,Height);
      LRect := ClientRect;
      Canvas.Brush.Color := Color;
      Canvas.FillRect(LRect);
      if aGesture='→向右' then
      begin
        Canvas.MoveTo(20, Height div 2);
        for I := 20 to Width-20 do
        begin
          DrawPoint(Point(I,Height div 2));
          Sleep(1);
        end;
      end
      else if aGesture='→向左' then
      begin
        Canvas.MoveTo(Width-20, Height div 2);
        for I := Width-20 downto 20 do
        begin
          DrawPoint(Point(I,Height div 2));
          Sleep(1);
        end;
      end
      else if aGesture='→向下' then
      begin
        Canvas.MoveTo(Width div 2, 20);
        for I := 20 to Height-20 do
        begin
          DrawPoint(Point(Width div 2,I));
          Sleep(1);
        end;
      end
      else if aGesture='→向上' then
      begin
        Canvas.MoveTo(Width div 2, Height-20);
        for I := Height-20 downto 20 do
        begin
          DrawPoint(Point(Width div 2,I));
          Sleep(1);
        end;
      end
      else if aGesture='→向右斜下' then
      begin
        Canvas.MoveTo(20, 20);
        for I := 20 to CC-20 do
        begin
          DrawPoint(Point(I,I));
          Sleep(1);
        end;
      end
      else if aGesture='→向右斜上' then
      begin
        Canvas.MoveTo(20, Height-20);
        for I := 20 to CC-20 do
        begin
          DrawPoint(Point(I,Height-I));
          Sleep(1);
        end;
      end
      else if aGesture='→向左斜下' then
      begin
        Canvas.MoveTo(Width-20, 20);
        for I := 20 to CC-20 do
        begin
          DrawPoint(Point(Width-I,I));
          Sleep(1);
        end;
      end
      else if aGesture='→向左斜上' then
      begin
        Canvas.MoveTo(Width-20, Height-20);
        for I := 20 to CC-20 do
        begin
          DrawPoint(Point(Width-I,Height-I));
          Sleep(1);
        end;
      end
      else if aGesture='→向下→向右' then
      begin
        Canvas.MoveTo(60, 60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(60,I));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(I,Height-60));
          Sleep(1);
        end;
      end
      else if aGesture='→向下→向左' then
      begin
        Canvas.MoveTo(width-60,60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(width-60,I));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(width-I,Height-60));
          Sleep(1);
        end;
      end
      else if aGesture='→向上→向右' then
      begin
        Canvas.MoveTo(60,Height-60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(60,Height-I));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(I,60));
          Sleep(1);
        end;
      end
      else if aGesture='→向上→向左' then
      begin
        Canvas.MoveTo(Width-60,Height-60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width-60,Height-I));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width-I,60));
          Sleep(1);
        end;
      end
      else if aGesture='→向左→向上' then
      begin
        Canvas.MoveTo(Width-60,Height-60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width-I,Height-60));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(60,Height-I));
          Sleep(1);
        end;
      end
      else if aGesture='→向左→向下' then
      begin
        Canvas.MoveTo(Width-60,60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width-I,60));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(60,I));
          Sleep(1);
        end;
      end
      else if aGesture='→向右→向上' then
      begin
        Canvas.MoveTo(60,Height-60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(I,Height-60));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width-60,Height-I));
          Sleep(1);
        end;
      end
      else if aGesture='→向右→向下' then
      begin
        Canvas.MoveTo(60,60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(I,60));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width-60,I));
          Sleep(1);
        end;
      end
      else if aGesture='→向右→向左' then
      begin
        Canvas.MoveTo(60,Height div 2);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(I,Height div 2));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width-I,Height div 2));
          Sleep(1);
        end;
      end
      else if aGesture='→向左→向右' then
      begin
        Canvas.MoveTo(Width-60,Height div 2);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width-I,Height div 2));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(I,Height div 2));
          Sleep(1);
        end;
      end
      else if aGesture='→向下→向上' then
      begin
        Canvas.MoveTo(Width div 2,60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width div 2,I));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width div 2,Height-I));
          Sleep(1);
        end;
      end
      else if aGesture='→向上→向下' then
      begin
        Canvas.MoveTo(Width div 2,Height-60);
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width div 2,Height-I));
          Sleep(1);
        end;
        for I := 60 to CC-60 do
        begin
          DrawPoint(Point(Width div 2,I));
          Sleep(1);
        end;
      end;
      FPlaying:=False;
    end;
    
    function TCustomUWSGestureRecord.IsStandardGesture(aGesture:String):Boolean;
    begin
      Result:=False ;
      if aGesture='' then Exit;
      Result:=(FStandardGestures.IndexOf(aGesture)<>-1);
    end;
    
    function TCustomUWSGestureRecord.GesturetoGestureFileName(aGesture:String):string;
    var
      Temp:TStringList;
      I,ID:Integer;
    begin
      Result:='';
      if aGesture='' then Exit;
      Temp:=TStringList.Create;
      try
        Temp.Delimiter:='';
        Temp.DelimitedText:=aGesture;
        for I := 0 to Temp.Count-1 do
        begin
          if Temp[I]<>'' then
          begin
            ID:=FBasicGestures.IndexOf(Temp[I]);
            Result:=Result+InttoStr(ID);
          end;
        end;
      finally
        Temp.Free;
      end;
      Result:=Result+'.GPS';
    end;
    
    procedure TCustomUWSGestureRecord.ExpoertStandardGesture2List(Items:TStrings);
    begin
      Items.Assign(FStandardGestures);
    end;
    
    procedure TCustomUWSGestureRecord.SaveGesturePointtoFile(aGPFile:String);
    var
      I:Integer;
      Temp:TStringList;
    begin
      if aGPFile='' then
      aGPFile:='123.GPS';
      if FRecordedPoints.Count<1 then Exit;
      Temp:=TStringList.Create ;
      try
        for I := 0 to FRecordedPoints.Count-1 do
        begin
          Temp.Add(Format('X%d=%d',[I,FRecordedPoints[I].X]));
          Temp.Add(Format('Y%d=%d',[I,FRecordedPoints[I].Y]));
        end;
        Temp.SaveToFile(aGPFile);
      finally
        Temp.Free;
      end;
    end;
    
    procedure TCustomUWSGestureRecord.PlayFromFile(aGestureFile:String);
    var
      I,CC,X,Y:Integer ;
      Temp:TStringList;
      LRect: TRect;
    begin
      if aGestureFile='' then Exit;
      if not FileExists(aGestureFile) then Exit;
      LRect := ClientRect;
      Canvas.Brush.Color := Color;
      Canvas.FillRect(LRect);
      Temp:=TStringList.Create;
      try
        try
          Temp.LoadFromFile(aGestureFile);
        except
        end;
        if Temp.Count>1 then
        begin
          CC:=Temp.Count div 2;
          X:=0;
          Y:=0;
          try
            X:=StrToInt(Temp.Values['X0']);
            Y:=StrToInt(Temp.Values['Y0']);
          except
          end;
          Canvas.MoveTo(X,Y);
          for I := 0 to CC-1 do
          begin
            X:=0;
            Y:=0;
            try
              X:=StrToInt(Temp.Values[Format('X%d',[I])]);
              Y:=StrToInt(Temp.Values[Format('Y%d',[I])]);
            except
            end;
            DrawPoint(Point(X,Y));
            Sleep(10);
          end;
        end;
      finally
        Temp.Free;
      end;
    end;
    
    procedure TCustomUWSGestureRecord.AddGestureChar(AChar: String);
    begin
      if AChar <> FLastPushed then
      begin
        FGesture := FGesture +''+ AChar;
        FLastPushed := AChar;
      end;
    end;
    
    procedure TCustomUWSGestureRecord.AddGesturePoint(const LastPoint, NextPoint: TPoint);
    var
      StepX, StepY: Single;
      I, DeltaX, DeltaY: Integer;
      CountX, CountY, Count: Integer;
    begin
      // Determine distance between points
      DeltaX := Abs(NextPoint.X - LastPoint.X);
      DeltaY := Abs(NextPoint.Y - LastPoint.Y);
    
      // If points are too close together discard the new point
      if (DeltaX < 4) and (DeltaY < 4) then
        Exit;
    
      // If points are too far apart insert intermediate points
      if (DeltaX > 8) or (DeltaY > 8) then
      begin
        // Determine how many points to insert
        CountX := DeltaX div 5;
        if (DeltaX mod 5) = 0 then
          Dec(CountX);
        CountY := DeltaY div 5;
        if (DeltaY mod 5) = 0 then
          Dec(CountY);
        Count := Max(CountX, CountY);
    
        // Determine spacing between inserted points
        StepX := (NextPoint.X - LastPoint.X) / Count;
        StepY := (NextPoint.Y - LastPoint.Y) / Count;
    
        // Insert points
        for I := 1 to Count - 1 do
          FRecordedPoints.Add(Point(LastPoint.X + Round(StepX * I),
            LastPoint.Y + Round(StepY * I)));
      end;
    
      // Add captured point
      FRecordedPoints.Add(NextPoint);
    end;
    
    function TCustomUWSGestureRecord.PointsToArray(Source: TGesturePoints): TGesturePointArray;
    var
      I: Integer;
    begin
      SetLength(Result, Source.Count);
      for I := 0 to Source.Count - 1 do
        Result[I] := Source[I];
    end;
    
    procedure TCustomUWSGestureRecord.SetCaption(const Value: string);
    begin
      if Value <> FCaption then
      begin
        FCaption := Value;
        Invalidate;
      end;
    end;
    
    procedure TCustomUWSGestureRecord.StartMouseGesture(AMouseX, AMouseY: Integer);
    begin
      // Set recording mode
      FRecording := True;
      Invalidate;
      // Clear list of points
      FRecordedPoints.Clear;
      FRecordedPoints.Add(Point(AMouseX, AMouseY));
      DrawPoint(FRecordedPoints[0]);
      FLastDrawnPoint := 0;
      FLastPushed := #0;
      FGesture := '';
      FTrailActive := True;
      FTrailLength := 0;
      FTrailX := AMouseX;
      FTrailY := AMouseY;
      FTrailStartTime := now;
    end;
    
    procedure TCustomUWSGestureRecord.ShortGesture;
    var
      TempStr:string;
      Temp:TStringList;
      I:Integer;
    begin
      Temp:=TStringList.Create;
      try
        Temp.Delimiter:='';
        Temp.DelimitedText:=FGesture;
        if Temp.Count>8 then
        begin
          for I := 1 to 8 do
          TempStr:=TempStr+''+temp[I];
          FGesture:=TempStr;
        end;
      finally
        Temp.Free;
      end;
    end;
    
    procedure TCustomUWSGestureRecord.EndMouseGesture(AMouseX, AMouseY: Integer);
    var
      Index: Integer;
    begin
      if not FRecording  then
        Exit;
      FTrailActive := False;
      FRecording := False;
    
      // Add new gesture point
      AddGesturePoint(FRecordedPoints[FRecordedPoints.Count - 1], Point(AMouseX, AMouseY));
    
      // Normalize list of points
      FPoints := NormalizePoints(PointsToArray(FRecordedPoints));
      ShortGesture;
      FCaption:=FGesture ;
    
    
      // Trigger OnRecorded event if more than 1 point was recorded
      if (Length(FPoints) > 1) then
      begin
    
      end;
      FGestureFileName:=GesturetoGestureFileName(FGesture);
      DoMouseGestureCustomInterpretation(FGesture);
      // Force repaint
      Invalidate;
    end;
    
    procedure TCustomUWSGestureRecord.TrailMouseGesture(AMouseX, AMouseY: Integer);
    var
      locX: Integer;
      locY: Integer;
      x_dir: Integer;
      y_dir: Integer;
      tolerancePercent: Double;
      x_divide_y: Double;
      y_divide_x: Double;
      I:Integer;
      function InBetween(AValue, AMin, AMax: Double): Boolean;
      begin
        Result := (AValue >= AMin) and (AValue <= AMax);
      end;
    
    begin
      if not FRecording then
        Exit;
    
      // Add new gesture point
      AddGesturePoint(FRecordedPoints[FRecordedPoints.Count - 1], Point(AMouseX, AMouseY));
      for I := FLastDrawnPoint to FRecordedPoints.Count - 1 do
        DrawPoint(FRecordedPoints[I]);
      FLastDrawnPoint := FRecordedPoints.Count - 1;
    
      if (not FTrailActive) or (FTrailLength > FTrailLimit) then
      begin
        FTrailActive := False;
        Exit;
      end;
    
      try
        x_dir := AMouseX - FTrailX;
        y_dir := AMouseY - FTrailY;
        locX := abs(x_dir);
        locY := abs(y_dir);
    
        // process each half-grid
        if (locX >= FGridHalf) or (locY >= FGridHalf) then
        begin
          // diagonal movement:
          // dTolerance = 75 means that a movement is recognized as diagonal when
          // x/y or y/x is between 0.25 and 1
    
          tolerancePercent := 1 - FdTolerance / 100;
          if locY <> 0 then
            x_divide_y := locX / locY
          else
            x_divide_y := 0;
          if locX <> 0 then
            y_divide_x := locY / locX
          else
            y_divide_x := 0;
          if (FdTolerance <> 0) and
            (InBetween(x_divide_y, tolerancePercent, 1) or
            InBetween(y_divide_x, tolerancePercent, 1)) then
          begin
            if (x_dir < -6) and (y_dir > 6) then
            begin
              AddGestureChar('向左斜下');
            end
            else
            begin
              if (x_dir > 6) and (y_dir > 6) then
                AddGestureChar('向右斜下')
              else
              begin
                if (x_dir < -6) and (y_dir < -6) then
                  AddGestureChar('向左斜上')
                else
                begin
                  if (x_dir > 6) and (y_dir < -6) then
                    AddGestureChar('向右斜上');
                end;
              end;
            end;
          end // of diaognal
          else
          begin
            // horizontal movement:
            if locX > locY then
            begin
              if x_dir > 0 then
                AddGestureChar('向右')
              else
              begin
                if x_dir < 0 then
                  AddGestureChar('向左');
              end;
            end
            else
            begin
              // vertical movement:
              if locX < locY then
              begin
                if y_dir > 0 then
                  AddGestureChar('向下')
                else
                begin
                  if y_dir < 0 then
                    AddGestureChar('向上');
                end;
              end;
            end;
          end;
        end; // of half grid
      finally
        FTrailX := AMouseX;
        FTrailY := AMouseY;
      end;
      DoTrailingGesture(FGesture);
    end;
    
    procedure TCustomUWSGestureRecord.SetGestureLineColor(const Value: TColor);
    begin
      if Value <> FGestureLineColor then
      begin
        FGestureLineColor := Value;
        Invalidate;
      end;
    end;
    
    procedure TCustomUWSGestureRecord.SetGesturePointColor(const Value: TColor);
    begin
      if Value <> FGesturePointColor then
      begin
        FGesturePointColor := Value;
        Invalidate;
      end;
    end;
    
    procedure TCustomUWSGestureRecord.DrawPoint(const Point: TPoint);
    begin
      Canvas.Brush.Style := bsClear;
      Canvas.Pen.Width:=17;
      Canvas.Pen.Color := FGesturePointColor;
      Canvas.Ellipse(Point.X - 2, Point.Y - 2, Point.X + 3, Point.Y + 3);
    
      Canvas.Pen.Color := FGestureLineColor;
      if FRecordedPoints.Count = 1 then
        Canvas.MoveTo(Point.X, Point.Y)
      else
        Canvas.LineTo(Point.X, Point.Y);
    end;
    
    procedure TCustomUWSGestureRecord.MouseDown(Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    begin
      if Button<>mbLeft then Exit;
      StartMouseGesture(X,Y);
    end;
    
    procedure TCustomUWSGestureRecord.MouseMove(Shift: TShiftState; X, Y: Integer);
    begin
      TrailMouseGesture(X,Y);
    end;
    
    function TCustomUWSGestureRecord.NormalizePoints(
      const Points: array of TPoint): TGesturePointArray;
    var
      Index, SmallestX, SmallestY: Integer;
    begin
      SetLength(Result, Length(Points));
      // Find the delta.
      SmallestX := MaxInt;
      SmallestY := MaxInt;
    
      for Index := 0 to Length(Points) - 1 do
      begin
        if SmallestX > Points[Index].X then
          SmallestX := Points[Index].X;
    
        if SmallestY > Points[Index].Y then
          SmallestY := Points[Index].Y;
      end;
    
      // Apply the delta.
      SetLength(Result, Length(Points));
      for Index := 0 to Length(Points) - 1 do
        Result[Index] := Point(Points[Index].X - SmallestX, Points[Index].Y - SmallestY);
    end;
    
    procedure TCustomUWSGestureRecord.MouseUp(Button: TMouseButton; Shift: TShiftState;
      X, Y: Integer);
    begin
      EndMouseGesture(X,Y);
    end;
    
    procedure TCustomUWSGestureRecord.WndProc(var Message: TMessage);
    begin
      inherited WndProc(Message);
    end;
    
    procedure TCustomUWSGestureRecord.Paint;
    var
      LRect: TRect;
      LText: string;
      I, LTextHeight: Integer;
    begin
      LRect := ClientRect;
      Canvas.Brush.Color := Color;
      Canvas.FillRect(LRect);
    
      if (not FRecording) and (not FPlaying) then
      begin
        // Draw instructions
        Canvas.Font := Self.Font;
        Canvas.Brush.Style := bsClear;
        if FCaption='' then
        FCaption:=FGesture ; 
        LText := FCaption;
        if (csDesigning in ComponentState) and (LText = '') then
          LText := Name;
    
        InflateRect(LRect, -25, 0);
        LRect.Top := 0;
        LRect.Bottom := 0;
        Canvas.TextRect(LRect, LText, [tfCalcRect, tfWordBreak]);
        LRect.Right := Width - 25;
        LTextHeight := LRect.Bottom - LRect.Top;
        LRect.Top := (Height - LTextHeight) div 2;
        Inc(LRect.Bottom, LRect.Top);
        Canvas.TextRect(LRect, LText, [tfCenter, tfWordBreak]);
      end
      else
      begin
        // Draw points
        for I := 0 to FRecordedPoints.Count - 1 do
          DrawPoint(FRecordedPoints[I])
      end;
    end;
    
    function TCustomUWSGestureRecord.DoMouseGestureCustomInterpretation(const AGesture: string): Boolean;
    begin
       Result := Assigned(FOnMouseGestureCustomInterpretation);
       if Result then
       begin
          FOnMouseGestureCustomInterpretation(Self,FGesture);
       end;
    end;
    
    function TCustomUWSGestureRecord.DoTrailingGesture(const AGesture: string): Boolean;
    begin
       Result := Assigned(FOnTrailingGesture);
       if Result then
       begin
          FOnTrailingGesture(Self,FGesture);
       end;
    end;
    
    end.
    管理单元代码

     改造过的JvMouseGesture.pas和鼠标手势定义组件下载:

    JvMouseGesture.pas

    UWSGestureREC

    效果图

    暂时就记录到这里

     代码在Delphi XE中测试通过,其他版本未经测试

  • 相关阅读:
    python入门-函数(二)
    python入门-函数(一)
    python入门-WHILE循环
    python入门-用户输入
    python入门-字典
    Spring Security授权 AccessDecisionManager
    Java的性能优化
    datahub
    vbs mytest
    spring发布和接收定制的事件(spring事件传播)
  • 原文地址:https://www.cnblogs.com/uws2056/p/3525426.html
Copyright © 2011-2022 走看看