uses
  ..., AnsiStrings;


var
  Sub, Src: AnsiString;
begin
  // Case 1:
  Sub := #$82#$A4;                                     // Japanese Hiragana 'u'
  Src := #$82#$A0#$82#$A2#$82#$A4#$82#$A6#$82#$A8;     // Japanese Hiragana 'a' 'i' 'u' 'e' 'o'
  ShowMessage(IntToStr(AnsiStrings.AnsiPos(Sub, Src)));

  // Case 2:
  Sub := AnsiString('う');                             // Japanese Hiragana 'u'
  Src := AnsiString('あいうえお');                     // Japanese Hiragana 'a' 'i' 'u' 'e' 'o'
  ShowMessage(IntToStr(AnsiStrings.AnsiPos(Sub, Src)));

  // Case 3:
  Sub := #$95#$5C;                                     // Japanese 'Hyou'
  Src := #$8C#$76#$8F#$57#$95#$5C;                     // Japanese 'SyuuKeiHyou'
  ShowMessage(IntToStr(AnsiStrings.AnsiPos(Sub, Src)));

  // Case 4:
  Sub := AnsiString('表');                             // Japanese 'Hyou'
  Src := AnsiString('集計表');                         // Japanese 'SyuuKeiHyou'
  ShowMessage(IntToStr(AnsiStrings.AnsiPos(Sub, Src)));
end;

uses
  ..., AnsiStrings;


var
  Sub, Src: AnsiString;
  uSub, uSrc: UnicodeString;
begin
  // Case 2:
  uSub := 'う';                    // Japanese Hiragana 'u'
  uSrc := 'あいうえお';            // Japanese Hiragana 'a' 'i' 'u' 'e' 'o'
  Sub := AnsiString(uSub);
  Src := AnsiString(uSrc);
  ShowMessage(IntToStr(AnsiStrings.AnsiPos(Sub, Src)));

  // Case 4:
  uSub := '表';                    // Japanese 'Hyou'
  uSrc := '集計表';                // Japanese 'SyuuKeiHyou'
  Sub := AnsiString(uSub);
  Src := AnsiString(uSrc);
  ShowMessage(IntToStr(AnsiStrings.AnsiPos(Sub, Src)));
end;

var
  Index: Integer;
  Src: String;
begin
  Src := 'あいうえお';
  Index := Pos('う', Src);
  ShowMessage(IntToStr(Index));
end;

var
  Index: Integer;
  Src: AnsiString;
begin
  Src := 'あいうえお';
  Index := Pos('う', Src);
  ShowMessage(IntToStr(Index));
end;

var
  Index: Integer;
  Src: AnsiString;
begin
  Src := 'あいうえお';
  Index := Pos(AnsiString('う'), Src);
  ShowMessage(IntToStr(Index));
end;

var
  Index: Integer;
  Src, Sub: AnsiString;
begin
  Src := 'あいうえお';
  Sub := 'う';
  Index := Pos(Sub, Src);
  ShowMessage(IntToStr(Index));
end;

var
  Index: Integer;
  Src, Sub: AnsiString;
begin
  Sub := '\';
  Src := '表1\Sheet1.xls';
  Index := Pos(Sub, Src);
  ShowMessage(IntToStr(Index));
end;

var
  Index: Integer;
  Src, Sub: AnsiString;
begin
  Sub := '\';
  Src := '表1\Sheet1.xls';
  Index := AnsiPos(Sub, Src);
  ShowMessage(IntToStr(Index));
end;

uses
  ..., AnsiStrings;

var
  Index: Integer;
  Src, Sub: AnsiString;
begin
  Sub := '\';
  Src := '表1\Sheet1.xls';
  Index := AnsiStrings.AnsiPos(Sub, Src);
  ShowMessage(IntToStr(Index));
end;

uses
  ..., AnsiStrings;

var
  Index: Integer;
  Src, Sub: AnsiString;
begin
  Sub := '\';
  Src := 'C:\ABC\DEF\GHI.TXT';
  Index := AnsiStrings.PosEx(Sub, Src, 4);
  ShowMessage(IntToStr(Index));
end;

var
  URL: string;
begin
  URL := Format('https://maps.google.co.jp/maps?q=%s,%s&z=14&hl=ja&output=embed',
                 [etLatitude.Text, etLongitude.Text]);
  WebBrowser1.Navigate2(URL);
end;

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Embarcadero\BDS\10.0\Form Design]
"Embedded Designer"="False"

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\Embarcadero\BDS\10.0\Form Design]
"Embedded Designer"="True"

program xe3preload;

{$RTTI EXPLICIT METHODS([]) FIELDS([]) PROPERTIES([])}
{$WEAKLINKRTTI ON}

uses
  System.Masks,
  System.SysUtils,
  System.IOUtils,
  Winapi.Windows;

{$R *.res}

var
  FileName: String;
  DLLWnd: THandle;
begin
  System.NoErrMsg := True;
  for FileName in TDirectory.GetFiles('C:\Program Files\Embarcadero\RAD Studio\10.0',
                                      '*.dll',
                                      TSearchOption.soAllDirectories) do
    begin
      if MatchesMask(ExtractFileName(FileName), 'dbkw64*.dll') then
        Continue;
      if MatchesMask(ExtractFileName(FileName), 'dcc64*.dll') then
        Continue;
      try
        DLLWnd := LoadLibrary(PWideChar(FileName));
        if DLLWnd > 0 then
          FreeLibrary(DLLWnd);
      except
      end;
    end;
end.

program Xe3Preloader;

{$RTTI EXPLICIT METHODS([]) FIELDS([]) PROPERTIES([])}
{$WEAKLINKRTTI ON}

// {$DEFINE VERBOSE}   // <- ここのコメントを外せばコンソールアプリになります

{$IFDEF VERBOSE}
{$APPTYPE CONSOLE}
{$ELSE}
{$R *.res}
{$ENDIF}

uses
  Winapi.Windows,
  Winapi.Messages,
  ...

program Xe3dllPreloader;

{$RTTI EXPLICIT METHODS([]) FIELDS([]) PROPERTIES([])}
{$WEAKLINKRTTI ON}

// {$DEFINE VERBOSE}   // <- ここのコメントを外せばコンソールアプリになります

{$IFDEF VERBOSE}
{$APPTYPE CONSOLE}
{$ELSE}
{$R *.res}
{$ENDIF}

uses
  System.SysUtils,
  System.IOUtils,
  ...

uses
  ..., FMX.Platform;


procedure TForm1.FormCreate(Sender: TObject);
begin
  VKAutoShowMode := vkasAlways;
end;  

思いっきり iPhone 準拠じゃねーか！

　　∧_∧
⊂（#・д・）
　/　　　ﾉ∪
　し―-J　|l| |
　　 　 　 　 人ﾍﾟｼｯ!!
　　　　　　　＿＿
　　　　　　　＼　 ＼
　　　　　　　　 ￣￣

// 現在のクリップボードの内容を Edit1 に表示
var
  ClipboardService: IFMXClipboardService;
begin
  ClipboardService := IFMXClipboardService(TPlatformServices.Current.GetPlatformService(IFMXClipboardService));
  Edit1.Text := ClipboardService.GetClipboard.AsString;
end;

// Edit1 の内容をクリップボードに入れる
var
  ClipboardService: IFMXClipboardService;
begin
  ClipboardService := IFMXClipboardService(TPlatformServices.Current.GetPlatformService(IFMXClipboardService));
  ClipboardService.SetClipboard(Edit1.Text);
end;

unit uPlatformService;

interface

uses
  FMX.Platform;

type
  TPlatformService = record
      class function Available<IntfType: IInterface>(out Service: IntfType): Boolean; static;
      class function Get<IntfType: IInterface>: IntfType; static;
    end;

implementation

uses
  System.TypInfo;

class function TPlatformService.Available<IntfType>(out Service: IntfType): Boolean;
var
  Guid: TGUID;
begin
  Guid := PTypeInfo(TypeInfo(IntfType)).TypeData.Guid;
  Result := TPlatformServices.Current.SupportsPlatformService(Guid, IInterface(Service));
end;

class function TPlatformService.Get<IntfType>: IntfType;
var
  Guid: TGUID;
begin
  Guid := PTypeInfo(TypeInfo(IntfType)).TypeData.Guid;
  Result := IntfType(TPlatformServices.Current.GetPlatformService(Guid));
end;

end.

uses
  ..., uPlatformService;


// 現在のクリップボードの内容を Edit1 に表示
var
  ClipboardService: IFMXClipboardService;
begin
  ClipboardService := TPlatformService.Get<IFMXClipboardService>;
  Edit1.Text := ClipboardService.GetClipboard.AsString;
end;

// Edit1 の内容をクリップボードに入れる
var
  ClipboardService: IFMXClipboardService;
begin
  ClipboardService := TPlatformService.Get<IFMXClipboardService>;
  ClipboardService.SetClipboard(Edit1.Text);
end;

  // 現在のクリップボードの内容を Edit1 に表示
  Edit1.Text := TPlatformService.Get<IFMXClipboardService>.GetClipboard.AsString;

  // Edit1 の内容をクリップボードに入れる
  TPlatformService.Get<IFMXClipboardService>.SetClipboard(Edit1.Text);

unit FMX.BaseForm;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes,
  {$IFDEF MSWINDOWS}
  Winapi.Windows,
  {$ENDIF}
  {$IFDEF MACOS}
  MacAPI.Foundation, MacAPI.AppKit,
  {$ENDIF}
  FMX.Types, FMX.Forms;

type
  { TBaseFormHD }
  TBaseFormHD = class(TForm)
    procedure Timer_Timer(Sender: TObject);
  private
    { private 宣言 }
    FTimer: TTimer;
    FStartPoint: TPointF;
    FEndPoint: TPointF;
    FIntervalOver: Boolean;
    FFinished: Boolean;
    FMouseUpCount: SmallInt;
    FMouseClickEvent: TNotifyEvent;
    FMouseDblClickEvent: TNotifyEvent;
    function IsMouseOnControl(X, Y: Single): Boolean;
  public
    { public 宣言 }
    constructor Create(AOwner: TComponent); override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
  published
    { published 宣言 }
    property OnClick: TNotifyEvent read FMouseClickEvent write FMouseClickEvent;
    property OnDblClick: TNotifyEvent read FMouseDblClickEvent write FMouseDblClickEvent;
  end;

  { TBaseForm3D }
  TBaseForm3D = class(TForm3D)
    procedure Timer_Timer(Sender: TObject);
  private
    { private 宣言 }
    FTimer: TTimer;
    FStartPoint: TPointF;
    FEndPoint: TPointF;
    FIntervalOver: Boolean;
    FFinished: Boolean;
    FMouseUpCount: SmallInt;
    FMouseClickEvent: TNotifyEvent;
    FMouseDblClickEvent: TNotifyEvent;
    function IsMouseOnControl(X, Y: Single): Boolean;
  public
    { public 宣言 }
    constructor Create(AOwner: TComponent); override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
  published
    { published 宣言 }
    property OnClick: TNotifyEvent read FMouseClickEvent write FMouseClickEvent;
    property OnDblClick: TNotifyEvent read FMouseDblClickEvent write FMouseDblClickEvent;
  end;

const
  CLICK_JUDGE_DIST  =   4; // クリック判定用
  DOUBLE_CLICK_TIME = 500; // ダブルクリック判定時間 (規定)

implementation

function CalcDist(a, b: TPointF): Single;
begin
  result := Sqrt(Sqr(a.X - b.X) + Sqr(a.Y - b.Y));
end;

{ TBaseFormHD }

constructor TBaseFormHD.Create(AOwner: TComponent);
begin
  inherited;
  FMouseUpCount   := 0;
  FIntervalOver   := False;
  FFinished       := False;

  FTimer := TTimer.Create(Self);
  FTimer.Enabled  := False;

  FTimer.Interval := DOUBLE_CLICK_TIME;
  {$IFDEF MSWINDOWS}
  FTimer.Interval := GetDoubleClickTime;
  {$ENDIF}
  {$IFDEF MACOS}
  // OSX 用の処理
  {$ENDIF}

  FTimer.OnTimer  := Timer_Timer;
end;

procedure TBaseFormHD.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
begin
  try
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) and ((FMouseUpCount = 0) or FFinished) then
      begin
        FStartPoint   := PointF(X, Y);
        FIntervalOver := False;
        FFinished     := False;
        if Assigned(FMouseDblClickEvent) then
          FTimer.Enabled := True;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseFormHD.MouseUp(Button: TMouseButton; Shift: TShiftState; X,
  Y: Single);
begin
  try
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        FEndPoint := PointF(X, Y);
        Inc(FMouseUpCount);
        if not Assigned(FMouseDblClickEvent) then
          FIntervalOver := True;
        if FIntervalOver then
          Timer_Timer(FTimer);
      end;
  finally
    inherited;
  end;
end;

function TBaseFormHD.IsMouseOnControl(X, Y: Single): Boolean;
begin
  result := (IControl(ObjectAtPoint(ClientToScreen(PointF(X, Y)))) <> nil);
  if result then
    begin
      FTimer.Enabled := False;
      FMouseUpCount := 0;
    end;
end;

procedure TBaseFormHD.Timer_Timer(Sender: TObject);
begin
  FIntervalOver := True;
  if FMouseUpCount = 0 then
    Exit;
  FTimer.Enabled := False;
  if CalcDist(FStartPoint, FEndPoint) < CLICK_JUDGE_DIST then
    begin
      if (FMouseUpCount > 1) then
        begin
          if Assigned(FMouseDblClickEvent) then
            OnDblClick(Self);
        end
      else
        begin
          if Assigned(FMouseClickEvent) then
            OnClick(Self);
        end;
    end;
  FFinished := True;
  FMouseUpCount := 0;
end;

{ TBaseForm3D }

constructor TBaseForm3D.Create(AOwner: TComponent);
begin
  inherited;
  FMouseUpCount   := 0;
  FIntervalOver   := False;
  FFinished       := False;

  FTimer := TTimer.Create(Self);
  FTimer.Enabled  := False;

  FTimer.Interval := DOUBLE_CLICK_TIME;
  {$IFDEF MSWINDOWS}
  FTimer.Interval := GetDoubleClickTime;
  {$ENDIF}
  {$IFDEF MACOS}
  // OSX 用の処理
  {$ENDIF}

  FTimer.OnTimer  := Timer_Timer;
end;

procedure TBaseForm3D.MouseDown(Button: TMouseButton; Shift: TShiftState; X,
  Y: Single);
begin
  try
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) and ((FMouseUpCount = 0) or FFinished) then
      begin
        FStartPoint   := PointF(X, Y);
        FIntervalOver := False;
        FFinished     := False;
        if Assigned(FMouseDblClickEvent) then
          FTimer.Enabled := True;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseForm3D.MouseUp(Button: TMouseButton; Shift: TShiftState; X,
  Y: Single);
begin
  try
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        FEndPoint := PointF(X, Y);
        Inc(FMouseUpCount);
        if not Assigned(FMouseDblClickEvent) then
          FIntervalOver := True;
        if FIntervalOver then
          Timer_Timer(FTimer);
      end;
  finally
    inherited;
  end;
end;

function TBaseForm3D.IsMouseOnControl(X, Y: Single): Boolean;
begin
  result := (IControl(ObjectAtPoint(ClientToScreen(PointF(X, Y)))) <> nil);
  if result then
    begin
      FTimer.Enabled := False;
      FMouseUpCount := 0;
    end;
end;

procedure TBaseForm3D.Timer_Timer(Sender: TObject);
begin
  FIntervalOver := True;
  if FMouseUpCount = 0 then
    Exit;
  FTimer.Enabled := False;
  if CalcDist(FStartPoint, FEndPoint) < CLICK_JUDGE_DIST then
    begin
      if (FMouseUpCount > 1) then
        begin
          if Assigned(FMouseDblClickEvent) then
            OnDblClick(Self);
        end
      else
        begin
          if Assigned(FMouseClickEvent) then
            OnClick(Self);
        end;
    end;
  FFinished := True;
  FMouseUpCount := 0;
end;
end.

unit Unit1;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Dialogs, FMX.Platform, FMX.BaseForm;

type
  TForm1 = class(TBaseFormHD)
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Form1Click(Sender: TObject);
    procedure Form1DblClick(Sender: TObject);
  private
    { private 宣言 }
  public
    { public 宣言 }
  end;

var
  Form1: TForm1;

implementation

{$R *.fmx}

{ TForm1 }

procedure TForm1.FormCreate(Sender: TObject);
begin
  OnClick    := Form1Click;    // クリックイベントをアサイン
  OnDblClick := Form1DblClick; // ダブルクリックイベントをアサイン
end;

procedure TForm1.Form1Click(Sender: TObject);
begin
  ShowMessage('Clicked!');
end;

procedure TForm1.Form1DblClick(Sender: TObject);
begin
  ShowMessage('Double Clicked!');
end;

end.

procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Single);
begin
  if ssDouble in Shift then
    ShowMessage('Double Clicked!')
  else
    ShowMessage('Clicked!');
end;

procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Single);
begin
  if ssDouble in Shift then
    ShowMessage('Double Clicked!')
  else
    ShowMessage('Clicked!');
end;

procedure TForm1.FormMouseDown(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Single);
begin
  if ssDouble in Shift then
    ShowMessage('Double Clicked!');
end;

procedure TForm1.FormMouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Single);
begin
  ShowMessage('Clicked!');
end;

# VCL の挙動とは異なりますが、
# この後にダブルクリック判定を組み込むのが楽になります。

unit FMX.BaseForm;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes,
  {$IFDEF MSWINDOWS}
  Winapi.Windows,
  {$ENDIF}
  {$IFDEF MACOS}
  MacAPI.Foundation, MacAPI.AppKit,
  {$ENDIF}
  FMX.Types, FMX.Forms, FMX.Platform;

type
  TClickType = (ctNone, ctClick, ctDblClick);

  { TBaseFormHD }
  TBaseFormHD = class(TForm)
  private
    { private 宣言 }
    FDoubleClickTime: Extended;
    FStartPoint: TPointF;
    FStartTime: Extended;
    FMouseUpCount: SmallInt;
    FMouseClickEvent: TNotifyEvent;
    FMouseDblClickEvent: TNotifyEvent;
    function IsMouseOnControl(X, Y: Single): Boolean;
  public
    { public 宣言 }
    constructor Create(AOwner: TComponent); override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
  published
    { published 宣言 }
    property OnClick: TNotifyEvent read FMouseClickEvent write FMouseClickEvent;
    property OnDblClick: TNotifyEvent read FMouseDblClickEvent write FMouseDblClickEvent;
  end;

  { TBaseForm3D }
  TBaseForm3D = class(TForm3D)
  private
    { private 宣言 }
    FDoubleClickTime: Extended;
    FStartPoint: TPointF;
    FStartTime: Extended;
    FMouseUpCount: SmallInt;
    FMouseClickEvent: TNotifyEvent;
    FMouseDblClickEvent: TNotifyEvent;
    function IsMouseOnControl(X, Y: Single): Boolean;
  public
    { public 宣言 }
    constructor Create(AOwner: TComponent); override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
  published
    { published 宣言 }
    property OnClick: TNotifyEvent read FMouseClickEvent write FMouseClickEvent;
    property OnDblClick: TNotifyEvent read FMouseDblClickEvent write FMouseDblClickEvent;
  end;

const
  CLICK_JUDGE_DIST  =   4; // クリック判定用
  DOUBLE_CLICK_TIME = 500; // ダブルクリック判定時間 (規定)

implementation

function Get_Tick: Extended;
{$IF FireMonkeyVersion >= 17.0}
begin
  result := IFMXTimerService(TPlatformServices.Current.GetPlatformService(IFMXTimerService)).GetTick;
end;
{$ELSE}
begin
  result := Platform.GetTick;
end;
{$IFEND}

function CalcDist(a, b: TPointF): Single;
begin
  result := Sqrt(Sqr(a.X - b.X) + Sqr(a.Y - b.Y));
end;

{ TBaseFormHD }

constructor TBaseFormHD.Create(AOwner: TComponent);
begin
  inherited;
  FMouseUpCount    := 0;

  FDoubleClickTime := DOUBLE_CLICK_TIME  / 1000;
  {$IFDEF MSWINDOWS}
  FDoubleClickTime := GetDoubleClickTime / 1000;
  {$ENDIF}
  {$IFDEF MACOS}
  // OSX 用の処理
  {$ENDIF}
end;

procedure TBaseFormHD.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
begin
  try
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        if (FMouseUpCount = 0) then
          begin
            FStartPoint := PointF(X, Y);
            FStartTime  := Get_Tick;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseFormHD.MouseUp(Button: TMouseButton; Shift: TShiftState; X,
  Y: Single);
var
  ClickType: TClickType;
begin
  try
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        Inc(FMouseUpCount);

        ClickType := ctNone;
        if Assigned(FMouseDblClickEvent) then
          begin
            if (FMouseUpCount > 1) then
              ClickType := ctDblClick
            else
              begin
                while ((Get_Tick - FStartTime) < FDoubleClickTime) do
                  begin
                    if (FMouseUpCount > 1) then
                      Exit;
                    Application.ProcessMessages;
                  end;
                if (FMouseUpCount = 1) then
                  ClickType := ctClick;
              end;
          end
        else
          ClickType := ctClick;

        if (ClickType <> ctNone) then
          begin
            if (CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST) then
              case ClickType of
                ctClick:
                  if Assigned(FMouseClickEvent) then
                    OnClick(Self);
                ctDblClick:
                  if Assigned(FMouseDblClickEvent) then
                    OnDblClick(Self);
              end;
            FMouseUpCount := 0;
          end;
      end;
  finally
    inherited;
  end;
end;

function TBaseFormHD.IsMouseOnControl(X, Y: Single): Boolean;
begin
  result := (IControl(ObjectAtPoint(ClientToScreen(PointF(X, Y)))) <> nil);
  if result then
    FMouseUpCount := 0;
end;

{ TBaseForm3D }

constructor TBaseForm3D.Create(AOwner: TComponent);
begin
  inherited;
  FMouseUpCount    := 0;

  FDoubleClickTime := DOUBLE_CLICK_TIME  / 1000;
  {$IFDEF MSWINDOWS}
  FDoubleClickTime := GetDoubleClickTime / 1000;
  {$ENDIF}
  {$IFDEF MACOS}
  // OSX 用の処理
  {$ENDIF}
end;

procedure TBaseForm3D.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
begin
  try
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        if (FMouseUpCount = 0) then
          begin
            FStartPoint := PointF(X, Y);
            FStartTime  := Get_Tick;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseForm3D.MouseUp(Button: TMouseButton; Shift: TShiftState; X,
  Y: Single);
var
  ClickType: TClickType;
begin
  try
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        Inc(FMouseUpCount);

        ClickType := ctNone;
        if Assigned(FMouseDblClickEvent) then
          begin
            if (FMouseUpCount > 1) then
              ClickType := ctDblClick
            else
              begin
                while ((Get_Tick - FStartTime) < FDoubleClickTime) do
                  begin
                    if (FMouseUpCount > 1) then
                      Exit;
                    Application.ProcessMessages;
                  end;
                if (FMouseUpCount = 1) then
                  ClickType := ctClick;
              end;
          end
        else
          ClickType := ctClick;

        if (ClickType <> ctNone) then
          begin
            if (CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST) then
              case ClickType of
                ctClick:
                  if Assigned(FMouseClickEvent) then
                    OnClick(Self);
                ctDblClick:
                  if Assigned(FMouseDblClickEvent) then
                    OnDblClick(Self);
              end;
            FMouseUpCount := 0;
          end;
      end;
  finally
    inherited;
  end;
end;

function TBaseForm3D.IsMouseOnControl(X, Y: Single): Boolean;
begin
  result := (IControl(ObjectAtPoint(ClientToScreen(PointF(X, Y)))) <> nil);
  if result then
    FMouseUpCount := 0;
end;
end.

// -----------------------------------------------------------------------------
// OnClick / OnDblClick を備えたベースフォーム
// TTimer 版
// -----------------------------------------------------------------------------
unit FMX.BaseForm;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes,
  {$IFDEF MSWINDOWS}
  Winapi.Windows,
  {$ENDIF}
  {$IFDEF MACOS}
  MacAPI.Foundation, MacAPI.AppKit,
  {$ENDIF}
  FMX.Types, FMX.Forms;

type
  { TBaseFormHD }
  TBaseFormHD = class(TForm)
    procedure Timer_Timer(Sender: TObject);
  private
    { private 宣言 }
    FTimer: TTimer;
    FStartPoint: TPointF;
    FIntervalOver: Boolean;
    FIsMouseUp: Boolean;
    FMouseClickEvent: TNotifyEvent;
    FMouseDblClickEvent: TNotifyEvent;
    function IsMouseOnControl(X, Y: Single): Boolean;
    procedure GenerateClickEvent;
  public
    { public 宣言 }
    constructor Create(AOwner: TComponent); override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
  published
    { published 宣言 }
    property OnClick: TNotifyEvent read FMouseClickEvent write FMouseClickEvent;
    property OnDblClick: TNotifyEvent read FMouseDblClickEvent write FMouseDblClickEvent;
  end;

  { TBaseForm3D }
  TBaseForm3D = class(TForm3D)
    procedure Timer_Timer(Sender: TObject);
  private
    { private 宣言 }
    FTimer: TTimer;
    FStartPoint: TPointF;
    FIntervalOver: Boolean;
    FIsMouseUp: Boolean;
    FMouseClickEvent: TNotifyEvent;
    FMouseDblClickEvent: TNotifyEvent;
    function IsMouseOnControl(X, Y: Single): Boolean;
    procedure GenerateClickEvent;
  public
    { public 宣言 }
    constructor Create(AOwner: TComponent); override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
  published
    { published 宣言 }
    property OnClick: TNotifyEvent read FMouseClickEvent write FMouseClickEvent;
    property OnDblClick: TNotifyEvent read FMouseDblClickEvent write FMouseDblClickEvent;
  end;

const
  CLICK_JUDGE_DIST  =   4; // クリック判定用
  DOUBLE_CLICK_TIME = 500; // ダブルクリック判定時間 (規定)

implementation

function CalcDist(a, b: TPointF): Single;
begin
  result := Sqrt(Sqr(a.X - b.X) + Sqr(a.Y - b.Y));
end;

{ TBaseFormHD }

constructor TBaseFormHD.Create(AOwner: TComponent);
begin
  inherited;
  FTimer := TTimer.Create(Self);
  FTimer.Enabled  := False;

  FTimer.Interval := DOUBLE_CLICK_TIME;
  {$IFDEF MSWINDOWS}
  FTimer.Interval := GetDoubleClickTime;
  {$ENDIF}
  {$IFDEF MACOS}
  // OSX 用の処理
  {$ENDIF}

  FTimer.OnTimer  := Timer_Timer;
end;

procedure TBaseFormHD.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
begin
  try
    if not (Assigned(FMouseClickEvent) or Assigned(FMouseDblClickEvent)) then
      Exit;
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft)  then
      begin
        if (ssDouble in Shift) then
          begin
            FTimer.Enabled  := False;
            if CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST then
              if Assigned(FMouseDblClickEvent) then
                OnDblClick(Self);
          end
        else
          begin
            FStartPoint := PointF(X, Y);
            if Assigned(FMouseDblClickEvent) then
              begin
                FIntervalOver  := False;
                FIsMouseUp     := False;
                FTimer.Enabled := True;
              end;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseFormHD.MouseUp(Button: TMouseButton; Shift: TShiftState; X,
  Y: Single);
begin
  try
    if not (Assigned(FMouseClickEvent) or Assigned(FMouseDblClickEvent)) then
      Exit;
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        if CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST then
          begin
            if (not Assigned(FMouseDblClickEvent)) or FIntervalOver then
              GenerateClickEvent
            else
              FIsMouseUp := True;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseFormHD.Timer_Timer(Sender: TObject);
begin
  FIntervalOver := True;
  FTimer.Enabled  := False;
  if FIsMouseUp then
    GenerateClickEvent;
end;

function TBaseFormHD.IsMouseOnControl(X, Y: Single): Boolean;
begin
  result := (IControl(ObjectAtPoint(ClientToScreen(PointF(X, Y)))) <> nil);
  if result then
    FTimer.Enabled  := False;
end;

procedure TBaseFormHD.GenerateClickEvent;
begin
  FIntervalOver := False;
  FTimer.Enabled  := False;
  if Assigned(FMouseClickEvent) then
    OnClick(Self);
end;

{ TBaseForm3D }

constructor TBaseForm3D.Create(AOwner: TComponent);
begin
  inherited;
  FTimer := TTimer.Create(Self);
  FTimer.Enabled  := False;

  FTimer.Interval := DOUBLE_CLICK_TIME;
  {$IFDEF MSWINDOWS}
  FTimer.Interval := GetDoubleClickTime;
  {$ENDIF}
  {$IFDEF MACOS}
  // OSX 用の処理
  {$ENDIF}

  FTimer.OnTimer  := Timer_Timer;
end;

procedure TBaseForm3D.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
begin
  try
    if not (Assigned(FMouseClickEvent) or Assigned(FMouseDblClickEvent)) then
      Exit;
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft)  then
      begin
        if (ssDouble in Shift) then
          begin
            FTimer.Enabled  := False;
            if CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST then
              if Assigned(FMouseDblClickEvent) then
                OnDblClick(Self);
          end
        else
          begin
            FStartPoint := PointF(X, Y);
            if Assigned(FMouseDblClickEvent) then
              begin
                FIntervalOver  := False;
                FIsMouseUp     := False;
                FTimer.Enabled := True;
              end;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseForm3D.MouseUp(Button: TMouseButton; Shift: TShiftState; X,
  Y: Single);
begin
  try
    if not (Assigned(FMouseClickEvent) or Assigned(FMouseDblClickEvent)) then
      Exit;
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        if CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST then
          begin
            if (not Assigned(FMouseDblClickEvent)) or FIntervalOver then
              GenerateClickEvent
            else
              FIsMouseUp := True;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseForm3D.Timer_Timer(Sender: TObject);
begin
  FIntervalOver := True;
  FTimer.Enabled  := False;
  if FIsMouseUp then
    GenerateClickEvent;
end;

function TBaseForm3D.IsMouseOnControl(X, Y: Single): Boolean;
begin
  result := (IControl(ObjectAtPoint(ClientToScreen(PointF(X, Y)))) <> nil);
  if result then
    FTimer.Enabled  := False;
end;

procedure TBaseForm3D.GenerateClickEvent;
begin
  FIntervalOver := False;
  FTimer.Enabled  := False;
  if Assigned(FMouseClickEvent) then
    OnClick(Self);
end;
end.

// -----------------------------------------------------------------------------
// OnClick / OnDblClick を備えたベースフォーム
// GetTick 版
// -----------------------------------------------------------------------------
unit FMX.BaseForm;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes,
  {$IFDEF MSWINDOWS}
  Winapi.Windows,
  {$ENDIF}
  {$IFDEF MACOS}
  MacAPI.Foundation, MacAPI.AppKit,
  {$ENDIF}
  FMX.Types, FMX.Forms, FMX.Platform;

type
  { TBaseFormHD }
  TBaseFormHD = class(TForm)
  private
    { private 宣言 }
    FDoubleClickTime: Extended;
    FStartPoint: TPointF;
    FStartTime: Extended;
    FDoubleClicked: Boolean;
    FMouseClickEvent: TNotifyEvent;
    FMouseDblClickEvent: TNotifyEvent;
    FIsMouseUp: Boolean;
    FIntervalOver: Boolean;
    function IsMouseOnControl(X, Y: Single): Boolean;
    procedure GenerateClickEvent;
  public
    { public 宣言 }
    constructor Create(AOwner: TComponent); override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
  published
    { published 宣言 }
    property OnClick: TNotifyEvent read FMouseClickEvent write FMouseClickEvent;
    property OnDblClick: TNotifyEvent read FMouseDblClickEvent write FMouseDblClickEvent;
  end;

  { TBaseForm3D }
  TBaseForm3D = class(TForm3D)
  private
    { private 宣言 }
    FDoubleClickTime: Extended;
    FStartPoint: TPointF;
    FStartTime: Extended;
    FDoubleClicked: Boolean;
    FMouseClickEvent: TNotifyEvent;
    FMouseDblClickEvent: TNotifyEvent;
    FIsMouseUp: Boolean;
    FIntervalOver: Boolean;
    function IsMouseOnControl(X, Y: Single): Boolean;
    procedure GenerateClickEvent;
  public
    { public 宣言 }
    constructor Create(AOwner: TComponent); override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Single); override;
  published
    { published 宣言 }
    property OnClick: TNotifyEvent read FMouseClickEvent write FMouseClickEvent;
    property OnDblClick: TNotifyEvent read FMouseDblClickEvent write FMouseDblClickEvent;
  end;

const
  CLICK_JUDGE_DIST  =   4; // クリック判定用
  DOUBLE_CLICK_TIME = 500; // ダブルクリック判定時間 (規定)

implementation

function Get_Tick: Extended;
{$IF FireMonkeyVersion >= 17.0}
begin
  result := IFMXTimerService(TPlatformServices.Current.GetPlatformService(IFMXTimerService)).GetTick;
end;
{$ELSE}
begin
  result := Platform.GetTick;
end;
{$IFEND}

function CalcDist(a, b: TPointF): Single;
begin
  result := Sqrt(Sqr(a.X - b.X) + Sqr(a.Y - b.Y));
end;

{ TBaseFormHD }

constructor TBaseFormHD.Create(AOwner: TComponent);
begin
  inherited;
  FDoubleClickTime := DOUBLE_CLICK_TIME  / 1000;
  {$IFDEF MSWINDOWS}
  FDoubleClickTime := GetDoubleClickTime / 1000;
  {$ENDIF}
  {$IFDEF MACOS}
  // OSX 用の処理
  {$ENDIF}
end;

procedure TBaseFormHD.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
begin
  try
    if not (Assigned(FMouseClickEvent) or Assigned(FMouseDblClickEvent)) then
      Exit;
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        if (ssDouble in Shift) then
          begin
            FDoubleClicked := True;
            if CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST then
              if Assigned(FMouseDblClickEvent) then
                OnDblClick(Self);
          end
        else
          begin
            FStartPoint    := PointF(X, Y);
            FStartTime     := Get_Tick;
            FDoubleClicked := False;
            FIsMouseUp     := False;
            FIntervalOver  := False;
            while ((Get_Tick - FStartTime) < FDoubleClickTime) do
              begin
                Application.ProcessMessages;
                if FDoubleClicked then
                  Exit;
              end;
            FIntervalOver := not FDoubleClicked;
            if FIsMouseUp then
              GenerateClickEvent;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseFormHD.MouseUp(Button: TMouseButton; Shift: TShiftState; X,
  Y: Single);
begin
  try
    if not (Assigned(FMouseClickEvent) or Assigned(FMouseDblClickEvent)) then
      Exit;
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        if CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST then
          begin
            if (not Assigned(FMouseDblClickEvent)) or FIntervalOver then
              GenerateClickEvent
            else
              FIsMouseUp := True;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseFormHD.GenerateClickEvent;
begin
  FDoubleClicked := False;
  if Assigned(FMouseClickEvent) then
    OnClick(Self);
end;

function TBaseFormHD.IsMouseOnControl(X, Y: Single): Boolean;
begin
  result := (IControl(ObjectAtPoint(ClientToScreen(PointF(X, Y)))) <> nil);
end;

{ TBaseForm3D }

constructor TBaseForm3D.Create(AOwner: TComponent);
begin
  inherited;
  FDoubleClickTime := DOUBLE_CLICK_TIME  / 1000;
  {$IFDEF MSWINDOWS}
  FDoubleClickTime := GetDoubleClickTime / 1000;
  {$ENDIF}
  {$IFDEF MACOS}
  // OSX 用の処理
  {$ENDIF}
end;

procedure TBaseForm3D.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Single);
begin
  try
    if not (Assigned(FMouseClickEvent) or Assigned(FMouseDblClickEvent)) then
      Exit;
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        if (ssDouble in Shift) then
          begin
            FDoubleClicked := True;
            if CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST then
              if Assigned(FMouseDblClickEvent) then
                OnDblClick(Self);
          end
        else
          begin
            FStartPoint    := PointF(X, Y);
            FStartTime     := Get_Tick;
            FDoubleClicked := False;
            FIsMouseUp     := False;
            FIntervalOver  := False;
            while ((Get_Tick - FStartTime) < FDoubleClickTime) do
              begin
                Application.ProcessMessages;
                if FDoubleClicked then
                  Exit;
              end;
            FIntervalOver := not FDoubleClicked;
            if FIsMouseUp then
              GenerateClickEvent;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseForm3D.MouseUp(Button: TMouseButton; Shift: TShiftState; X,
  Y: Single);
begin
  try
    if not (Assigned(FMouseClickEvent) or Assigned(FMouseDblClickEvent)) then
      Exit;
    if IsMouseOnControl(X, Y) then
      Exit;
    if (Button = TMouseButton.mbLeft) then
      begin
        if CalcDist(FStartPoint, PointF(X, Y)) < CLICK_JUDGE_DIST then
          begin
            if (not Assigned(FMouseDblClickEvent)) or FIntervalOver then
              GenerateClickEvent
            else
              FIsMouseUp := True;
          end;
      end;
  finally
    inherited;
  end;
end;

procedure TBaseForm3D.GenerateClickEvent;
begin
  FDoubleClicked := False;
  if Assigned(FMouseClickEvent) then
    OnClick(Self);
end;

function TBaseForm3D.IsMouseOnControl(X, Y: Single): Boolean;
begin
  result := (IControl(ObjectAtPoint(ClientToScreen(PointF(X, Y)))) <> nil);
end;
end.

var
  F: Single;
  I: Integer;
begin
  F := -0.5;

  // display the hexadecimal representation of the single precision floating-point value
  // leftmost bytes are the most significant
  for I := High(F.Bytes) downto Low(F.Bytes) do
    Write(IntToHex(F.Bytes[I], 2) + ' ');
  Writeln;

  // display the value
  Writeln(FloatToStr(F));

   // ...
end;

var
  s: string;
begin
  s := 'ABCDEFG'.Substring(2, 3);
  s := s.ToLower;
  Writeln(s);
end;

uses
  ..., FMX.Sensors;

  ...
    procedure FormCreate(Sender: TObject);
    procedure btnActiveClick(Sender: TObject);
    procedure DataChanged(Sender: TObject);
  private
    { private 宣言 }
    LightSensor: TLightSensor;
  public
    { public 宣言 }
  end;

...

procedure TForm1.FormCreate(Sender: TObject);
begin
  // 照度センサーの生成とイベントハンドラ設定
  LightSensor := TLightSensor.Create(Self);
  LightSensor.OnDataChanged := DataChanged;
end;

procedure TForm1.btnActiveClick(Sender: TObject);
begin
  // センサーをアクティブに
  LightSensor.Active := True;
end;

procedure TForm1.DataChanged(Sender: TObject);
begin
  // データが更新された
  lblLUX.Text := Format('%f LUX', [LightSensor.Sensor.Lux]);
end;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, System.Sensors;

type
  TForm3 = class(TForm)
    Button2: TButton;
    Label2: TLabel;
    Memo2: TMemo;
    procedure Button2Click(Sender: TObject);
  private
    { Private declarations }
    NumberOfSensors : integer;
  public
    { Public declarations }
  end;

var
  Form1: TForm3;

implementation

{$R *.dfm}

uses System.TypInfo;

procedure TForm3.Button2Click(Sender: TObject);
var
  i : integer;
begin
  // get list of found sensors - if any
  TSensorManager.Current.Active := true;
  NumberofSensors := TSensorManager.Current.Count;
  Label2.Caption := 'Sensors: '+IntToStr(NumberOfSensors);
  Memo2.Lines.Clear;
  for i := 0 to NumberOfSensors-1 do begin
    Memo2.Lines.Add(
      IntToStr(i)
      + ': '
      + TSensorManager.Current.Sensors[i].Name
      + '", Category: '
      + GetEnumName(System.TypeInfo(TSensorCategory),
            Ord(TSensorManager.Current.Sensors[i].Category))
    );
  end;
  TSensorManager.Current.Active := false;
end;

procedure TForm1.SelectionPoint3D_XTrack(Sender: TObject);
begin
  RoundCube1.RotationAngle.X := -SelectionPoint3D_X.Angle;
end;

procedure TForm1.SelectionPoint3D_YTrack(Sender: TObject);
begin
  RoundCube1.RotationAngle.Y := -SelectionPoint3D_Y.Angle;
end;

procedure TForm1.SelectionPoint3D_ZTrack(Sender: TObject);
begin
  RoundCube1.RotationAngle.Z := -SelectionPoint3D_Z.Angle;
end;