(* ImageEn Build 7.0.0.06.2637 @ 7-4-17 14:58:42.679 *)
(*
Copyright (c) 1998-2017 by Carlotta Calandra. All rights reserved.
Copyright (c) 2011-2017 by Xequte Software.

This software comes without express or implied warranty.
In no case shall the author be liable for any damage or unwanted behavior of any
computer hardware and/or software.

Author grants you the right to include the component
in your application, whether COMMERCIAL, SHAREWARE, or FREEWARE.

ImageEn, IEvolution and ImageEn ActiveX may not be included in any
commercial, shareware or freeware libraries or components.

www.ImageEn.com
*)

(*
File: iexRulers.pas
Description: Provides rulers for use by TImageEnView and TRulerBox
File version 1010
Doc revision 1002
*)

unit iexRulers;

{$R-}
{$Q-}

{$I ie.inc}


interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls,
  {$ifdef IEHASTYPES} Types, {$endif}
  iegdiplus;

const
  IEMAXPOLYGLINES = 10;

type
  TIEPolyg = array[0..IEMAXPOLYGLINES - 1] of TPoint;

{!!
<FS>TGripKind

<FM>Declaration<FC>
TGripKind = (gkTriangle, gkLeftTriangle, gkRightTriangle, gkArrow, gkArrow2, gkLine, gkNone);

<FM>Description<FN>
<TABLE>
<R> <H>Item</H> <H>Description</H> </R>
<R> <C><FC>gkTriangle<FN></C> <C>Triangle</C> </R>
<R> <C><FC>gkLeftTriangle<FN></C> <C>Triangle pointing to the left</C> </R>
<R> <C><FC>gkRightTriangle<FN></C> <C>Triangle pointing to the right</C> </R>
<R> <C><FC>gkArrow<FN></C> <C>A standard arrow</C> </R>
<R> <C><FC>gkArrow2<FN></C> <C>A track bar style arrow</C> </R>
<R> <C><FC>gkLine<FN></C> <C>Line only</C> </R>
<R> <C><FC>gkNone<FN></C> <C>Grip is not visible</C> </R>
</TABLE>
!!}
  TGripKind = (gkTriangle, gkLeftTriangle, gkRightTriangle, gkArrow, gkArrow2, gkLine, gkNone);


{!!
<FS>TGripsDir

<FM>Declaration<FC>
}
  TGripsDir = (gdUp, gdDown);
{!!}


{!!
<FS>TGripsXDir

<FM>Declaration<FC>
}
  TGripsXDir = (gdLeft, gdRight);
{!!}

{!!
<FS>TRulerDir

<FM>Declaration<FC>
}
  TRulerDir = (rdHorizontal, rdVertical);
{!!}

{!!
<FS>TRulerDirs

<FM>Declaration<FC>

  TRulerDirs = Set of <A TRulerDir>;
!!}
  TRulerDirs = Set of TRulerDir;


{!!
<FS>TIERulerUnits

<FM>Declaration<FC>
}
  TIERulerUnits = (ieruPixels, ieruInches, ieruMillimeters, ieruCentimeters);
{!!}

{!!
<FS>TIERulerSnapping

<FM>Declaration<FC>
TIERulerSnapping = (iesnNone, iesnSnapToTick, iesnSnapToLabel, iesnSnapToWholeNumber);

<FM>Description<FN>
<TABLE>
<R> <H>Item</H> <H>Description</H> </R>
<R> <C><FC>iesnNone<FN></C> <C>Do not adjust grip positions</C> </R>
<R> <C><FC>iesnSnapToTick<FN></C> <C>Automatically move grips to the nearest <L TIEViewRulerParams.Frequency>tick</L></C> </R>
<R> <C><FC>iesnSnapToLabel<FN></C> <C>Automatically move grips to the nearest <L TIEViewRulerParams.LabelFrequency>label</L> (long tick)</C> </R>
<R> <C><FC>iesnSnapToWholeNumber<FN></C> <C>Automatically move grips to the nearest whole value on the ruler (e.g. move to 2.0 inches)</C> </R>
</TABLE>

Default: iesnNone

<FM>Example<FC>
// Snap to the nearest label tick
ImageEnView1.RulerParams.SnapGrips := iesnSnapToLabel;

// Snap to the nearest whole number on the ruler
ImageEnView1.RulerParams.SnapGrips := iesnSnapToWholeNumber;

!!}
  TIERulerSnapping = (iesnNone, iesnSnapToTick, iesnSnapToLabel, iesnSnapToWholeNumber);


{!!
<FS>TIERulerPosBase

<FM>Declaration<FC>
}
  TIERulerPosBase = (ierbRuler, ierbBitmap, ierbScreen);
{!!}

{!!
<FS>TRulerGripPosChangeEvent

<FM>Declaration<FC>
}
  TRulerGripPosChangeEvent = procedure(Sender: TObject; RulerDir: TRulerDir; Grip: integer; NewPos: Double) of object;
{!!}

{!!
<FS>TRulerClickEvent

<FM>Declaration<FC>
}
  TRulerClickEvent = procedure(Sender: TObject; RulerDir: TRulerDir; Ps: double) of object;
{!!}

{!!
<FS>TRulerGripClickEvent

<FM>Declaration<FC>
}
  TRulerGripClickEvent = procedure(Sender: TObject; RulerDir: TRulerDir; Grip: integer; GripPos: Double) of object;
{!!}

// Internal only
  TRulerSetGripPosEvent = procedure(Sender: TObject; var GripPos: double) of object;

  // Internal class for handling and display the rulers of TImageEnView and TRulerBox
  TIERuler = class
  private
    { Private declarations }
    fOwner: TControl;
    fBitmap: TBitmap;
    fBackground: TColor;
    fGrips: TList;          // list of rips
    fGripBaseDim: integer;  // base size of grip (triangles)
    fSelGrip: integer;      // selected grip (-1=none)
    fSelGripSt: integer;    // starting position during mouse-dragging
    fMX1, fMY1: integer;    // initial mouse coordinate during mouse-dragging
    fGripsDir: TGripsDir;   // direction for all grips
    fShowRuler: boolean;    // ruler + numeric labels
    fViewPos: double;       // starting ruler position
    fDPU: double;           // DotPerUnit - relation between ruler and pixels
    fFrequency: double;     // line frequency (Unit based)
    fLabelFreq: double;     // label frequency (Unit based)
    fRulerColor: TColor;    // ruler color
    fRulerDir: TRulerDir;   // ruler orientation
    fViewMin, fViewMax: double; // Max and Min for fViewPos
    fFitInView: boolean;    // adjust fDPU from fViewMin and fViewMax
    fHexLabels: boolean;    // if true display labels in hex
    fMaxGripHeight: integer;
    fInverted: boolean;      // ruler is inverted
    fScrollRate: double;     // scroll rate
    fOffsetX, fOffsetY: integer;        // horizontal or vertical offset
    fLabelPrecision: Integer;
    fMinLabelSpacing: Integer;
    fGripPenColor : TColor;
    fGripKindDefault: TGripKind;
    fGripColorDefault : TColor;
    fLockUpdateCount: Integer; // When > 0 updating is disabled
    fFont: TFont;
    fGripIndexOffset: Integer; // When used by a TImageEnView, grip 0 is used to show the cursor position. We hide this from the user by offsetting the grip indexes/count by 1
    fShowBorder: Boolean;

    procedure SetBackground(bk: TColor);
    procedure SetGripsCount(v: integer);
    function GetGripsCount: integer;
    procedure SetGripsPos(i: integer; p: double);
    function GetGripsPos(i: integer): double;
    procedure SetGripsColor(i: integer; p: TColor);
    function GetGripsColor(i: integer): TColor;
    procedure SetGripBaseDim(v: integer);
    procedure SetGripsKind(i: integer; v: TGripKind);
    function GetGripsKind(i: integer): TGripKind;
    procedure SetGripsDir(v: TGripsDir);
    procedure SetShowRuler(v: boolean);
    procedure SetViewPos(v: double);
    procedure SetDPU(v: double);
    procedure SetFrequency(v: double);
    procedure SetLabelFreq(v: double);
    procedure SetRulerColor(v: TColor);
    procedure SetRulerDir(v: TRulerDir);
    procedure SetGripsMax(i: integer; v: double);
    procedure SetGripsMin(i: integer; v: double);
    function GetGripsMax(i: integer): double;
    function GetGripsMin(i: integer): double;
    procedure SetViewMin(v: double);
    procedure SetViewMax(v: double);
    procedure SetFitInView(v: boolean);
    procedure SetHexLabels(v: boolean);
    procedure SetInverted(v: boolean);
    procedure SetOffsetX(v: integer);
    procedure SetOffsetY(v: integer);
    procedure SetLabelPrecision(v: integer);
    procedure SetMinLabelSpacing(v: integer);
    procedure SetGripPenColor(const Value: TColor);
    procedure SetGripKindDefault(const Value: TGripKind);
    procedure SetGripColorDefault(const Value: TColor);

    function GetClickedGrip(x, y: integer): integer;
    procedure GetGripPoly(gn: integer; var poly: TIEPolyg);
    procedure GetGripRect(gn: integer; var rc: TRect);
    function GetRulerHeight: integer;
    procedure RepaintGrips;
    procedure RepaintRuler;
    procedure RepaintBorder;
    function GetXGripPos(gn: integer): integer;
    procedure AdjustGripLimits(gn: integer);
    procedure AdjustViewLimits;
    procedure SetShowBorder(const Value: boolean);

  protected
    { Protected declarations }

    procedure FontChange(Sender: TObject);
  public
    { Public declarations }

    // EVENTS
    fOnRulerGripPosChange: TRulerGripPosChangeEvent;
    fOnRulerGripClick: TRulerGripClickEvent;
    fOnRulerGripDblClick: TRulerGripClickEvent;
    fOnRulerClick: TRulerClickEvent;

    constructor Create(Owner: TControl);
    destructor Destroy; override;
    procedure Update();
    procedure UpdateEx(RepaintAll, DoInvalidate : Boolean);
    procedure LockUpdate();
    procedure UnlockUpdate(RepaintAll: Boolean = True; DoInvalidate: Boolean = True);
    property GripsPos[g: integer]: double read GetGripsPos write SetGripsPos; default;
    property GripsColor[g: integer]: TColor read GetGripsColor write SetGripsColor;
    property GripsKind[g: integer]: TGripKind read GetGripsKind write SetGripsKind;
    property GripsMin[g: integer]: double read GetGripsMin write SetGripsMin;
    property GripsMax[g: integer]: double read GetGripsMax write SetGripsMax;
    property ScrollRate: double read fScrollRate write fScrollRate;

    // Need to handle the following in objects that use this class
    procedure DrawToCanvas(Canvas: TCanvas; X, Y: Integer);
    procedure HandleMouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    procedure HandleMouseMove(Shift: TShiftState; X, Y: Integer);
    procedure HandleMouseMoveEx(Shift: TShiftState; X, Y: Integer; SetGripCallBack: TRulerSetGripPosEvent);
    procedure HandleMouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    procedure UpdateSize(Width, Height: integer);

    property ViewPos: double read fViewPos write SetViewPos;
    property Background: TColor read fBackground write SetBackground default clBtnFace;
    property GripPenColor : TColor read fGripPenColor write SetGripPenColor default clWindowFrame;
    property GripBaseDim: integer read fGripBaseDim write SetGripBaseDim default 12;
    property GripsDir: TGripsDir read fGripsDir write SetGripsDir default gdUp;
    property ShowRuler: boolean read fShowRuler write SetShowRuler default true;
    property DotPerUnit: double read fDPU write SetDPU;
    property Frequency: double read fFrequency write SetFrequency;
    property LabelFrequency: double read fLabelFreq write SetLabelFreq;
    property RulerColor: TColor read fRulerColor write SetRulerColor default clBtnFace;
    property RulerDir: TRulerDir read fRulerDir write SetRulerDir default rdHorizontal;
    property ViewMin: double read fViewMin write SetViewMin;
    property ViewMax: double read fViewMax write SetViewMax;
    property LabelPrecision: integer read fLabelPrecision write SetLabelPrecision default 3;
    property MinLabelSpacing: integer read fMinLabelSpacing write SetMinLabelSpacing default 30;
    property GripKindDefault: TGripKind read fGripKindDefault write SetGripKindDefault default gkTriangle;
    property GripColorDefault: TColor read fGripColorDefault write SetGripColorDefault default clBtnFace;
    property OffsetX: integer read fOffsetX write SetOffsetX default 0;
    property OffsetY: integer read fOffsetY write SetOffsetY default 0;

    property MaxGripHeight: integer read fMaxGripHeight write fMaxGripHeight;
    property Inverted: boolean read fInverted write SetInverted default false;
    property FitInView: boolean read fFitInView write SetFitInView default false;
    property GripsCount: integer read GetGripsCount write SetGripsCount default 1;
    property HexLabels: boolean read fHexLabels write SetHexLabels default false;
    property ShowBorder : boolean read fShowBorder write SetShowBorder default False;

    property LockUpdateCount: integer read fLockUpdateCount;

    property SelectedGrip: integer read fSelGrip write fSelGrip;

    property Font: TFont read fFont;
  end;


{!!
<FS>TIEViewRulerParams

<FM>Description<FN>
Specifies the <L TImageEnView.RulerParams>properties of embedded rulers</L> within a TImageEnView (if <A TImageEnView.ShowRulers> is not []).

<FM>Example<FC>
// Show rulers in TImageEnView
ImageEnView1.ShowRulers := [ rdHorizontal, rdVertical ];

// Set units to CM
ImageEnView1.RulerParams.Units := ieruCentimeters;

// Show grips as a line
ImageEnView1.RulerParams.Units := gkLine;

<FM>Methods and Properties<FN>
<FI>Display<FN>
<TABLE2>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.AlignToImage></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.Color></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.Frequency></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.Font></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.HorzInverted></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.HorzPos></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.LabelFrequency></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.LabelPrecision></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.MinLabelSpacing></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.MeasureColor></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.ShowMeasure></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.ShowBorder></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.Units></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.VertInverted></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.VertPos></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.VertWidth></C> </R>
</TABLE>

<FI>Grip Properties<FN>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.ConstrainGrips></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.CursorGripKind></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.GripHeight></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.GripWidth></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.GripColorDefault></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.GripKindDefault></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.GripPenColor></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.HorzGripsColor></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.HorzGripsCount></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.HorzGripsKind></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.HorzGripsMax></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.HorzGripsMin></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.HorzGripsPos></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.SnapGrips></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.VertGripsColor></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.VertGripsCount></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.VertGripsKind></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.VertGripsMax></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.VertGripsMin></C> </R>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.VertGripsPos></C> </R>
</TABLE>

<FI>Other<FN>
<TABLE2>
<R> <C_IMG_PROPERTY> <C><A TIEViewRulerParams.ScrollRate></C> </R>
</TABLE>

<FM>Events<FN>
<TABLE2>
<R> <C_IMG_EVENT> <C><A TImageEnView.OnRulerClick></C> </R>
<R> <C_IMG_EVENT> <C><A TImageEnView.OnRulerGripClick></C> </R>
<R> <C_IMG_EVENT> <C><A TImageEnView.OnRulerGripDblClick></C> </R>
<R> <C_IMG_EVENT> <C><A TImageEnView.OnRulerGripPosChange></C> </R>
</TABLE>

!!}

  TIEViewRulerParams = class
  private
    { Private declarations }
    fOwner: TControl;
    fHorzRuler: TIERuler;
    fVertRuler: TIERuler;

    fSnapGrips: TIERulerSnapping;
    fConstrainGrips: Boolean;
    fAlignToImage: Boolean;
    fUnits: TIERulerUnits;
    fWasUnits: TIERulerUnits;
    fHorzPos: TGripsDir;
    fVertPos: TGripsXDir;
    fHorzHeight : Integer;
    fVertWidth  : Integer;
    fGripsPosBase: TIERulerPosBase;

    // Limit duplicate paints caused by the MouseMove handling
    fLastMouseMoveX : Integer;
    fLastMouseMoveY : Integer;
    fLastMouseMoveShift : TShiftState;
    fLastMouseMoveResult: Boolean;

    function GetHorzGripsPos(i: integer): double;
    procedure SetHorzGripsPos(i: integer; p: double);
    function GetHorzGripsColor(i: integer): TColor;
    procedure SetHorzGripsColor(i: integer; p: TColor);
    function GetHorzGripsMin(i: integer): double;
    procedure SetHorzGripsMin(i: integer; v: double);
    function GetHorzGripsMax(i: integer): double;
    procedure SetHorzGripsMax(i: integer; v: double);
    function GetVertGripsPos(i: integer): double;
    procedure SetVertGripsPos(i: integer; p: double);
    function GetVertGripsColor(i: integer): TColor;
    procedure SetVertGripsColor(i: integer; p: TColor);
    function GetVertGripsMin(i: integer): double;
    procedure SetVertGripsMin(i: integer; v: double);
    function GetVertGripsMax(i: integer): double;
    procedure SetVertGripsMax(i: integer; v: double);

    function GetMinLabelSpacing: integer;
    procedure SetMinLabelSpacing(v: integer);
    function GetFrequency: double;
    procedure SetFrequency(v: double);
    function GetLabelFrequency: double;
    procedure SetLabelFrequency(v: double);
    function GetShowMeasure: boolean;
    procedure SetShowMeasure(v: boolean);
    function GetMeasureColor: TColor;
    procedure SetMeasureColor(v: TColor);
    function GetColor: TColor;
    procedure SetColor(c: TColor);
    function GetHorzInverted: boolean;
    procedure SetHorzInverted(v: boolean);
    function GetVertInverted: boolean;
    procedure SetVertInverted(v: boolean);
    function GetLabelPrecision: integer;
    procedure SetLabelPrecision(v: integer);
    function GetScrollRate: double;
    procedure SetScrollRate(const Value: double);

    function GetCursorGripKind: TGripKind;
    procedure SetCursorGripKind(const Value: TGripKind);

    function GetGripKindDefault: TGripKind;
    procedure SetGripKindDefault(const Value: TGripKind);
    function GetGripColorDefault: TColor;
    procedure SetGripColorDefault(const Value: TColor);
    function GetGripPenColor: TColor;
    procedure SetGripPenColor(const Value: TColor);

    function GetHorzGripsCount: integer;
    procedure SetHorzGripsCount(v: integer);
    function GetHorzGripsKind(i: integer): TGripKind;
    procedure SetHorzGripsKind(i: integer; v: TGripKind);
    function GetVertGripsCount: integer;
    procedure SetVertGripsCount(v: integer);
    function GetVertGripsKind(i: integer): TGripKind;
    procedure SetVertGripsKind(i: integer; v: TGripKind);

    function GetGripWidth: integer;
    procedure SetGripWidth(v: integer);
    function GetGripHeight: integer;
    procedure SetGripHeight(const Value: integer);

    function GetFont: TFont;
    procedure FontChange(Sender: TObject);

    procedure SetSnapGrips(Value: TIERulerSnapping);
    procedure SetConstrainGrips(Value: Boolean);
    procedure SetAlignToImage(Value: Boolean);
    procedure SetUnits(Value: TIERulerUnits);
    procedure SetHorzPos(Value: TGripsDir);
    procedure SetVertPos(Value: TGripsXDir);
    procedure SetVertWidth(Value: Integer);
    procedure SetHorzHeight(Value: Integer);
    function GetHorzRulerRect: TRect;
    function GetVertRulerRect: TRect;

    procedure MouseMoveOutsideRuler(Shift: TShiftState; X, Y: Integer);
    procedure ConstrainGripsCB(Sender: TObject; var GripPos: double);
    procedure CheckGripBounds();

    function ImageLeftOnHorzRuler(): double;
    function ImageRightOnHorzRuler(): double;
    function ImageTopOnVertRuler(): double;
    function ImageBottomOnVertRuler(): double;

    function ApplyHorzConstraints(value : double; DoSnapGrips : TIERulerSnapping = iesnNone; DoConstrainGrips : Boolean = False) : double;
    function ApplyVertConstraints(value : double; DoSnapGrips : TIERulerSnapping = iesnNone; DoConstrainGrips : Boolean = False) : double;

    function ScrToRulerX(X : Integer) : double;
    function RulerToScrX(Pos : Double) : Integer;
    function ScrToRulerY(Y : Integer) : double;
    function RulerToScrY(Pos : Double) : Integer;

    function ValueToRulerX(Value : double; ValueBase: TIERulerPosBase) : double;
    function RulerToValueX(Pos : double; ValueBase: TIERulerPosBase) : double;
    function ValueToRulerY(Value : double; ValueBase: TIERulerPosBase) : double;
    function RulerToValueY(Pos : Double; ValueBase: TIERulerPosBase) : Double;

    function HorzRulerVisible: Boolean;
    function VertRulerVisible: Boolean;

    procedure LockUpdate();
    procedure UnlockUpdate(DoUpdate: Boolean = True; DoInvalidate: Boolean = True);

    function GetOnRulerClick: TRulerClickEvent;
    function GetOnRulerGripClick: TRulerGripClickEvent;
    function GetOnRulerGripDblClick: TRulerGripClickEvent;
    function GetOnRulerPosChange: TRulerGripPosChangeEvent;
    procedure SetOnRulerClick(const Value: TRulerClickEvent);
    procedure SetOnRulerGripClick(const Value: TRulerGripClickEvent);
    procedure SetOnRulerGripDblClick(const Value: TRulerGripClickEvent);
    procedure SetOnRulerPosChange(const Value: TRulerGripPosChangeEvent);
    function GetShowBorder: boolean;
    procedure SetShowBorder(const Value: boolean);

  protected
    { Protected declarations }
  public
    { Public declarations }
    constructor Create(Owner: TControl);
    destructor Destroy; override;

    property HorzGripsPos[g: integer]: double read GetHorzGripsPos write SetHorzGripsPos;
    property HorzGripsColor[g: integer]: TColor read GetHorzGripsColor write SetHorzGripsColor;
    property HorzGripsKind[g: integer]: TGripKind read GetHorzGripsKind write SetHorzGripsKind;
    property HorzGripsMin[g: integer]: double read GetHorzGripsMin write SetHorzGripsMin;
    property HorzGripsMax[g: integer]: double read GetHorzGripsMax write SetHorzGripsMax;

    property VertGripsPos[g: integer]: double read GetVertGripsPos write SetVertGripsPos;
    property VertGripsColor[g: integer]: TColor read GetVertGripsColor write SetVertGripsColor;
    property VertGripsKind[g: integer]: TGripKind read GetVertGripsKind write SetVertGripsKind;
    property VertGripsMin[g: integer]: double read GetVertGripsMin write SetVertGripsMin;
    property VertGripsMax[g: integer]: double read GetVertGripsMax write SetVertGripsMax;

    property ScrollRate: double read GetScrollRate write SetScrollRate;

    property Color: TColor read GetColor write SetColor default clBtnFace;
    property GripPenColor : TColor read GetGripPenColor write SetGripPenColor default clWindowFrame;
    property GripWidth: integer read GetGripWidth write SetGripWidth default 12;
    property GripHeight: integer read GetGripHeight write SetGripHeight;
    property ShowMeasure: boolean read GetShowMeasure write SetShowMeasure default true;
    property Frequency: double read GetFrequency write SetFrequency;
    property LabelFrequency: double read GetLabelFrequency write SetLabelFrequency;
    property MeasureColor: TColor read GetMeasureColor write SetMeasureColor default clBtnFace;
    property LabelPrecision: integer read GetLabelPrecision write SetLabelPrecision default 3;
    property MinLabelSpacing: integer read GetMinLabelSpacing write SetMinLabelSpacing default 30;

    property CursorGripKind: TGripKind read GetCursorGripKind write SetCursorGripKind default gkLine;
    property GripKindDefault: TGripKind read GetGripKindDefault write SetGripKindDefault default gkTriangle;
    property GripColorDefault: TColor read GetGripColorDefault write SetGripColorDefault default cl3DLight;

    property HorzGripsCount: integer read GetHorzGripsCount write SetHorzGripsCount default 1;
    property VertGripsCount: integer read GetVertGripsCount write SetVertGripsCount default 1;

    property HorzPos: TGripsDir read fHorzPos write SetHorzPos default gdUp;
    property VertPos: TGripsXDir read fVertPos write SetVertPos default gdLeft;
    property HorzInverted: boolean read GetHorzInverted write SetHorzInverted default false;
    property VertInverted: boolean read GetVertInverted write SetVertInverted default false;

    property ShowBorder : boolean read GetShowBorder write SetShowBorder default True;

{!!
<FS>TIEViewRulerParams.GripsPosBase

<FM>Declaration<FC>
property GripsPosBase: <A TIERulerPosBase>;

<FM>Description<FN>
Specifies the type of values used for grip position properties: <A TIEViewRulerParams.HorzGripsPos>, <A TIEViewRulerParams.VertGripsPos>, <A TIEViewRulerParams.HorzGripsMin>, <A TIEViewRulerParams.HorzGripsMax>, <A TIEViewRulerParams.VertGripsMin> and <A TIEViewRulerParams.VertGripsMax>.

The following options are available:
<TABLE>
<R> <H>Item</H> <H>Description</H> </R>
<R> <C><FC>ierbRuler<FN></C> <C>Values are ruler values (taking into account the DPI set by <A TIEViewRulerParams.Units> </C> </R>
<R> <C><FC>ierbBitmap<FN></C> <C>Values are pixel positions on the currently displayed image (regardless of zoom, scrolling, etc)</C> </R>
<R> <C><FC>ierbScreen<FN></C> <C>Values are screen values</C> </R>
</TABLE>

Default: ierbBitmap

<FM>Example<FC>
// Add three grips at 25%, 50% and 75% of the image width
ImageEnView1.RulerParams.HorzGripsCount := 3;
ImageEnView1.RulerParams.GripsPosBase := ierbBitmap; // Units are relative to the bitmap
ImageEnView1.RulerParams.HorzGripsPos[ 0 ] := MulDiv( ImageEnView1.IEBitmap.Width, 1, 4 );
ImageEnView1.RulerParams.HorzGripsPos[ 1 ] := MulDiv( ImageEnView1.IEBitmap.Width, 2, 4 );
ImageEnView1.RulerParams.HorzGripsPos[ 2 ] := MulDiv( ImageEnView1.IEBitmap.Width, 3, 4 );
!!}
    property GripsPosBase: TIERulerPosBase read fGripsPosBase write fGripsPosBase;

    property Font: TFont read GetFont;

    property SnapGrips: TIERulerSnapping read fSnapGrips       write SetSnapGrips      default iesnNone;
    property ConstrainGrips: Boolean     read fConstrainGrips  write SetConstrainGrips default True;
    property AlignToImage: Boolean       read fAlignToImage    write SetAlignToImage   default False;
    property Units: TIERulerUnits        read fUnits           write SetUnits          default ieruPixels;
    property HorzHeight: Integer         read fHorzHeight      write SetHorzHeight     default 40;
    property VertWidth: Integer          read fVertWidth       write SetVertWidth      default 40;

    // EVENTS
    property OnRulerGripPosChange: TRulerGripPosChangeEvent read GetOnRulerPosChange write SetOnRulerPosChange;
    property OnRulerGripClick: TRulerGripClickEvent read GetOnRulerGripClick write SetOnRulerGripClick;
    property OnRulerGripDblClick: TRulerGripClickEvent read GetOnRulerGripDblClick write SetOnRulerGripDblClick;
    property OnRulerClick: TRulerClickEvent read GetOnRulerClick write SetOnRulerClick;

    // Need to handle the following in objects that use this class
    procedure Update(DoInvalidate: Boolean = True);
    procedure Paint(Canvas: TCanvas);
    function HandleMouseMove(Shift: TShiftState; X, Y: Integer): Boolean;
    procedure HandleMouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    procedure HandleMouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
    procedure HandleSpecialKey(CharCode: Word; Shift: TShiftState);

    // Internal Helper properties
    property HorzRulerRect: TRect read GetHorzRulerRect;
    property VertRulerRect: TRect read GetVertRulerRect;

    function RulerAreaLeft: Integer;
    function RulerAreaRight: Integer;
    function RulerAreaTop: Integer;
    function RulerAreaBottom: Integer;

    procedure ScrollToHorzGrip(g: Integer);
    procedure ScrollToVertGrip(g: Integer);
  end;


implementation

uses
  iexThemes, imageenproc, hyieutils, hyiedefs, imageenview, RulerBox, Forms;

{$R-}

type

  TRUGrip = record
    Pos: double;      // position
    Color: TColor;    // color
    Kind: TGripKind;  // type
    Min: double;      // min position
    Max: double;      // max position
    Default: Boolean; // If false, then a custom color and kind have been set
  end;
  PRUGrip = ^TRUGrip;

const
  // Number of points for each grip type
  NumLinesGKind: array[gkTriangle..gkLine] of integer = (
    3, // gkTriangle
    3, // gkLeftTriangle
    3, // gkRightTriangle
    7, // gkArrow
    5, // gkArrow2
    2  // gkLine
    );

  Ruler_To_Text_Spacing = 3; // Distance between ruler and labels

  NON_VIZ = -10000; // Grip is not shown



/////////////////////////////////////////////////////////////////////////////////////////
//                                                                                     //
//                                       TIERULER                                      //
//                                                                                     //
/////////////////////////////////////////////////////////////////////////////////////////


constructor TIERuler.Create(Owner: TControl);
begin
  inherited Create();
  fOwner := Owner;
  IEGDIPLoadLibrary();
  fFont := TFont.Create;
  fGripIndexOffset := 0;
  if fOwner is TImageEnVIew then
    fGripIndexOffset := 1
  else
  if fOwner is TRulerBox then
    fFont.Assign( TRulerBox( fOwner ).Font );
  fFont.OnChange := FontChange;
  fLockUpdateCount := 0;
  fRulerDir := rdHorizontal;
  fOffsetX := 0;
  fOffsetY := 0;
  fInverted := false;
  fHexLabels := false;
  fGripsDir := gdUp;
  fBackground := clBtnFace;
  fGripBaseDim := 12;
  fShowRuler := true;
  fViewPos := 0;
  fDPU := 1;
  fFrequency := 10;
  fLabelFreq := 40;
  fRulerColor := clBtnFace;
  fViewMin := 0;
  fViewMax := 0;
  fMaxGripHeight := 15;
  fOnRulerGripPosChange := nil;
  fOnRulerGripClick := nil;
  fOnRulerGripDblClick := nil;
  fOnRulerClick := nil;
  fFitInView := false;
  fBitmap := TBitmap.create;
  fBitmap.PixelFormat := pf24bit;
  fBitmap.Width := fOwner.Width - fOffsetX;
  fBitmap.Height := fOwner.Height - fOffsetY;
  fGrips := TList.Create;
  fSelGrip := -1;
  fScrollRate := 1.0;
  fLabelPrecision := 3;
  fMinLabelSpacing := 30;
  fGripPenColor := clWindowFrame;
  fGripKindDefault := gkTriangle;
  fGripColorDefault := clBtnFace;
  SetGripsCount(1);
  Update();
end;


destructor TIERuler.Destroy;
var
  i: integer;
begin
  FreeAndNil( fBitmap );
  FreeAndNil( fFont );
  for i := 0 to fGrips.Count-1 do
    dispose(fGrips[i]);
  FreeAndNil(fGrips);
  IEGDIPUnLoadLibrary();
  inherited;
end;


procedure TIERuler.DrawToCanvas(Canvas: TCanvas; X, Y: Integer);
begin
  Canvas.Draw( X + fOffsetX, Y + fOffsetY, fBitmap);
end;


procedure TIERuler.UpdateSize(Width, Height: integer);
begin
  fBitmap.Width  := imax( 0, Width - fOffsetX );
  fBitmap.Height := imax( 0, Height - fOffsetY );
  Update();
end;


procedure TIERuler.SetBackground(bk: TColor);
begin
  fBackground := bk;
  Update();
end;


function TIERuler.GetGripsCount: integer;
begin
  result := fGrips.Count;
end;

procedure TIERuler.SetGripsCount(v: integer);
var
  ex, q: integer;
begin
  ex := fGrips.Count;
  if v <> ex then
  begin
    if v < ex then
      // free
      for q := ex-1 downto v do
        dispose(fGrips[q]);

    fGrips.Count := v;

    // init
    for q := ex to v - 1 do
    begin
      fGrips[q] := new(PRUGrip);
      // defaults
      PRUGrip(fGrips[q])^.Pos     := 0;
      PRUGrip(fGrips[q])^.Color   := GetThemeColor( ietpRulerGripFill, fGripColorDefault );
      PRUGrip(fGrips[q])^.Kind    := fGripKindDefault;
      PRUGrip(fGrips[q])^.Min     := fViewMin;
      PRUGrip(fGrips[q])^.Max     := fViewMax;
      PRUGrip(fGrips[q])^.Default := True;
    end;

    Update();
  end;
end;


procedure TIERuler.SetGripPenColor(const Value: TColor);
begin
  fGripPenColor := Value;
  Update();
end;


function TIERuler.GetGripsPos(i: integer): double;
begin
  if i < fGrips.Count then
    result := PRUGrip(fGrips[i])^.Pos
  else
    result := 0;
end;

procedure TIERuler.SetGripsPos(i: integer; p: double);
begin
  if i < fGrips.Count then
  begin
    PRUGrip(fGrips[i])^.Pos := p;
    AdjustGripLimits(i);
    if assigned( fOnRulerGripPosChange ) and
      ( i >= fGripIndexOffset ) then
      fOnRulerGripPosChange( self, fRulerDir, i - fGripIndexOffset, PRUGrip(fGrips[i])^.Pos );
    UpdateEx( False, True );
  end;
end;


function TIERuler.GetGripsColor(i: integer): TColor;
begin
  if i < fGrips.Count then
    result := PRUGrip(fGrips[i])^.Color
  else
    result := 0;
end;

procedure TIERuler.SetGripsColor(i: integer; p: TColor);
begin
  if i < fGrips.Count then
  begin
    PRUGrip(fGrips[i])^.Color   := p;
    PRUGrip(fGrips[i])^.Default := False;
    Update();
  end;
end;


procedure TIERuler.SetGripColorDefault(const Value: TColor);
var
  i: Integer;
begin
  fGripColorDefault := Value;
  for i := 0 to fGrips.Count - 1 do
    if PRUGrip( fGrips[ i ])^.Default then
      PRUGrip( fGrips[ i ])^.Color := Value;
  Update();
end;


procedure TIERuler.SetGripBaseDim(v: integer);
begin
  fGripBaseDim := v;
  Update();
end;


function TIERuler.GetGripsKind(i: integer): TGripKind;
begin
  result := gkTriangle; // default
  if i < fGrips.Count then
    result := PRUGrip(fGrips[i])^.Kind;
end;

procedure TIERuler.SetGripsKind(i: integer; v: TGripKind);
begin
  if i < fGrips.Count then
  begin
    PRUGrip(fGrips[i])^.Kind := v;
    PRUGrip(fGrips[i])^.Default := False;
    Update();
  end;
end;


procedure TIERuler.SetGripKindDefault(const Value: TGripKind);
var
  i: Integer;
begin
  fGripKindDefault := Value;
  for i := 0 to fGrips.Count - 1 do
    if PRUGrip( fGrips[ i ])^.Default then
      PRUGrip( fGrips[ i ])^.Kind := Value;
  Update();
end;


// return -1 = none
function TIERuler.GetClickedGrip(x, y: integer): integer;
var
  q: integer;
  rc: TRect;
begin
  result := -1;
  for q := fGrips.Count - 1 downto 0 do
  begin
    GetGripRect(q, rc);
    if PtInRect(rc, Point(x, y)) then
    begin
      result := q;
      break;
    end;
  end;
end;


// returns the rectangle where the grip "gn" is contained.
// Right and bottom borders are incremented by 1 to make them compatible with PtInRect.
procedure TIERuler.GetGripRect(gn: integer; var rc: TRect);
var
  poly: TIEPolyg;
  q: integer;
begin
  if GripsKind[ gn ] = gkNone then
  begin
    rc := Rect( 0, 0, -1, -1 );
    exit;
  end;

  GetGripPoly(gn, poly);
  rc.TopLeft := poly[0];
  rc.BottomRight := poly[0];
  for q := 1 to NumLinesGKind[GripsKind[gn]] - 1 do
  begin
    if poly[q].X < rc.Left then
      rc.Left := poly[q].X;
    if poly[q].X > rc.Right then
      rc.Right := poly[q].X;
    if poly[q].Y < rc.Top then
      rc.Top := poly[q].Y;
    if poly[q].Y > rc.Bottom then
      rc.Bottom := poly[q].Y;
  end;
  inc(rc.Bottom);
  inc(rc.Right);
end;


procedure TIERuler.SetGripsDir(v: TGripsDir);
begin
  fGripsDir := v;
  Update();
end;


procedure TIERuler.SetShowBorder(const Value: boolean);
begin
  fShowBorder := Value;
  Update();
end;

procedure TIERuler.SetShowRuler(v: boolean);
begin
  fShowRuler := v;
  Update();
end;


// return height of ruler+text
function TIERuler.GetRulerHeight: integer;
const
  Min_Tick_Size   = 3;
  Min_Grip_Height = 3;
var
  minHeight, availHeight: Integer;
begin
  result := 0;
  if fShowRuler = False then
    exit;

  // New method
  if fOwner is TImageEnView then
  begin
    if fRulerDir = rdHorizontal then
      availHeight := fBitmap.Height
    else
      availHeight := fBitmap.Width;
    minHeight := abs( fFont.Height ) + Ruler_To_Text_Spacing + Min_Tick_Size;

    result := availHeight - fMaxGripHeight;
    if result < minHeight then
      result := minHeight;
    if Result + Min_Grip_Height > availHeight then
      Result := availHeight - Min_Grip_Height;
  end
  else
  begin
    // Legacy method (TRulerBox)
    if fRulerDir = rdHorizontal then
      result := trunc( abs( fFont.Height ) * 1.5 ) + Ruler_To_Text_Spacing
    else
      result := fBitmap.Width - fMaxGripHeight;
  end;
end;


procedure TIERuler.Update();
begin
  UpdateEx( True, True );
end;


procedure TIERuler.UpdateEx(RepaintAll, DoInvalidate : Boolean);
begin
  if fLockUpdateCount > 0 then
    exit
  else
  if ( fOwner is TImageEnView ) and
     ( TImageEnView( fOwner ).LockUpdateCount > 0 ) then
    exit
  else
  if ( fOwner is TImageEnView ) and
     (( fRulerDir in TImageEnView( fOwner ).ShowRulers ) = False ) then
    exit;


  if fFitinView then
  begin
    if (fViewMax - fViewMin <> 0) then
      fDPU := (fBitmap.Width) / (fViewMax - fViewMin);
    AdjustViewLimits;
    RepaintAll := True;
  end;
  RepaintGrips;
  if RepaintAll then
    RepaintRuler;
  if fShowBorder then
    RepaintBorder;
  if DoInvalidate then
    fOwner.invalidate;
end;


procedure TIERuler.SetViewPos(v: double);
begin
  fViewPos := v;
  AdjustViewLimits;
  Update();
end;


procedure TIERuler.SetFrequency(v: double);
begin
  fFrequency := v;
  Update();
end;


procedure TIERuler.SetLabelFreq(v: double);
begin
  fLabelFreq := v;
  Update();
end;


// returns X position (in pixels) of grip "gn"
function TIERuler.GetXGripPos(gn: integer): integer;
begin
  result := round(fDPU * (GripsPos[gn] - fViewPos));
  if fInverted then
  begin
    if fRulerDir = rdHorizontal then
      result := fBitmap.Width - result
    else
      result := fBitmap.Height - result;
  end;
end;


procedure TIERuler.SetRulerColor(v: TColor);
begin
  fRulerColor := v;
  Update();
end;


procedure TIERuler.SetRulerDir(v: TRulerDir);
begin
  fRulerDir := v;
  Update();
end;


// returns coordinates of points making the grip
procedure TIERuler.GetGripPoly(gn: integer; var poly: TIEPolyg);
var
  w, h, b: integer;
  borderSize: integer;
begin
  borderSize := 0;
  if fShowBorder and ( GripsKind[gn] <> gkLine ) then
    borderSize := 1;
  b := 0;
  h := 0;
  if csDesigning in fOwner.ComponentState then
    w := (fGripBaseDim + 5) * gn
  else
    w := GetXGripPos(gn);

  if fGripsDir = gdUp then
  begin
    if fRulerDir = rdHorizontal then
    begin
      h := fBitmap.Height - 2 - borderSize;
      b := 0;
    end
    else
    begin
      h := fBitmap.Width - 2 - borderSize;
      b := 0;
    end;
    if fShowRuler then
      inc(b, GetRulerHeight);
  end
  else
  if fGripsDir = gdDown then
  begin
    if fRulerDir = rdHorizontal then
    begin
      b := fBitmap.Height - 1;
      h := 1 + borderSize;
    end
    else
    begin
      b := fBitmap.Width - 1;
      h := 1 + borderSize;
    end;
    if fShowRuler then
      dec(b, GetRulerHeight);
  end;

  case GripsKind[gn] of
    gkTriangle:
      begin
        poly[0].x := w - (fGripBaseDim div 2);
        poly[0].y := h;
        poly[1].x := w + (fGripBaseDim div 2);
        poly[1].y := h;
        poly[2].x := w;
        poly[2].y := b;
      end;
    gkLeftTriangle:
      begin
        poly[0].x := w - (fGripBaseDim div 2);
        poly[0].y := h;
        poly[1].x := w;
        poly[1].y := h;
        poly[2].x := w;
        poly[2].y := b;
      end;
    gkRightTriangle:
      begin
        poly[0].x := w;
        poly[0].y := h;
        poly[1].x := w + (fGripBaseDim div 2);
        poly[1].y := h;
        poly[2].x := w;
        poly[2].y := b;
      end;
    gkArrow:
      begin
        poly[0].x := w - (fGripBaseDim div 4);
        poly[0].y := h;
        poly[1].x := w + (fGripBaseDim div 4);
        poly[1].y := poly[0].y;
        poly[2].x := poly[1].x;
        if fGripsDir = gdUp then
          poly[2].y := b + ((h - b) div 2)
        else
          poly[2].y := h + ((b - h) div 2);
        poly[3].x := w + (fGripBaseDim div 2);
        poly[3].y := poly[2].y;
        poly[4].x := w;
        poly[4].y := b;
        poly[5].x := w - (fGripBaseDim div 2);
        poly[5].y := poly[2].y;
        poly[6].x := poly[0].x;
        poly[6].y := poly[2].y;
      end;
    gkArrow2:
      begin
        poly[0].x := w - (fGripBaseDim div 2);
        poly[0].y := h;
        poly[1].x := w + (fGripBaseDim div 2);
        poly[1].y := poly[0].y;
        poly[2].x := poly[1].x;
        if fGripsDir = gdUp then
          poly[2].y := b + (h - b) div 2
        else
          poly[2].y := h + (b - h) div 2;
        poly[3].x := w;
        poly[3].y := b;
        poly[4].x := poly[0].x;
        poly[4].y := poly[2].y;
      end;
    gkLine:
      begin
        poly[0].x := w;
        poly[0].y := h;
        poly[1].x := w;
        poly[1].y := b;
      end;
  end;
  if fRulerDir = rdVertical then
    for w := 0 to NumLinesGKind[GripsKind[gn]] - 1 do
      iswap(poly[w].x, poly[w].y);
end;


procedure TIERuler.RepaintGrips;
var
  q, rh: integer;
  poly: TIEPolyg;
  iec: TIECanvas;
begin
  iec := TIECanvas.Create( fBitmap.Canvas, true, true);
  iec.Brush.Color := GetThemeColor( ietpRulerBackground, fBackground );
  rh := GetRulerHeight;
  if fRulerDir = rdHorizontal then
  begin
    if fGripsDir = gdUp then
      iec.Fillrect(rect(0, rh, fBitmap.Width, fBitmap.Height))
    else
    if fgripsDir = gdDown then
      iec.FillRect(rect(0, 0, fBitmap.Width, fBitmap.Height - rh));
  end
  else
  begin
    if fGripsDir = gdUp then
      iec.FillRect(rect(rh, 0, fBitmap.Width, fBitmap.Height))
    else
    if fgripsDir = gdDown then
      iec.FillRect(rect(0, 0, fBitmap.Width - rh, fBitmap.Height));
  end;

  for q := 0 to fGrips.Count - 1 do
    if ( GripsKind[ q ] <> gkNone ) and ( GripsPos[ q ] <> NON_VIZ ) then
    begin
      GetGripPoly(q, poly);

      // paint grip
      iec.Brush.Color := GripsColor[q];
      iec.Pen.Color   := GetThemeColor( ietpRulerGripBorder, fGripPenColor );
      iec.Polygon(slice(poly, NumLinesGKind[GripsKind[q]]));
    end;
  iec.Free;
end;


// adjusts limits of specified grip (looking at Max and Min)
procedure TIERuler.AdjustGripLimits(gn: integer);
begin
  if GripsMin[gn] < GripsMax[gn] then
  begin
    if GripsPos[gn] < GripsMin[gn] then
      GripsPos[gn] := GripsMin[gn]
    else
    if GripsPos[gn] > GripsMax[gn] then
      GripsPos[gn] := GripsMax[gn];
  end;
end;


// adjusts limits of fViewPos (looking at fViewMin and fViewMax)
procedure TIERuler.AdjustViewLimits;
var
  wiu: Double;
begin
  if ( fViewMin < fViewMax ) and ( fBitmap.Width > 0 ) then
  begin
    // return horizontal size in Units
    wiu := fBitmap.Width / fDPU;
    if fViewPos < fViewMin then
      fViewPos := fViewMin
    else
    if fViewPos > (fViewMax - wiu) then
      fViewpos := dmax(0, fViewMax - wiu);
  end;
end;


procedure TIERuler.HandleMouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  inherited;

  {$IFDEF IEDEBUG}
  OutputDebugStringA( 'Mouse Down' );
  {$ENDIF}

  dec(X, fOffsetX);
  dec(Y, fOffsetY);
  if (Button = mbLeft) then
  begin
    fSelGrip := GetClickedGrip(x, y);
    fMX1 := X;
    fMY1 := Y;
    if fSelGrip >= 0 then
    begin
      if (ssDouble in Shift) and assigned(fOnRulerGripDblClick) and
         ( fSelGrip >= fGripIndexOffset ) then
        fOnRulerGripDblClick( fOwner, fRulerDir, fSelGrip - fGripIndexOffset, PRUGrip( fGrips[ fSelGrip ])^.Pos );
      fSelGripSt := GetXGripPos( fSelGrip );
    end
    else
    begin
      if assigned(fOnRulerClick) then
        fOnRulerClick( fOwner, fRulerDir, X / fDPU + fViewPos);
    end;
  end;
end;

procedure TIERuler.HandleMouseMove(Shift: TShiftState; X, Y: Integer);
begin
  HandleMouseMoveEx( Shift, X, Y, nil );
end;

procedure TIERuler.HandleMouseMoveEx(Shift: TShiftState; X, Y: Integer; SetGripCallBack: TRulerSetGripPosEvent);
  {}
  procedure _DoScroll_IEView(Dir: Integer);
  begin
    case Dir of
      VK_LEFT:
        begin
          PRUGrip(fGrips[ fSelGrip ])^.Pos := ( fSelGripSt - fMX1 ) / fDPU + fViewPos - (fScrollRate / fDPU);
          TImageEnView(fOwner).ViewX := Round( TImageEnView(fOwner).ViewX - (fScrollRate / fDPU));
        end;
      VK_RIGHT:
        begin
          PRUGrip(fGrips[ fSelGrip ])^.Pos := ( fSelGripSt + fBitmap.Width - 1 - fMX1 ) / fDPU + fViewPos + (fScrollRate / fDPU);
          TImageEnView(fOwner).ViewX := Round( TImageEnView(fOwner).ViewX + (fScrollRate / fDPU));
        end;
      VK_UP:
        begin
          PRUGrip(fGrips[ fSelGrip ])^.Pos := ( fSelGripSt - fMY1 ) / fDPU + fViewPos - (fScrollRate / fDPU);
          if fOwner is TImageEnView then
            TImageEnView(fOwner).ViewY := Round( TImageEnView(fOwner).ViewY - (fScrollRate / fDPU));
        end;
      VK_DOWN:
        begin
          PRUGrip(fGrips[ fSelGrip ])^.Pos := ( fSelGripSt + fBitmap.Height- 1 - fMY1 ) / fDPU + fViewPos + (fScrollRate / fDPU);
          TImageEnView(fOwner).ViewY := Round( TImageEnView(fOwner).ViewY + (fScrollRate / fDPU));
        end;
    end;

    AdjustGripLimits( fSelGrip );
    AdjustViewLimits;

    if assigned(fOnRulerGripPosChange)  and
      ( fSelGrip >= fGripIndexOffset ) then
      fOnRulerGripPosChange( fOwner, fRulerDir,  fSelGrip - fGripIndexOffset, PRUGrip( fGrips[  fSelGrip  ])^.Pos );
  end;
  {}
  function _DoScroll_RB(Dir: Integer): integer;
  var
    p: TPoint;
  begin
    GetCursorPos(p);
    p := fOwner.ScreenToClient(p);
    case Dir of
      VK_LEFT:
        begin
          PRUGrip(fGrips[ fSelGrip ])^.Pos := ( fSelGripSt - fMX1 ) / fDPU + fViewPos - (fScrollRate / fDPU);
          fViewPos := fViewPos - (fScrollRate / fDPU);
        end;
      VK_RIGHT:
        begin
          PRUGrip(fGrips[ fSelGrip ])^.Pos := ( fSelGripSt + fBitmap.Width - 1 - fMX1 ) / fDPU + fViewPos + (fScrollRate / fDPU);
          fViewPos := fViewPos + (fScrollRate / fDPU);
        end;
      VK_UP:
        begin
          PRUGrip(fGrips[ fSelGrip ])^.Pos := ( fSelGripSt - fMY1 ) / fDPU + fViewPos - (fScrollRate / fDPU);
          fViewPos := fViewPos - (fScrollRate / fDPU);
        end;
      VK_DOWN:
        begin
          PRUGrip(fGrips[ fSelGrip ])^.Pos := ( fSelGripSt + fBitmap.Height- 1 - fMY1 ) / fDPU + fViewPos + (fScrollRate / fDPU);
          fViewPos := fViewPos + (fScrollRate / fDPU);
        end;
    end;

    AdjustGripLimits( fSelGrip );
    AdjustViewLimits;
    RepaintGrips;
    RepaintRuler;
    fOwner.Invalidate();

    if assigned(fOnRulerGripPosChange)  and
      ( fSelGrip >= fGripIndexOffset ) then
      fOnRulerGripPosChange( fOwner, fRulerDir,  fSelGrip - fGripIndexOffset, PRUGrip( fGrips[  fSelGrip  ])^.Pos );

    if Dir in [ VK_LEFT, VK_RIGHT ] then
      result := p.X
    else
      result := p.Y;
  end;
  {}
  function _CheckConstraints(v: Double) : Double;
  begin
    Result := v;
    if assigned( SetGripCallBack ) then
      SetGripCallBack( Self, Result );
  end;
  {}
  function _CheckInverted(Dir: Integer) : Integer;
  begin
    Result := Dir;
    if fInverted then
      case Dir of
        VK_LEFT  : Result := VK_RIGHT;
        VK_RIGHT : Result := VK_LEFT ;
        VK_UP    : Result := VK_DOWN ;
        VK_DOWN  : Result := VK_UP   ;
      end;
  end;
  {}
var
  isMouseCapture: Boolean;
begin
  inherited;
  //
  dec(X, fOffsetX);
  dec(Y, fOffsetY);

  isMouseCapture := False;
  if fOwner is TRulerBox then
    isMouseCapture := TRulerBox( fOwner ).MouseCapture
  else
  if fOwner is TImageEnView then
    isMouseCapture := TImageEnView( fOwner ).MouseCapture;

  if isMouseCapture then
    if (fSelGrip >= 0) then
    begin
      if fRulerDir = rdHorizontal then
      begin
        if X < 0 then
        begin
          // Scroll Left
          if fOwner is TImageEnView then
            _DoScroll_IEView( _CheckInverted( VK_LEFT ))
          else
          while ( _DoScroll_RB( _CheckInverted( VK_LEFT )) < 0) and (GetAsyncKeyState(VK_LBUTTON) <> 0) do
            Application.ProcessMessages
        end
        else
        if X >= fBitmap.Width then
        begin
          // Scroll Right
          if fOwner is TImageEnView then
            _DoScroll_IEView( _CheckInverted( VK_RIGHT ))
          else
          while ( _DoScroll_RB( _CheckInverted( VK_RIGHT )) >= fBitmap.Width) and (GetAsyncKeyState(VK_LBUTTON) <> 0) do
            Application.ProcessMessages
        end
        else
        begin
          // Move Horz Grip
          if fInverted then
            SetGripsPos( fSelGrip, _CheckConstraints(( fSelGripSt + (fBitmap.Width-X) - fMX1) / fDPU + fViewPos ))
          else
            SetGripsPos( fSelGrip, _CheckConstraints(( fSelGripSt + X - fMX1) / fDPU + fViewPos ));
          fOwner.Invalidate();
        end;
      end
      else
      begin
        if Y < 0 then
        begin
          // Scroll Up
          if fOwner is TImageEnView then
            _DoScroll_IEView( _CheckInverted( VK_UP ))
          else
          while ( _DoScroll_RB( _CheckInverted( VK_UP )) < 0) and (GetAsyncKeyState(VK_LBUTTON) <> 0) do
            Application.ProcessMessages
        end
        else
        if Y >= fBitmap.Height then
        begin
          // Scroll Down
          if fOwner is TImageEnView then
            _DoScroll_IEView( _CheckInverted( VK_DOWN ))
          else
          while ( _DoScroll_RB( _CheckInverted( VK_DOWN )) >= fBitmap.height) and (GetAsyncKeyState(VK_LBUTTON) <> 0) do
            Application.ProcessMessages
        end
        else
        begin
          // Move Vert Grip
          if fInverted then
            SetGripsPos( fSelGrip, _CheckConstraints(( fSelGripSt + (fBitmap.Height-Y) - fMY1) / fDPU + fViewPos ))
          else
            SetGripsPos( fSelGrip, _CheckConstraints(( fSelGripSt + Y - fMY1) / fDPU + fViewPos ));
          fOwner.Invalidate();
        end;
      end
    end;
end;


// fMouseSel 0=none  1=capture on sat/val  2=capture on hue
procedure TIERuler.HandleMouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  {$IFDEF IEDEBUG}
  OutputDebugStringA( 'Mouse Up' );
  {$ENDIF}

  dec(X, fOffsetX);
  dec(Y, fOffsetY);

  if fSelGrip >= 0 then
  begin
    if (fMX1 = X) and (fMY1 = Y) and assigned(fOnRulerGripClick)  and
      ( fSelGrip >= fGripIndexOffset ) then
      fOnRulerGripClick( fOwner, fRulerDir, fSelGrip - fGripIndexOffset, PRUGrip( fGrips[ fSelGrip ])^.Pos );
  end;
end;


function TIERuler.GetGripsMax(i: integer): double;
begin
  if i < fGrips.Count then
    result := PRUGrip(fGrips[i])^.Max
  else
    result := 0;
end;

procedure TIERuler.SetGripsMax(i: integer; v: double);
var
  q: integer;
begin
  if (i < fGrips.Count) then
  begin
    PRUGrip(fGrips[i])^.Max := v;
    for q := 0 to fGrips.Count - 1 do
      AdjustGripLimits(q);
    Update();
  end;
end;


function TIERuler.GetGripsMin(i: integer): double;
begin
  if i < fGrips.Count then
    result := PRUGrip(fGrips[i])^.Min
  else
    result := 0;
end;

procedure TIERuler.SetGripsMin(i: integer; v: double);
var
  q: integer;
begin
  if (i < fGrips.Count) then
  begin
    PRUGrip(fGrips[i])^.Min := v;
    for q := 0 to fGrips.Count - 1 do
      AdjustGripLimits(q);
    Update();
  end;
end;


procedure TIERuler.SetViewMin(v: double);
var
  q: integer;
begin
  fViewMin := v;
  AdjustViewLimits;
  for q := 0 to fGrips.Count - 1 do
    PRUGrip(fGrips[q])^.Min := fViewMin;
  Update();
end;


procedure TIERuler.SetViewMax(v: double);
var
  q: integer;
begin
  fViewMax := v;
  AdjustViewLimits;
  for q := 0 to fGrips.Count - 1 do
    PRUGrip(fGrips[q])^.Max := fViewMax;
  Update();
end;


procedure TIERuler.RepaintBorder;
  {}
  procedure _DrawBorder(x1, y1, x2, y2 : Integer);
  begin
    fBitmap.Canvas.MoveTo( x1, y1 );
    fBitmap.Canvas.LineTo( x2, y2 );
  end;
  {}
begin
  fBitmap.Canvas.Pen.Color := GetThemeColor( ietpRulerBorder, clBtnShadow );
  if fRulerDir = rdHorizontal then
  begin
    if fGripsDir = gdDown then
      _DrawBorder( 0, 0, fBitmap.Width, 0 )
    else
      _DrawBorder( 0, fBitmap.Height - 1, fBitmap.Width, fBitmap.Height - 1 );
  end
  else
  begin
    if fGripsDir = gdDown then
      _DrawBorder( 0, 0, 0, fBitmap.Height )
    else
      _DrawBorder( fBitmap.Width - 1, 0, fBitmap.Width - 1, fBitmap.Height );
  end;
end;

// repaint ruler+text
procedure TIERuler.RepaintRuler;
var
  LogFont: TLogFontA;
  SaveFont: TFont;
  rl: integer;              // ruler height
  bigTickFreq : Double;     // Local value of fLabelFreq
  littleTickFreq: Double;   // Local value of fFrequency
  bigTickSpacing: Integer;  // Pixels between big ticks
  fontColor: TColor;
  {}
  function _FloatToLabel(v: double) : string;
  var
    lb1: string;
    e: integer;
  begin
    if fHexLabels then
    begin
      lb1 := IntToHex(trunc(abs( v )), 6);
      // remove starting zeros
      Result := '0';
      for e := 1 to length(lb1) do
        if lb1[e] <> '0' then
        begin
          Result := Copy(lb1, e, length(lb1));
          break;
        end;
      if v < 0 then
        Result := '-' + Result;
    end
    else
      Result := IEFloatToFormatString( v, fLabelPrecision, True );
  end;
  {}
  procedure _DrawHorzTicks(TickFrequency: Double; TickScale: Integer; DrawLabel: Boolean);
  var
    q, w: integer;
    z, v: double;   // pos in unit
    x: integer;     // pos in pixel
    xx: integer;    // Draw pos
    lb: string;
  begin
    w := trunc((fBitmap.Width / fDPU) / TickFrequency); // number of lines
    for q := 0 to w + 1 do
    begin
      v := ((fViewPos / TickFrequency) - trunc(fViewPos / TickFrequency)) * TickFrequency;
      z := q * TickFrequency + fViewPos - v;

      x := round((z - fViewPos) * fDPU);
      if fInverted then
        x := fBitmap.Width - x;

      if fGripsDir = gdDown then
      begin // DOWN
        fBitmap.Canvas.MoveTo( x, fBitmap.Height - rl );
        fBitmap.Canvas.LineTo( x, fBitmap.Height - rl + ( rl div TickScale ) - 1 );
      end
      else
      begin // UP
        fBitmap.Canvas.MoveTo( x, rl - 1 );
        fBitmap.Canvas.LineTo( x, rl - ( rl div TickScale ) + 1 );
      end;

      if DrawLabel then
      begin
        lb := _FloatToLabel( z );
        xx := x - (fBitmap.Canvas.TextWidth(lb) div 2);
        if xx <= 0 then
          begin { Don't draw half a zero } end
        else
        if fGripsDir = gdDown then
          fBitmap.Canvas.TextOut(xx, fBitmap.Height - fBitmap.Canvas.TextHeight( lb ), lb)
        else
          fBitmap.Canvas.TextOut(xx, 0, lb);
      end;
    end;
  end;
  {}
  procedure _DrawVertTicks(TickFrequency: Double; TickScale: Integer; DrawLabel: Boolean);
  var
    w, q: Integer;
    z, v: double;   // pos in unit
    y: integer;     // pos in pixel
    yy: integer;    // Draw pos
    lb: string;
    tw: Integer;
  begin
    w := trunc((fBitmap.Height / fDPU) / TickFrequency); // number of rows
    for q := 0 to w + 1 do
    begin
      v := ((fViewPos / TickFrequency) - trunc(fViewPos / TickFrequency)) * TickFrequency;
      z := q * TickFrequency + fViewPos - v;

      y := round((z - fViewPos) * fDPU);
      if fInverted then
        y := fBitmap.Height - y;

      if fGripsDir = gdDown then
      begin // DOWN
        fBitmap.Canvas.MoveTo( fBitmap.Width - rl, y );
        fBitmap.Canvas.LineTo( fBitmap.Width - rl + ( rl div TickScale ), y );
      end
      else
      begin // UP
        fBitmap.Canvas.MoveTo( rl - 1, y );
        fBitmap.Canvas.LineTo( rl - ( rl div TickScale ) - 1, y );
      end;

      if DrawLabel then
      begin
        lb := _FloatToLabel( z );
        tw := fBitmap.Canvas.TextWidth( lb );
        if fGripsDir = gdDown then
        begin // DOWN
          yy := y - ( tw div 2 );
          if yy > 0 then // Don't draw half a zero
            fBitmap.Canvas.TextOut(fBitmap.Width, yy, lb);
        end
        else
        begin // UP
          yy := y + ( tw div 2 );
          if yy - tw > 0 then // Don't draw half a zero
            fBitmap.Canvas.TextOut(0, yy, lb);
        end;
      end;

    end;
  end;
  {}
begin
  if not fShowRuler then
    exit;

  fBitmap.Canvas.Brush.Color := GetThemeColor( ietpRuler, fRulerColor );
  rl := GetRulerHeight;

  if fRulerDir = rdHorizontal then
  begin
    if fGripsDir = gdDown then
      fBitmap.Canvas.Fillrect(Rect(0, fBitmap.Height - rl, fBitmap.Width, fBitmap.Height))
    else
      fBitmap.Canvas.Fillrect(Rect(0, 0, fBitmap.Width, rl));
  end
  else
  begin
    if fGripsDir = gdDown then
      fBitmap.Canvas.Fillrect(Rect(fBitmap.Width - rl, 0, fBitmap.Width, fBitmap.Height))
    else
      fBitmap.Canvas.Fillrect(Rect(0, 0, rl, fBitmap.Height));
  end;


  // paint
  fBitmap.Canvas.Font := fFont;
  fontColor  := GetThemeColor( ietpRulerText, fFont.Color );
  fBitmap.Canvas.Font.Color := fontColor;
  fBitmap.Canvas.Pen.Color  := fontColor;

  bigTickFreq := fLabelFreq;
  littleTickFreq := fFrequency;
  // Scale spacing
  bigTickSpacing := imax( 1, Round( fDPU * bigTickFreq ));
  if ( fMinLabelSpacing > 0 ) then
    while bigTickSpacing < fMinLabelSpacing do
    begin
      bigTickFreq    := 2 * bigTickFreq   ;
      littleTickFreq := 2 * littleTickFreq;
      bigTickSpacing := imax( 1, Round( fDPU * bigTickFreq ));
    end;

  if fRulerDir = rdVertical then
  begin
    // VERTICAL
    // pepare vertical font
    SaveFont := TFont.Create;
    SaveFont.assign(fBitmap.Canvas.Font);
    GetObject(SaveFont.Handle, sizeof(TLogFontA), @LogFont);
    if fGripsDir = gdDown then
      LogFont.lfEscapement := -900 // -90 degrees
    else
      LogFont.lfEscapement := 900; // 90 degrees
    LogFont.lfPitchAndFamily := FIXED_PITCH or FF_DONTCARE;
    fBitmap.Canvas.Font.Handle := CreateFontIndirectA(LogFont);

    // paint long ticks and text
    _DrawVertTicks( bigTickFreq, 2, True );

    // Paint little ticks
    _DrawVertTicks( littleTickFreq, 4, False );

    // free font
    fBitmap.Canvas.Font.Assign(SaveFont);
    FreeAndNil(SaveFont);
  end
  else
  begin
    // HORIZONTAL

    // Paint long ticks and text
    _DrawHorzTicks( bigTickFreq, 2, True );

    // Paint little ticks
    _DrawHorzTicks( littleTickFreq, 4, False );
  end;
end;


procedure TIERuler.SetFitInView(v: boolean);
begin
  fFitInView := v;
  Update();
end;


procedure TIERuler.SetDPU(v: double);
begin
  if (csDesigning in fOwner.ComponentState) and fFitInView then
    exit;

  fDPU := v;
  Update();
end;


procedure TIERuler.SetHexLabels(v: boolean);
begin
  fHexLabels := v;
  Update();
end;


procedure TIERuler.SetInverted(v: boolean);
begin
  fInverted := v;
  Update();
end;


procedure TIERuler.SetOffsetX(v: integer);
begin
  fOffsetX := v;
  fBitmap.Width := fOwner.Width - fOffsetX;
  Update();
end;


procedure TIERuler.SetOffsetY(v: integer);
begin
  fOffsetY := v;
  fBitmap.Height := fOwner.Height - fOffsetY;
  Update();
end;


procedure TIERuler.SetLabelPrecision(v: integer);
begin
  fLabelPrecision := v;
  Update();
end;


procedure TIERuler.SetMinLabelSpacing(v: integer);
begin
  fMinLabelSpacing := v;
  Update();
end;


procedure TIERuler.LockUpdate();
begin
  Inc( fLockUpdateCount );
end;

procedure TIERuler.UnlockUpdate(RepaintAll: Boolean = True; DoInvalidate: Boolean = True);
begin
  Dec( fLockUpdateCount );
  if fLockUpdateCount < 1 then
    UpdateEx( RepaintAll, DoInvalidate );
end;


procedure TIERuler.FontChange(Sender: TObject);
begin
  Update();
end;



/////////////////////////////////////////////////////////////////////////////////////////
//                                                                                     //
//                             TIEViewRulerParams                                      //
//                                                                                     //
/////////////////////////////////////////////////////////////////////////////////////////


constructor TIEViewRulerParams.Create(Owner: TControl);
begin
  if not ( Owner is TImageEnView ) then
    raise EIEException.create( 'Only TImageEnView supported' );

  fOwner := Owner;

  fHorzRuler := TIERuler.Create( Owner );
  fHorzRuler.RulerDir := rdHorizontal;
  fHorzRuler.LabelPrecision := 2;
  fHorzRuler.RulerColor := clBtnShadow;
  fHorzRuler.ShowBorder := True;
  fHorzRuler.GripColorDefault := cl3DLight;

  fVertRuler := TIERuler.Create( Owner );
  fVertRuler.RulerDir := rdVertical;
  fVertRuler.LabelPrecision := 2;
  fVertRuler.RulerColor := clBtnShadow;
  fVertRuler.ShowBorder := True;
  fVertRuler.GripColorDefault := clWindow;

  fSnapGrips      := iesnNone;
  fConstrainGrips := True;
  fAlignToImage   := False;
  fUnits          := ieruPixels;
  fWasUnits       := ieruPixels;
  fHorzPos        := gdUp;
  fVertPos        := gdLeft;
  fHorzHeight     := 40;
  fVertWidth      := 40;
  fLastMouseMoveX := -99;
  fLastMouseMoveY := -99;
  fGripsPosBase   := ierbBitmap;

  fHorzRuler.GripsCount := 1;
  fVertRuler.GripsCount := 1;
  fHorzRuler.GripsKind[ 0 ] := gkLine;
  fVertRuler.GripsKind[ 0 ] := gkLine;
  fHorzRuler.GripsPos[ 0 ] := NON_VIZ;
  fVertRuler.GripsPos[ 0 ] := NON_VIZ;

  Font.OnChange := FontChange;

  Update( False );
end;


destructor TIEViewRulerParams.Destroy;
begin
  FreeAndNil( fHorzRuler );
  FreeAndNil( fVertRuler );
  inherited;
end;


// Update the ruler positions and sizes when the source TImageEnView changes size or content
procedure TIEViewRulerParams.Update(DoInvalidate: Boolean = True);
var
  z: double;
  ieDpiX, ieDpiY: Integer;
  dpux, dpuy: double;
  newHorzPos, newVertPos: double;
  hRect, vRect: TRect;
  I: Integer;
begin
  if not ( HorzRulerVisible or VertRulerVisible ) then
    exit;

  fHorzRuler.LockUpdate();
  fVertRuler.LockUpdate();
  try
    if fAlignToImage then
    begin
      // Align ruler to position of the image
      fHorzRuler.OffsetX := TImageEnView( fOwner ).OffsetX - RulerAreaLeft;
      fVertRuler.OffsetY := TImageEnView( fOwner ).OffsetY - RulerAreaTop;
    end
    else
    begin
      // Photoshop style: show negative values in ruler
      fHorzRuler.OffsetX := 0;
      fVertRuler.OffsetY := 0;
    end;
    hRect := HorzRulerRect;
    fHorzRuler.UpdateSize( hRect.Right - hRect.Left, hRect.Bottom - hRect.Top );
    vRect := VertRulerRect;
    fVertRuler.UpdateSize( vRect.Right - vRect.Left, vRect.Bottom - vRect.Top );

    ieDpiX := TImageEnView( fOwner ).IO.Params.DpiX;
    ieDpiY := TImageEnView( fOwner ).IO.Params.DpiY;
    if ( ieDpiX < 1 ) or ( ieDpiY < 1 ) then
      fUnits := ieruPixels;

    case fUnits of
      ieruInches :
        begin
          dpux := ieDpiX;
          dpuy := ieDpiY;
        end;
      ieruMillimeters :
        begin
          dpux := ieDpiX / CM_per_Inch / 10;
          dpuy := ieDpiY / CM_per_Inch / 10;
        end;
      ieruCentimeters :
        begin
          dpux := ieDpiX / CM_per_Inch;
          dpuy := ieDpiY / CM_per_Inch;
        end;
      else { ieruPixels }
        begin
          dpux := 1;
          dpuy := 1;
        end;
    end;

    z := TImageEnView( fOwner ).Zoom / 100;

    newHorzPos := TImageEnView( fOwner ).ViewX / z / dpux;
    newVertPos := TImageEnView( fOwner ).ViewY / z / dpuy;
    if fAlignToImage = False then
    begin
      newHorzPos := newHorzPos - ( TImageEnView( fOwner ).OffsetX - RulerAreaLeft ) / z / dpux;
      newVertPos := newVertPos - ( TImageEnView( fOwner ).OffsetY - RulerAreaTop )  / z / dpuy;
    end;

    fHorzRuler.ViewPos    := newHorzPos;
    fVertRuler.ViewPos    := newVertPos;

    if fUnits <> fWasUnits then
    begin
      // Repositon all grips
      for I := 0 to fHorzRuler.GripsCount do
        fHorzRuler.GripsPos[ I ] := fHorzRuler.DotPerUnit / ( dpux * z ) * fHorzRuler.GripsPos[ I ];
      for I := 0 to fVertRuler.GripsCount do
        fVertRuler.GripsPos[ I ] := fVertRuler.DotPerUnit / ( dpuy * z ) * fVertRuler.GripsPos[ I ];
    end;
    fWasUnits := fUnits;

    fHorzRuler.DotPerUnit := z * dpux;
    fVertRuler.DotPerUnit := z * dpuy;

  finally
    fHorzRuler.UnlockUpdate( True, False );
    fVertRuler.UnlockUpdate( True, False );
    if DoInvalidate and ( fHorzRuler.LockUpdateCount <= 0 ) then
      fOwner.Invalidate();
  end;
end;


// Draw the rulers to the TImageEnView canvas
procedure TIEViewRulerParams.Paint(Canvas: TCanvas);
begin
  {$IFDEF IEDEBUG}
  OutputDebugStringW( PWideChar( Format( 'Paint - %d,%d,%d,%d',
                                         [ Canvas.ClipRect.Left,
                                           Canvas.ClipRect.Top,
                                           Canvas.ClipRect.Right,
                                           Canvas.ClipRect.Bottom ])));
  {$ENDIF}

  if HorzRulerVisible and VertRulerVisible then
  begin
    Canvas.Brush.Style := bsSolid;

    // There will be a corner that needs clearing
    if fVertPos = gdLeft then
    begin
      if fHorzPos = gdUp then
      begin
        // Top-Left
        Canvas.Brush.Color := GetThemeColor( ietpRuler, GetMeasureColor );
        Canvas.FillRect( Rect( 0,
                               0,
                               fVertWidth,
                               fHorzHeight ));
        Canvas.Brush.Color := GetThemeColor( ietpRulerBackground, GetColor );
        Canvas.FillRect( Rect( fHorzRuler.GetRulerHeight,
                               fVertRuler.GetRulerHeight,
                               fVertWidth,
                               fHorzHeight ));
        if GetShowBorder() then
          Canvas.Pixels[ fVertWidth - 1, fHorzHeight - 1 ] := GetThemeColor( ietpRulerBorder, clBtnShadow );
      end
      else
      begin
        // Bottom-Left
        Canvas.Brush.Color := GetThemeColor( ietpRuler, GetMeasureColor );
        Canvas.FillRect( Rect( 0,
                               TImageEnView( fOwner ).ClientHeight - fHorzHeight,
                               fVertWidth,
                               TImageEnView( fOwner ).ClientHeight ));
        Canvas.Brush.Color := GetThemeColor( ietpRulerBackground, GetColor );
        Canvas.FillRect( Rect( fHorzRuler.GetRulerHeight,
                               TImageEnView( fOwner ).ClientHeight - fHorzHeight,
                               fVertWidth,
                               TImageEnView( fOwner ).ClientHeight - fVertRuler.GetRulerHeight ));
        if GetShowBorder() then
          Canvas.Pixels[ fVertWidth - 1, TImageEnView( fOwner ).ClientHeight - fHorzHeight ] := GetThemeColor( ietpRulerBorder, clBtnShadow );
      end;
    end
    else
    begin
      if fHorzPos = gdUp then
      begin
        // Top-Right
        Canvas.Brush.Color := GetThemeColor( ietpRuler, GetMeasureColor );
        Canvas.FillRect( Rect( TImageEnView( fOwner ).ClientWidth - fVertWidth,
                               0,
                               TImageEnView( fOwner ).ClientWidth,
                               fHorzHeight ));
        Canvas.Brush.Color := GetThemeColor( ietpRulerBackground, GetColor );
        Canvas.FillRect( Rect( TImageEnView( fOwner ).ClientWidth - fVertWidth,
                               fVertRuler.GetRulerHeight,
                               TImageEnView( fOwner ).ClientWidth - fHorzRuler.GetRulerHeight,
                               fHorzHeight ));
        if GetShowBorder() then
          Canvas.Pixels[ TImageEnView( fOwner ).ClientWidth  - fVertWidth, fHorzHeight - 1 ] := GetThemeColor( ietpRulerBorder, clBtnShadow );

      end
      else
      begin
        // Bottom-Right
        Canvas.Brush.Color := GetThemeColor( ietpRuler, GetMeasureColor );
        Canvas.FillRect( Rect( TImageEnView( fOwner ).ClientWidth  - fVertWidth,
                               TImageEnView( fOwner ).ClientHeight - fHorzHeight,
                               TImageEnView( fOwner ).ClientWidth,
                               TImageEnView( fOwner ).ClientHeight ));
        Canvas.Brush.Color := GetThemeColor( ietpRulerBackground, GetColor );
        Canvas.FillRect( Rect( TImageEnView( fOwner ).ClientWidth  - fVertWidth,
                               TImageEnView( fOwner ).ClientHeight - fHorzHeight,
                               TImageEnView( fOwner ).ClientWidth  - fVertRuler.GetRulerHeight,
                               TImageEnView( fOwner ).ClientHeight - fHorzRuler.GetRulerHeight ));
        if GetShowBorder() then
          Canvas.Pixels[ TImageEnView( fOwner ).ClientWidth  - fVertWidth, TImageEnView( fOwner ).ClientHeight - fHorzHeight ] := GetThemeColor( ietpRulerBorder, clBtnShadow );
      end;
    end
  end;

  if HorzRulerVisible then
    fHorzRuler.DrawToCanvas( Canvas, HorzRulerRect.Left, HorzRulerRect.Top );
  if VertRulerVisible  then
    fVertRuler.DrawToCanvas( Canvas, VertRulerRect.Left, VertRulerRect.Top );
end;


// The horz ruler pos of the image left (always zero)
function TIEViewRulerParams.ImageLeftOnHorzRuler(): double;
begin
  Result := 0;
end;

// The horz ruler pos of the image right
function TIEViewRulerParams.ImageRightOnHorzRuler(): double;
var
  iev: TImageEnView;
begin
  iev  := TImageEnView( fOwner );
  Result := ( iev.ViewX - iev.OffsetX + iev.XBmp2Scr( iev.LayersRect().Width, false )) / fHorzRuler.DotPerUnit;
end;

// The vert ruler pos of the image top (always zero)
function TIEViewRulerParams.ImageTopOnVertRuler(): double;
begin
  Result := 0;
end;

// The vert ruler pos of the image Bottom
function TIEViewRulerParams.ImageBottomOnVertRuler(): double;
var
  iev: TImageEnView;
begin
  iev  := TImageEnView( fOwner );
  Result := ( iev.ViewY - iev.OffsetY + iev.YBmp2Scr( iev.LayersRect().Height, false )) / fVertRuler.DotPerUnit
end;


// Pass a ruler value, it is adjusted if SnapGrips or ConstrainGrips is enabled
function TIEViewRulerParams.ApplyHorzConstraints(value : double; DoSnapGrips : TIERulerSnapping = iesnNone; DoConstrainGrips : Boolean = False) : double;
begin
  Result := value;
  if Result = NON_VIZ then
    exit;

  case DoSnapGrips of
    iesnSnapToWholeNumber : Result := Round( Value );
    iesnSnapToLabel       : Result := Round( value / fHorzRuler.LabelFrequency ) * fHorzRuler.LabelFrequency;
    iesnSnapToTick        : Result := Round( Value / fHorzRuler.Frequency ) * fHorzRuler.Frequency;
  end;

  if DoConstrainGrips then
  begin
    if Result < ImageLeftOnHorzRuler then
      Result := ImageLeftOnHorzRuler;
    if Result > ImageRightOnHorzRuler then
      Result := ImageRightOnHorzRuler;
  end;
end;


// Pass a ruler value, it is adjusted if SnapGrips or ConstrainGrips is enabled
function TIEViewRulerParams.ApplyVertConstraints(value : double; DoSnapGrips : TIERulerSnapping = iesnNone; DoConstrainGrips : Boolean = False) : double;
begin
  Result := value;
  if Result = NON_VIZ then
    exit;

  case DoSnapGrips of
    iesnSnapToWholeNumber : Result := Round( Value );
    iesnSnapToLabel       : Result := Round( Value / fVertRuler.LabelFrequency ) * fVertRuler.LabelFrequency;
    iesnSnapToTick        : Result := Round( Value / fVertRuler.Frequency ) * fVertRuler.Frequency;
  end;

  if DoConstrainGrips then
  begin
    if Result < ImageTopOnVertRuler then
      Result := ImageTopOnVertRuler;
    if Result > ImageBottomOnVertRuler then
      Result := ImageBottomOnVertRuler;
  end;
end;


// Calculates the position on the ruler of a screen X value
function TIEViewRulerParams.ScrToRulerX(X : Integer) : double;
begin
  Result := ( X - RulerAreaLeft ) / fHorzRuler.DotPerUnit + fHorzRuler.ViewPos;
end;

// Calculates the position on screen for a grip position (in ruler units)
function TIEViewRulerParams.RulerToScrX(Pos : Double) : Integer;
begin
  result := round( fHorzRuler.DotPerUnit * ( Pos - fHorzRuler.ViewPos )) + RulerAreaLeft;
  if fHorzRuler.Inverted then
    result := TImageEnView( fOwner ).Width - result;
end;


// Calculates the position on the ruler of a screen Y value
// ApplyRules: adjusts if SnapGrips or ConstrainGrips is enabled
function TIEViewRulerParams.ScrToRulerY(Y : Integer) : double;
begin
  Result := ( Y - RulerAreaTop ) / fVertRuler.DotPerUnit + fVertRuler.ViewPos;
end;


// Calculates the position on screen for a grip position (in ruler units)
function TIEViewRulerParams.RulerToScrY(Pos : Double) : Integer;
begin
  result := round( fVertRuler.DotPerUnit * ( Pos - fVertRuler.ViewPos )) + RulerAreaTop;
  if fVertRuler.Inverted then
    result := TImageEnView( fOwner ).Height - result;
end;


// Converts a value adjusted by a base value to a ruler value and adjusts if SnapGrips or ConstrainGrips is enabled
function TIEViewRulerParams.ValueToRulerX(Value : double; ValueBase: TIERulerPosBase) : double;
begin
  case ValueBase of
    ierbBitmap       : Result := ScrToRulerX( TImageEnView( fOwner ).XBmp2Scr( Round( Value ), false));
    ierbScreen       : Result := ScrToRulerX( Round( Value ));
    else { ierbRuler } Result := Value;
  end;
end;

// Converts a ruler value to a base format
function TIEViewRulerParams.RulerToValueX(Pos : double; ValueBase: TIERulerPosBase) : double;
begin
  case ValueBase of
    ierbBitmap       : Result := TImageEnView( fOwner ).XScr2Bmp( Round( RulerToScrX( Pos{ + RulerAreaLeft} )), false);
    ierbScreen       : Result := Round( RulerToScrX( Pos ));
    else { ierbRuler } Result := Pos;
  end;
end;


// Converts a value adjusted by a base value to a ruler value and adjusts if SnapGrips or ConstrainGrips is enabled
function TIEViewRulerParams.ValueToRulerY(Value : double; ValueBase: TIERulerPosBase) : double;
begin
  case ValueBase of
    ierbBitmap       : Result := ScrToRulerY( TImageEnView( fOwner ).YBmp2Scr( Round( Value ), false));
    ierbScreen       : Result := ScrToRulerY( Round( Value ));
    else { ierbRuler } Result := Value;
  end;
end;


// Converts a ruler value to a base format
function TIEViewRulerParams.RulerToValueY(Pos : Double; ValueBase: TIERulerPosBase) : Double;
begin
  case ValueBase of
    ierbBitmap       : result := TImageEnView( fOwner ).YScr2Bmp( Round( RulerToScrY( Pos {+ RulerAreaTop} )), false);
    ierbScreen       : result := Round( RulerToScrY( Pos ));
    else { ierbRuler } Result := Pos;
  end;
end;


// Ensures all grips are adjusted by SnapGrips or ConstrainGrips
procedure TIEViewRulerParams.CheckGripBounds();
var
  aGripsPos: TIERulerPosBase;
  I: Integer;
begin
  if ( fConstrainGrips = False ) and ( fSnapGrips = iesnNone ) then
    exit;

  aGripsPos := fGripsPosBase;
  LockUpdate();
  try
    fGripsPosBase := ierbRuler;

    for I := 0 to fHorzRuler.GripsCount - 1 do
      fHorzRuler.GripsPos[ I ] := ApplyHorzConstraints( ScrToRulerX( RulerToScrX( fHorzRuler.GripsPos[ I ] )), fSnapGrips, fConstrainGrips );
    for I := 0 to fVertRuler.GripsCount - 1 do
      fVertRuler.GripsPos[ I ] := ApplyVertConstraints( ScrToRulerY( RulerToScrY( fVertRuler.GripsPos[ I ] )), fSnapGrips, fConstrainGrips );

  finally
    fGripsPosBase := aGripsPos;
    UnlockUpdate();
  end;
end;


// Call from TImageEnView MouseDown event
procedure TIEViewRulerParams.HandleMouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  if PtInRect( HorzRulerRect, Point( x, y )) then
    fHorzRuler.HandleMouseDown( Button, Shift, X - HorzRulerRect.Left, Y - HorzRulerRect.Top )
  else
  if PtInRect( VertRulerRect, Point( x, y )) then
    fVertRuler.HandleMouseDown( Button, Shift, X - VertRulerRect.Left, Y - VertRulerRect.Top )
  else
  begin
    fHorzRuler.SelectedGrip := -1;
    fHorzRuler.SelectedGrip := -1;
  end;
end;


procedure TIEViewRulerParams.MouseMoveOutsideRuler(Shift: TShiftState; X, Y: Integer);
begin
  if GetCursorGripKind = gkNone then
    exit;

  LockUpdate();
  try
    if fHorzRuler.GripsCount < 1 then
      fHorzRuler.GripsCount := 1;
    if fVertRuler.GripsCount < 1 then
      fVertRuler.GripsCount := 1;

    if fHorzRuler.Inverted then
      X := fOwner.ClientWidth - X + RulerAreaLeft - RulerAreaRight;
    if fVertRuler.Inverted then
      Y := fOwner.ClientHeight - Y + RulerAreaTop - RulerAreaBottom;

    // iesnNone because we don't snap cursor grips
    fHorzRuler.GripsPos[ 0 ] := ApplyHorzConstraints( ScrToRulerX( X ), iesnNone, fConstrainGrips );  // Cursor grip
    fVertRuler.GripsPos[ 0 ] := ApplyVertConstraints( ScrToRulerY( Y ), iesnNone, fConstrainGrips );  // Cursor grip
  finally
    UnlockUpdate( False, True );
  end;
end;


procedure TIEViewRulerParams.ConstrainGripsCB(Sender: TObject; var GripPos: double);
begin
  case TIERuler( Sender ).RulerDir of
    rdHorizontal : GripPos := ApplyHorzConstraints( GripPos, fSnapGrips, fConstrainGrips );
    rdVertical   : GripPos := ApplyVertConstraints( GripPos, fSnapGrips, fConstrainGrips );
  end;
end;

// Call from TImageEnView MouseMove event
// Result is true if mouse movement is over rulers
function TIEViewRulerParams.HandleMouseMove(Shift: TShiftState; X, Y: Integer) : Boolean;
begin
  if ( TImageEnView( fOwner ).MouseCapture = False ) and
     ( fLastMouseMoveX = X ) and
     ( fLastMouseMoveY = Y ) and
     ( fLastMouseMoveShift = Shift ) then
  begin
    Result := fLastMouseMoveResult;
    exit;
  end;


  Result := False;
  {$IFDEF IEDEBUG}
  OutputDebugStringW( PWideChar( Format( 'MouseMove - %d,%d', [ X, Y ])));
  {$ENDIF}

  // don't use PtInRect to allow them to drag outside the rect area
  if ( Y >= HorzRulerRect.Top ) and ( Y <= HorzRulerRect.Bottom )  then
  begin
    Result := True;
    fHorzRuler.HandleMouseMoveEx( Shift,
                                  X - HorzRulerRect.Left,
                                  Y - HorzRulerRect.Top,
                                  ConstrainGripsCB );
  end;

  // Don't use else, as potentially both might need to be called
  if ( X >= VertRulerRect.Left ) and ( X <= VertRulerRect.Top )  then
  begin
    Result := True;
    fVertRuler.HandleMouseMoveEx( Shift,
                                  X - VertRulerRect.Left,
                                  Y - VertRulerRect.Top,
                                  ConstrainGripsCB );
  end;

  if not Result then
    MouseMoveOutsideRuler( Shift, X, Y );

  fLastMouseMoveX := X;
  fLastMouseMoveY := Y;
  fLastMouseMoveShift := Shift;
  fLastMouseMoveResult := Result;
end;

// Call from TImageEnView MouseUp event
procedure TIEViewRulerParams.HandleMouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  if PtInRect( HorzRulerRect, Point( x, y )) then
    fHorzRuler.HandleMouseUp( Button, Shift, X - HorzRulerRect.Left, Y - HorzRulerRect.Top )
  else
  if PtInRect( VertRulerRect, Point( x, y )) then
    fVertRuler.HandleMouseUp( Button, Shift, X - VertRulerRect.Left, Y - VertRulerRect.Top );
end;

procedure TIEViewRulerParams.HandleSpecialKey(CharCode: Word; Shift: TShiftState);
var
  newPos, moveBy: double;
begin
  if ssShift in Shift then
    moveBy := fHorzRuler.LabelFrequency
  else
    moveBy := fHorzRuler.Frequency;

  case CharCode of
    VK_LEFT  : if HorzRulerVisible and ( fHorzRuler.SelectedGrip > 0 ) then
               begin
                 newPos := fHorzRuler.GripsPos[ fHorzRuler.SelectedGrip ] - moveBy;
                 if fConstrainGrips and ( newPos < ImageLeftOnHorzRuler ) then
                   newPos := ImageLeftOnHorzRuler;
                 fHorzRuler.GripsPos[ fHorzRuler.SelectedGrip ] := newPos;
                 ScrollToHorzGrip( fHorzRuler.SelectedGrip - 1 );
               end;
    VK_RIGHT : if HorzRulerVisible and ( fHorzRuler.SelectedGrip > 0 ) then
               begin
                 newPos := fHorzRuler.GripsPos[ fHorzRuler.SelectedGrip ] + moveBy;
                 if fConstrainGrips and ( newPos > ImageRightOnHorzRuler ) then
                   newPos := ImageRightOnHorzRuler;
                 fHorzRuler.GripsPos[ fHorzRuler.SelectedGrip ] := newPos;
                 ScrollToHorzGrip( fHorzRuler.SelectedGrip - 1 );
               end;
    VK_UP    : if VertRulerVisible and ( fVertRuler.SelectedGrip > 0 ) then
               begin
                 newPos := fVertRuler.GripsPos[ fVertRuler.SelectedGrip ] - moveBy;
                 if fConstrainGrips and ( newPos < ImageTopOnVertRuler ) then
                   newPos := ImageTopOnVertRuler;
                 fVertRuler.GripsPos[ fVertRuler.SelectedGrip ] := newPos;
                 ScrollToVertGrip( fVertRuler.SelectedGrip - 1 );
               end;
    VK_DOWN  : if VertRulerVisible and ( fVertRuler.SelectedGrip > 0 ) then
               begin
                 newPos := fVertRuler.GripsPos[ fVertRuler.SelectedGrip ] + moveBy;
                 if fConstrainGrips and ( newPos > ImageBottomOnVertRuler ) then
                   newPos := ImageBottomOnVertRuler;
                 fVertRuler.GripsPos[ fVertRuler.SelectedGrip ] := newPos;
                 ScrollToVertGrip( fVertRuler.SelectedGrip - 1 );
               end;
  end;
end;


{!!
<FS>TIEViewRulerParams.HorzGripsMin

<FM>Declaration<FC>
property HorzGripsMin[g: integer]: double;

<FM>Description<FN>
Specifies the minimum position of the grip, g, on the horizontal ruler.
Use <A TIEViewRulerParams.GripsPosBase> to determine whether to pass bitmap, ruler or screen values.

Notes:
- By default, all grips are contrained to the image area (<A TIEViewRulerParams.ConstrainGrips>)
- To access the cursor grip (showing the current position of the cursor over the image), use HorzGripsMin[ -1 ]
!!}
function TIEViewRulerParams.GetHorzGripsMin(i: integer): double;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := RulerToValueX( fHorzRuler.GripsMin[ i + 1 ], fGripsPosBase );
end;

procedure TIEViewRulerParams.SetHorzGripsMin(i: integer; v: double);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fHorzRuler.GripsMin[ i + 1 ] := ValueToRulerX( v, fGripsPosBase );
end;


{!!
<FS>TIEViewRulerParams.HorzGripsMax

<FM>Declaration<FC>
property HorzGripsMax[g: integer]: double;

<FM>Description<FN>
Specifies the max position of the grip, g, on the horizontal ruler.
Use <A TIEViewRulerParams.GripsPosBase> to determine whether to pass bitmap, ruler or screen values.

Notes:
- By default, all grips are contrained to the image area (<A TIEViewRulerParams.ConstrainGrips>)
- To access the cursor grip (showing the current position of the cursor over the image), use HorzGripsMax[ -1 ]
!!}
function TIEViewRulerParams.GetHorzGripsMax(i: integer): double;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := RulerToValueX( fHorzRuler.GripsMax[ i + 1 ], fGripsPosBase );
end;

procedure TIEViewRulerParams.SetHorzGripsMax(i: integer; v: double);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fHorzRuler.GripsMax[ i + 1 ] := ValueToRulerX( v, fGripsPosBase );
end;

{!!
<FS>TIEViewRulerParams.VertGripsMin

<FM>Declaration<FC>
property VertGripsMin[g: integer]: double;

<FM>Description<FN>
Specifies the minimum position of the grip, g, on the vertical ruler.
Use <A TIEViewRulerParams.GripsPosBase> to determine whether to pass bitmap, ruler or screen values.

Notes:
- By default, all grips are contrained to the image area (<A TIEViewRulerParams.ConstrainGrips>)
- To access the cursor grip (showing the current position of the cursor over the image), use VertGripsMin[ -1 ]
!!}
function TIEViewRulerParams.GetVertGripsMin(i: integer): double;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := RulerToValueY( fVertRuler.GripsMin[ i + 1 ], fGripsPosBase );
end;

procedure TIEViewRulerParams.SetVertGripsMin(i: integer; v: double);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fVertRuler.GripsMin[ i + 1 ] := ValueToRulerY( v, fGripsPosBase );
end;


{!!
<FS>TIEViewRulerParams.VertGripsMax

<FM>Declaration<FC>
property VertGripsMax[g: integer]: double;

<FM>Description<FN>
Specifies the max position of the grip, g, on the vertical ruler.
Use <A TIEViewRulerParams.GripsPosBase> to determine whether to pass bitmap, ruler or screen values.

Notes:
- By default, all grips are contrained to the image area (<A TIEViewRulerParams.ConstrainGrips>)
- To access the cursor grip (showing the current position of the cursor over the image), use VertGripsMax[ -1 ]
!!}
function TIEViewRulerParams.GetVertGripsMax(i: integer): double;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := RulerToValueY( fVertRuler.GripsMax[ i + 1 ], fGripsPosBase );
end;

procedure TIEViewRulerParams.SetVertGripsMax(i: integer; v: double);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fVertRuler.GripsMax[ i + 1 ] := ValueToRulerY( v, fGripsPosBase );
end;


{!!
<FS>TIEViewRulerParams.MinLabelSpacing

<FM>Declaration<FC>
property MinLabelSpacing: integer;

<FM>Description<FN>
Specifies the minimum spacing between (the center of) labels. To reduce crowding, labels positioned closer than this are not shown.
If <FC>MinLabelSpacing<FN> is 0 then labels are always drawn.

Default: 30

<FM>Example<FC>
ImageEnView1.RulerParams.MinLabelSpacing := 0;
!!}
function TIEViewRulerParams.GetMinLabelSpacing: integer;
begin
  result := fHorzRuler.MinLabelSpacing;
end;

procedure TIEViewRulerParams.SetMinLabelSpacing(v: integer);
begin
  LockUpdate();
  fHorzRuler.MinLabelSpacing := v;
  fVertRuler.MinLabelSpacing := v;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.Frequency

<FM>Declaration<FC>
property Frequency: double;

<FM>Description<FN>
Specifies the number of logical units where ticks are shown.

Use <A TIEViewRulerParams.LabelFrequency> to configure labels and longer tick marks.

Note: This value is set automatically when changing <A TIEViewRulerParams.Units>.

Default: 10

<FM>Example<FC>
ImageEnView1.LockUpdate();
ImageEnView1.RulerParams.Units := ieruInches;
ImageEnView1.RulerParams.LabelFrequency := 1/4;  // Labels every quarter inch
ImageEnView1.RulerParams.Frequency := 1/32; // Ticks every 1/32 inch
ImageEnView1.UnlockUpdate();
!!}
function TIEViewRulerParams.GetFrequency: double;
begin
  result := fHorzRuler.Frequency;
end;

procedure TIEViewRulerParams.SetFrequency(v: double);
begin
  LockUpdate();
  fHorzRuler.Frequency := v;
  fVertRuler.Frequency := v;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.LabelFrequency

<FM>Declaration<FC>
property LabelFrequency: double;

<FM>Description<FN>
Specifies the number of logical units where to show the labels (and longer tick marks).

Use <A TIEViewRulerParams.Frequency> to configure short tick marks.

Notes:
- This value is set automatically when changing <A TIEViewRulerParams.Units>.
- Labels may be hidden if the view is crowded and <A TIEViewRulerParams.MinLabelSpacing> has been set

Default: 40

<FM>Example<FC>
ImageEnView1.LockUpdate();
ImageEnView1.RulerParams.Units := ieruInches;
ImageEnView1.RulerParams.LabelFrequency := 1/4;  // Labels every quarter inch
ImageEnView1.RulerParams.Frequency := 1/32; // Ticks every 1/32 inch
ImageEnView1.UnlockUpdate();
!!}
function TIEViewRulerParams.GetLabelFrequency: double;
begin
  result := fHorzRuler.LabelFrequency;
end;

procedure TIEViewRulerParams.SetLabelFrequency(v: double);
begin
  LockUpdate();
  fHorzRuler.LabelFrequency := v;
  fVertRuler.LabelFrequency := v;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.ShowMeasure

<FM>Declaration<FC>
property ShowMeasure: boolean;

<FM>Description<FN>
Specify whether a measurement block is drawn on the ruler.

Default: True

<FM>Example<FC>
// Show only grips
ImageEnView1.RulerParams.ShowMeasure := False;
ImageEnView1.RulerParams.HorzHeight := 10;
ImageEnView1.RulerParams.VertWidth  := 10;

!!}
function TIEViewRulerParams.GetShowMeasure: boolean;
begin
  result := fHorzRuler.ShowRuler;
end;

procedure TIEViewRulerParams.SetShowMeasure(v: boolean);
begin
  LockUpdate();
  fHorzRuler.ShowRuler := v;
  fVertRuler.ShowRuler := v;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.ShowBorder

<FM>Declaration<FC>
property ShowBorder: boolean;

<FM>Description<FN>
Specify whether a border is displayed between the ruler and the image.

Default: True

<FM>Example<FC>
// Show only cursor position
ImageEnView1.RulerParams.ShowMeasure := False;
ImageEnView1.RulerParams.ShowBorder := False;
ImageEnView1.RulerParams.HorzHeight := 10;
ImageEnView1.RulerParams.VertWidth  := 10;

!!}
function TIEViewRulerParams.GetShowBorder: boolean;
begin
  Result := fHorzRuler.ShowBorder;
end;

procedure TIEViewRulerParams.SetShowBorder(const Value: boolean);
begin
  LockUpdate();
  fHorzRuler.ShowBorder := Value;
  fVertRuler.ShowBorder := Value;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.MeasureColor

<FM>Declaration<FC>
property MeasureColor: TColor;

<FM>Description<FN>
Specifies the color of the <L TIEViewRulerParams.ShowMeasure>measurement block</L> of the ruler.

Note: This value may be overridden if <A TIEImageEnGlobalSettings.EnableTheming> is enabled.

Default: clBtnFace

<FM>See Also<FN>
- <A TIEViewRulerParams.Color>
!!}
function TIEViewRulerParams.GetMeasureColor: TColor;
begin
  result := fHorzRuler.RulerColor;
end;

procedure TIEViewRulerParams.SetMeasureColor(v: TColor);
begin
  LockUpdate();
  fHorzRuler.RulerColor := v;
  fVertRuler.RulerColor := v;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.Color

<FM>Declaration<FC>
property Color: TColor;

<FM>Description<FN>
Specifies the color of the background (excluding area of the <L TIEViewRulerParams.ShowMeasure>measurement block</L>).

Note: This value may be overridden if <A TIEImageEnGlobalSettings.EnableTheming> is enabled.

Default: clBtnShadow

<FM>See Also<FN>
- <A TIEViewRulerParams.MeasureColor>
!!}
// return -1 = none
function TIEViewRulerParams.GetColor: TColor;
begin
  result := fHorzRuler.Background;
end;

procedure TIEViewRulerParams.SetColor(c: TColor);
begin
  LockUpdate();
  fHorzRuler.Background := c;
  fVertRuler.Background := c;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.HorzInverted

<FM>Declaration<FC>
property HorzInverted: boolean;

<FM>Description<FN>
When true, the horizontal ruler is painted from right to left.

Default: False

<FM>Example<FC>
// Draw a right-hand side UI
ImageEnView1.LockUpdate();
ImageEnView1.ShowRulers := [ rdVertical, rdHorizontal ];
ImageEnView1.RulerParams.VertPos := gdRight;      // Ruler on RHS
ImageEnView1.RulerParams.HorzInverted := True;    // Horz ruler reversed measurement
ImageEnView1.UnlockUpdate();

<FM>See Also<FN>
- <A TIEViewRulerParams.VertInverted>
- <A TIEViewRulerParams.HorzPos>
- <A TIEViewRulerParams.VertPos>
!!}
function TIEViewRulerParams.GetHorzInverted: boolean;
begin
  result := fHorzRuler.Inverted;
end;

procedure TIEViewRulerParams.SetHorzInverted(v: boolean);
begin
  fHorzRuler.Inverted := v;
end;


{!!
<FS>TIEViewRulerParams.VertInverted

<FM>Declaration<FC>
property VertInverted: boolean;

<FM>Description<FN>
When true, the vertical ruler is painted from bottom to top.

Default: False.

<FM>Example<FC>
// Draw ruler from bottom to top
ImageEnView1.RulerParams.VertInverted := True;

<FM>See Also<FN>
- <A TIEViewRulerParams.HorzInverted>
- <A TIEViewRulerParams.HorzPos>
- <A TIEViewRulerParams.VertPos>
!!}
function TIEViewRulerParams.GetVertInverted: boolean;
begin
  result := fVertRuler.Inverted;
end;

procedure TIEViewRulerParams.SetVertInverted(v: boolean);
begin
  fVertRuler.Inverted := v;
end;


{!!
<FS>TIEViewRulerParams.LabelPrecision

<FM>Declaration<FC>
property LabelPrecision: integer;

<FM>Description<FN>
Specifies the number of decimal places shown for values in the ruler.

Default: 2

<FM>Example<FC>
ImageEnView1.LockUpdate();
ImageEnView1.RulerParams.Units := ieruCentimeters;
ImageEnView1.RulerParams.LabelPrecision := 1;  // Show labels to one decimal place
ImageEnView1.UnlockUpdate();
!!}
function TIEViewRulerParams.GetLabelPrecision: integer;
begin
  result := fHorzRuler.LabelPrecision;
end;

procedure TIEViewRulerParams.SetLabelPrecision(v: integer);
begin
  LockUpdate();
  fHorzRuler.LabelPrecision := v;
  fVertRuler.LabelPrecision := v;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.ScrollRate

<FM>Declaration<FC>
property ScrollRate: double;

<FM>Description<FN>
Specifies the scroll rate used when moving a grip out of ruler borders.

Default: 1.0
!!}
function TIEViewRulerParams.GetScrollRate: double;
begin
  result := fHorzRuler.ScrollRate;
end;

procedure TIEViewRulerParams.SetScrollRate(const Value: double);
begin
  fHorzRuler.ScrollRate := Value;
  fVertRuler.ScrollRate := Value;
end;


{!!
<FS>TIEViewRulerParams.CursorGripKind

<FM>Declaration<FC>
property CursorGripKind: <A TGripKind>;

<FM>Description<FN>
Specifies the style for the grip that appears on the ruler showing the current position of the cursor over the image.

Default: gkLine

Note: You can access other properties of the cursor grips, using index -1 in the horizontal and vertical grip arrays.
i.e.
<FC>
ImageEnView1.RulerParams.CursorGripKind := gkTriangle;
<FN>
Is the same as setting:
<FC>
ImageEnView1.RulerParams.HorzGripsKind[ -1 ] := gkTriangle;
ImageEnView1.RulerParams.VertGripsKind[ -1 ] := gkTriangle;<FN>

<FM>Example<FC>
// Hide the cursor grip
ImageEnView1.RulerParams.CursorGripKind := gkNone;

// Set the cursor grip to a red triangle
ImageEnView1.RulerParams.CursorGripKind := gkTriangle;
ImageEnView1.RulerParams.HorzGripsColor[ -1 ] := clRed;
ImageEnView1.RulerParams.VertGripsColor[ -1 ] := clRed;

<FM>See Also<FC>
- <A TIEViewRulerParams.GripKindDefault>
- <A TIEViewRulerParams.GripPenColor>
- <A TIEViewRulerParams.GripColorDefault>
- <A TIEViewRulerParams.GripWidth>
- <A TIEViewRulerParams.GripHeight>
!!}
function TIEViewRulerParams.GetCursorGripKind: TGripKind;
begin
  result := GetHorzGripsKind( -1 );
end;

procedure TIEViewRulerParams.SetCursorGripKind(const Value: TGripKind);
begin
  SetHorzGripsKind( -1, Value );
  SetVertGripsKind( -1, Value );
end;


{!!
<FS>TIEViewRulerParams.GripKindDefault

<FM>Declaration<FC>
property GripKindDefault: <A TGripKind>;

<FM>Description<FN>
Specifies the default style for all grips.
This style will be assigned to any grips for which you have not set a custom style using <A TIEViewRulerParams.HorzGripsKind> or <A TIEViewRulerParams.VertGripsKind>.

Notes:
- The size of the grip is specified by <A TIEViewRulerParams.GripWidth> and <A TIEViewRulerParams.GripHeight>.
- This property does not affect the grip for the current cursor position, use <A TIEViewRulerParams.CursorGripKind> instead

Default: gkTriangle

<FM>Example<FC>
// Set default style of grips to gkTriangle, but gkArrow2 to grips > 10
ImageEnView1.RulerParams.GripKindDefault := gkTriangle;
for i := 10 to ImageEnView1.RulerParams.HorzGripsCount - 1 do
  ImageEnView1.RulerParams.HorzGripsKind[ i ] := gkArrow2;

<FM>See Also<FN>
- <A TIEViewRulerParams.HorzGripsKind>
- <A TIEViewRulerParams.VertGripsKind>
- <A TIEViewRulerParams.CursorGripKind>
- <A TIEViewRulerParams.GripPenColor>
- <A TIEViewRulerParams.GripColorDefault>
- <A TIEViewRulerParams.GripWidth>
- <A TIEViewRulerParams.GripHeight>
!!}
function TIEViewRulerParams.GetGripKindDefault: TGripKind;
begin
  result := fHorzRuler.GripKindDefault;
end;

procedure TIEViewRulerParams.SetGripKindDefault(const Value: TGripKind);
begin
  LockUpdate();
  fHorzRuler.GripKindDefault := Value;
  fVertRuler.GripKindDefault := Value;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.GripColorDefault

<FM>Declaration<FC>
property GripColorDefault: TColor;

<FM>Description<FN>
Specifies the brush color of all grips.
This color will be assigned to any grips for which you have not set a custom color using <A TIEViewRulerParams.HorzGripsColor> or <A TIEViewRulerParams.VertGripsColor>.

Notes:
- This value may be overridden if <A TIEImageEnGlobalSettings.EnableTheming> is enabled.
- You can set the pen color with <A TIEViewRulerParams.GripPenColor>

Default: cl3DLight

<FM>Example<FC>
// Set default color of grips to clSilver, but clRed to grips > 10
ImageEnView1.RulerParams.GripColorDefault := clSilver;
for i := 10 to ImageEnView1.RulerParams.HorzGripsCount - 1 do
  ImageEnView1.RulerParams.HorzGripsColor[ i ] := clRed;

<FM>See Also<FN>
- <A TIEViewRulerParams.GripPenColor>
- <A TIEViewRulerParams.GripKindDefault>
- <A TIEViewRulerParams.GripWidth>
- <A TIEViewRulerParams.GripHeight>
!!}
function TIEViewRulerParams.GetGripColorDefault: TColor;
begin
  result := fHorzRuler.GripColorDefault;
end;

procedure TIEViewRulerParams.SetGripColorDefault(const Value: TColor);
begin
  LockUpdate();
  fHorzRuler.GripColorDefault := Value;
  fVertRuler.GripColorDefault := Value;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.GripPenColor

<FM>Declaration<FC>
property GripPenColor: TColor;

<FM>Description<FN>
Specifies the pen (border) color of all grips.

Notes:
- This value may be overridden if <A TIEImageEnGlobalSettings.EnableTheming> is enabled.
- The brush color is specified by <A TIEViewRulerParams.GripColorDefault>, or for individual grips with <A TIEViewRulerParams.HorzGripsColor> or <A TIEViewRulerParams.VertGripsColor>.

Default: clWindowFrame

<FM>See Also<FN>
- <A TIEViewRulerParams.HorzGripsColor>
- <A TIEViewRulerParams.VertGripsColor>
- <A TIEViewRulerParams.GripColorDefault>
- <A TIEViewRulerParams.GripKindDefault>
- <A TIEViewRulerParams.GripWidth>
- <A TIEViewRulerParams.GripHeight>
!!}
function TIEViewRulerParams.GetGripPenColor: TColor;
begin
  result := fHorzRuler.GripPenColor;
end;

procedure TIEViewRulerParams.SetGripPenColor(const Value: TColor);
begin
  LockUpdate();
  fHorzRuler.GripPenColor := Value;
  fVertRuler.GripPenColor := Value;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.GripWidth

<FM>Declaration<FC>
property GripWidth: integer;

<FM>Description<FN>
Specifies the width of grip triangles in pixels.

Default: 12

<FM>See Also<FN>
- <A TIEViewRulerParams.GripHeight>
- <A TIEViewRulerParams.GripKindDefault>
!!}
function TIEViewRulerParams.GetGripWidth: integer;
begin
  result := fHorzRuler.GripBaseDim;
end;

procedure TIEViewRulerParams.SetGripWidth(v: integer);
begin
  LockUpdate();
  fHorzRuler.GripBaseDim := v;
  fVertRuler.GripBaseDim := v;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.GripHeight

<FM>Declaration<FC>
property GripHeight: integer;

<FM>Description<FN>
Specifies the maximum height of the grip.

Default: 15

Note: The value may be automatically adjusted depending on your <L TIEViewRulerParams.Font>font size</L> and the available <L TIEViewRulerParams.HorzHeight>height</L>/<L TIEViewRulerParams.VertWidth>width</L>.

<FM>Example<FC>
// Create narrow rulers
ImageEnView1.RulerParams.Font.Size  := 6;
ImageEnView1.RulerParams.HorzHeight := 20;
ImageEnView1.RulerParams.VertWidth  := 20;
ImageEnView1.RulerParams.GripHeight := 10;

<FM>See Also<FN>
- <A TIEViewRulerParams.GripWidth>
- <A TIEViewRulerParams.GripKindDefault>
!!}
function TIEViewRulerParams.GetGripHeight: integer;
begin
  result := fHorzRuler.MaxGripHeight;
end;

procedure TIEViewRulerParams.SetGripHeight(const Value: integer);
begin
  LockUpdate();
  fHorzRuler.MaxGripHeight := Value;
  fVertRuler.MaxGripHeight := Value;
  UnlockUpdate();
end;


{!!
<FS>TIEViewRulerParams.HorzGripsPos

<FM>Declaration<FC>
property HorzGripsPos[g: integer]: double;

<FM>Description<FN>
Specifies the current position of the grip, g, on the horizontal ruler.
Use <A TIEViewRulerParams.GripsPosBase> to determine whether to pass bitmap, ruler or screen values.

<FM>Example<FC>
// Add three grips at 25%, 50% and 75% of the image width
ImageEnView1.RulerParams.HorzGripsCount := 3;
ImageEnView1.RulerParams.GripsPosBase := ierbBitmap; // Units are relative to the bitmap
ImageEnView1.RulerParams.HorzGripsPos[ 0 ] := MulDiv( ImageEnView1.IEBitmap.Width, 1, 4 );
ImageEnView1.RulerParams.HorzGripsPos[ 1 ] := MulDiv( ImageEnView1.IEBitmap.Width, 2, 4 );
ImageEnView1.RulerParams.HorzGripsPos[ 2 ] := MulDiv( ImageEnView1.IEBitmap.Width, 3, 4 );
!!}
function TIEViewRulerParams.GetHorzGripsPos(i: integer): double;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := RulerToValueX( fHorzRuler.GripsPos[ i + 1 ], fGripsPosBase );
end;

procedure TIEViewRulerParams.SetHorzGripsPos(i: integer; p: double);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fHorzRuler.GripsPos[ i + 1 ] := ApplyHorzConstraints( ValueToRulerX( p, fGripsPosBase ), fSnapGrips, fConstrainGrips );
end;


{!!
<FS>TIEViewRulerParams.HorzGripsCount

<FM>Declaration<FC>
property HorzGripsCount: integer;

<FM>Description<FN>
Specifies the number of the grips on the horizontal ruler.

Default: 0

<FM>Examples<FC>
// Clear added grips
ImageEnView1.RulerParams.HorzGripsCount := 0;

// Add twenty grips
ImageEnView1.RulerParams.HorzGripsCount := 20;

// Set default color of grips to clSilver, but clRed for grips > 10
ImageEnView1.RulerParams.GripColorDefault := clSilver;
for i := 10 to ImageEnView1.RulerParams.HorzGripsCount - 1 do
  ImageEnView1.RulerParams.HorzGripsColor[ i ] := clRed;
!!}
function TIEViewRulerParams.GetHorzGripsCount: integer;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := fHorzRuler.GripsCount - 1;
end;

procedure TIEViewRulerParams.SetHorzGripsCount(v: integer);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fHorzRuler.GripsCount := imax( 1, v + 1 );
end;

{!!
<FS>TIEViewRulerParams.HorzGripsKind

<FM>Declaration<FC>
property HorzGripsKind[g: integer]: <A TGripKind>;

<FM>Description<FN>
Specifies the style of the grip, g, on the horizontal ruler (triangle, arrow, etc).

Notes:
- The default style for grips is specified by <A TIEViewRulerParams.GripKindDefault>. Use <A TIEViewRulerParams.HorzGripsKind> when you want individual grips with different styles
- The style of the grip showing the current cursor position is specified by <A TIEViewRulerParams.CursorGripKind>
- The size of the grip is specified by <A TIEViewRulerParams.GripWidth> and <A TIEViewRulerParams.GripHeight>

<FM>Examples<FC>
// Set default style of grips to gkTriangle, but gkArrow2 to grips > 10
ImageEnView1.RulerParams.GripKindDefault := gkTriangle;
for i := 10 to ImageEnView1.RulerParams.HorzGripsCount - 1 do
  ImageEnView1.RulerParams.HorzGripsKind[ i ] := gkArrow2;

<FM>See Also<FN>
- <A TIEViewRulerParams.GripKindDefault>
- <A TIEViewRulerParams.VertGripsKind>
- <A TIEViewRulerParams.GripWidth>
- <A TIEViewRulerParams.GripHeight>
- <A TIEViewRulerParams.GripColorDefault>
- <A TIEViewRulerParams.GripPenColor>
!!}
function TIEViewRulerParams.GetHorzGripsKind(i: integer): TGripKind;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := fHorzRuler.GripsKind[ i + 1 ];
end;

procedure TIEViewRulerParams.SetHorzGripsKind(i: integer; v: TGripKind);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fHorzRuler.GripsKind[ i + 1 ] := v;
end;


{!!
<FS>TIEViewRulerParams.HorzGripsColor

<FM>Declaration<FC>
property HorzGripsColor[g: integer]: TColor;

<FM>Description<FN>
Specifies the brush color of the grip, g, on the horizontal ruler.

Notes:
- The default color of all grips is set by <A TIEViewRulerParams.GripColorDefault>. Use <FC>HorzGripsColor<FN> to assign custom colors to specific grips.
- To access the cursor grip (showing the current position of the cursor over the image), use HorzGripsColor[ -1 ]

You can set the pen color with <A TIEViewRulerParams.GripPenColor>

<FM>Example<FC>
// Set default color of grips to clSilver, but clRed for grips > 10
ImageEnView1.RulerParams.GripColorDefault := clSilver;
for i := 10 to ImageEnView1.RulerParams.HorzGripsCount - 1 do
  ImageEnView1.RulerParams.HorzGripsColor[ i ] := clRed;

// Set the cursor grip to a red triangle
ImageEnView1.RulerParams.HorzGripsKind[ -1 ] := gkTriangle;     // Same as setting CursorGripKind
ImageEnView1.RulerParams.HorzGripsColor[ -1 ] := clRed;

<FM>See Also<FN>
- <A TIEViewRulerParams.GripColorDefault>
- <A TIEViewRulerParams.VertGripsColor>
- <A TIEViewRulerParams.GripPenColor>
- <A TIEViewRulerParams.GripKindDefault>
- <A TIEViewRulerParams.GripWidth>
- <A TIEViewRulerParams.GripHeight>

!!}
function TIEViewRulerParams.GetHorzGripsColor(i: integer): TColor;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := fHorzRuler.GripsColor[ i + 1 ];
end;

procedure TIEViewRulerParams.SetHorzGripsColor(i: integer; p: TColor);
begin
  fHorzRuler.GripsColor[ i + 1 ] := p;
end;


{!!
<FS>TIEViewRulerParams.VertGripsPos

<FM>Declaration<FC>
property VertGripsPos[g: integer]: double;

<FM>Description<FN>
Specifies the current position of the grip, g, on the vertical ruler.
Use <A TIEViewRulerParams.GripsPosBase> to determine whether to pass bitmap, ruler or screen values.

<FM>Example<FC>
// Add three grips at 25%, 50% and 75% of the image height
ImageEnView1.RulerParams.VertGripsCount := 3;
ImageEnView1.RulerParams.GripsPosBase := ierbBitmap; // Units are relative to the bitmap
ImageEnView1.RulerParams.VertGripsPos[ 0 ] := MulDiv( ImageEnView1.IEBitmap.Height, 1, 4 );
ImageEnView1.RulerParams.VertGripsPos[ 1 ] := MulDiv( ImageEnView1.IEBitmap.Height, 2, 4 );
ImageEnView1.RulerParams.VertGripsPos[ 2 ] := MulDiv( ImageEnView1.IEBitmap.Height, 3, 4 );
!!}
function TIEViewRulerParams.GetVertGripsPos(i: integer): double;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := RulerToValueY( fVertRuler.GripsPos[ i + 1 ], fGripsPosBase );
end;

procedure TIEViewRulerParams.SetVertGripsPos(i: integer; p: double);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fVertRuler.GripsPos[ i + 1 ] := ApplyVertConstraints(ValueToRulerY( p, fGripsPosBase ), fSnapGrips, fConstrainGrips );
end;


{!!
<FS>TIEViewRulerParams.VertGripsCount

<FM>Declaration<FC>
property VertGripsCount: integer;

<FM>Description<FN>
Specifies the number of the grips on the vertical ruler.

Default: 0

<FM>Examples<FC>
// Clear all grips
ImageEnView1.RulerParams.VertGripsCount := 0;

// Add twenty grips
ImageEnView1.RulerParams.VertGripsCount := 20;

// Set default color of grips to clSilver, but clRed for grips > 10
ImageEnView1.RulerParams.GripColorDefault := clSilver;
for i := 10 to ImageEnView1.RulerParams.VertGripsCount - 1 do
  ImageEnView1.RulerParams.VertGripsColor[ i ] := clRed;

!!}
function TIEViewRulerParams.GetVertGripsCount: integer;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := fVertRuler.GripsCount - 1;
end;

procedure TIEViewRulerParams.SetVertGripsCount(v: integer);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fVertRuler.GripsCount := imax( 1, v + 1 )
end;

{!!
<FS>TIEViewRulerParams.VertGripsKind

<FM>Declaration<FC>
property VertGripsKind[g: integer]: <A TGripKind>;

<FM>Description<FN>
Specifies the style of the grip, g, on the vertical ruler (triangle, arrow, etc).

Notes:
- The default style for grips is specified by <A TIEViewRulerParams.GripKindDefault>. Use <A TIEViewRulerParams.VertGripsKind> when you want individual grips with different styles
- The style of the grip showing the current cursor position is specified by <A TIEViewRulerParams.CursorGripKind>
- The size of the grip is specified by <A TIEViewRulerParams.GripWidth> and <A TIEViewRulerParams.GripHeight>

<FM>Example<FC>
// Set default style of grips to gkTriangle, but gkArrow2 to grips > 10
ImageEnView1.RulerParams.GripKindDefault := gkTriangle;
for i := 10 to ImageEnView1.RulerParams.VertGripsCount - 1 do
  ImageEnView1.RulerParams.VertGripsKind[ i ] := gkArrow2;

// Set the cursor grip to a red triangle
ImageEnView1.RulerParams.VertGripsKind[ -1 ] := gkTriangle;     // Same as setting CursorGripKind
ImageEnView1.RulerParams.VertGripsColor[ -1 ] := clRed;

<FM>See Also<FN>
- <A TIEViewRulerParams.GripKindDefault>
- <A TIEViewRulerParams.HorzGripsKind>
- <A TIEViewRulerParams.GripWidth>
- <A TIEViewRulerParams.GripHeight>
- <A TIEViewRulerParams.GripColorDefault>
- <A TIEViewRulerParams.GripPenColor>
!!}
function TIEViewRulerParams.GetVertGripsKind(i: integer): TGripKind;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := fVertRuler.GripsKind[ i + 1 ];
end;

procedure TIEViewRulerParams.SetVertGripsKind(i: integer; v: TGripKind);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fVertRuler.GripsKind[ i + 1 ] := v;
end;


{!!
<FS>TIEViewRulerParams.VertGripsColor

<FM>Declaration<FC>
property VertGripsColor[g: integer]: TColor;

<FM>Description<FN>
Specifies the brush color of the grip, g, on the vertical ruler.

Notes:
- The default color of all grips is set by <A TIEViewRulerParams.GripColorDefault>. Use <FC>VertGripsColor<FN> to assign custom colors to specific grips.
- To access the cursor grip (showing the current position of the cursor over the image), use VertGripsColor[ -1 ]

You can set the pen color with <A TIEViewRulerParams.GripPenColor>

<FM>Example<FC>
// Set default color of grips to clSilver, but clRed for grips > 10
ImageEnView1.RulerParams.GripColorDefault := clSilver;
for i := 10 to ImageEnView1.RulerParams.VertGripsCount - 1 do
  ImageEnView1.RulerParams.VertGripsColor[ i ] := clRed;

<FM>See Also<FN>
- <A TIEViewRulerParams.GripColorDefault>
- <A TIEViewRulerParams.HorzGripsColor>
- <A TIEViewRulerParams.GripPenColor>
- <A TIEViewRulerParams.GripKindDefault>
- <A TIEViewRulerParams.GripWidth>
- <A TIEViewRulerParams.GripHeight>
!!}
function TIEViewRulerParams.GetVertGripsColor(i: integer): TColor;
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  result := fVertRuler.GripsColor[ i + 1 ];
end;

procedure TIEViewRulerParams.SetVertGripsColor(i: integer; p: TColor);
begin
  // Offset index by 1 to obscure grip 0, the cursor grip
  fVertRuler.GripsColor[ i + 1 ] := p;
end;


{!!
<FS>TIEViewRulerParams.Font

<FM>Declaration<FC>
property Font: TFont;

<FM>Description<FN>
Specifies the font used for label text.

Note: The color of this font may be overridden if <A TIEImageEnGlobalSettings.EnableTheming> is enabled.

<FM>Example<FC>
// Create narrow rulers
ImageEnView1.RulerParams.Font.Size  := 6;
ImageEnView1.RulerParams.HorzHeight := 20;
ImageEnView1.RulerParams.VertWidth  := 20;
ImageEnView1.RulerParams.GripHeight := 10;
!!}
function TIEViewRulerParams.GetFont: TFont;
begin
  result := fHorzRuler.Font;
end;


procedure TIEViewRulerParams.FontChange(Sender: TObject);
begin
  fVertRuler.Font.Assign( Font );
end;


{!!
<FS>TIEViewRulerParams.SnapGrips

<FM>Declaration<FC>
property SnapGrips: <A TIERulerSnapping>;

<FM>Description<FN>
Specifies whether grips snap to the closest label or whole number on the ruler.

<FM>Description<FN>
<TABLE>
<R> <H>Item</H> <H>Description</H> </R>
<R> <C><FC>iesnNone<FN></C> <C>Do not adjust grip positions</C> </R>
<R> <C><FC>iesnSnapToTick<FN></C> <C>Automatically move grips to the nearest <L TIEViewRulerParams.Frequency>tick</L></C> </R>
<R> <C><FC>iesnSnapToLabel<FN></C> <C>Automatically move grips to the nearest <L TIEViewRulerParams.LabelFrequency>label</L> (long tick)</C> </R>
<R> <C><FC>iesnSnapToWholeNumber<FN></C> <C>Automatically move grips to the nearest whole value on the ruler (e.g. move to 2.0 inches)</C> </R>
</TABLE>

Default: iesnNone

<FM>Example<FC>
// Snap to the nearest label tick
ImageEnView1.RulerParams.SnapGrips := iesnSnapToLabel;

// Snap to the nearest whole number on the ruler
ImageEnView1.RulerParams.SnapGrips := iesnSnapToWholeNumber;
!!}
procedure TIEViewRulerParams.SetSnapGrips(Value: TIERulerSnapping);
begin
  fSnapGrips := Value;

  // Snap existing grips
  CheckGripBounds();
end;


{!!
<FS>TIEViewRulerParams.ConstrainGrips

<FM>Declaration<FC>
property ConstrainGrips: Boolean;

<FM>Description<FN>
Specifies whether grips can be dragged outside the area of the image.

Default: True

<FM>Example<FC>
// Allow dragging of grips outside the area of the image
ImageEnView1.RulerParams.ConstrainGrips := False;
!!}
procedure TIEViewRulerParams.SetConstrainGrips(Value: Boolean);
begin
  fConstrainGrips := Value;

  // Constrain existing grips
  CheckGripBounds();
end;


{!!
<FS>TIEViewRulerParams.AlignToImage

<FM>Declaration<FC>
property AlignToImage: Boolean;

<FM>Description<FN>
If false, the ruler will be the full width of the control (and show negative values for areas outside the image). If true, the ruler begins at the position of the image within the control.

Default: False
!!}
procedure TIEViewRulerParams.SetAlignToImage(Value: Boolean);
begin
  fAlignToImage := Value;
  Update();
end;


{!!
<FS>TIEViewRulerParams.Units

<FM>Declaration<FC>
property Units: <A TIERulerUnits>;

<FM>Description<FN>
Specifies the measurement unit displayed on the ruler.

Default: ieruPixels

Note: Changing <FC>Units<FN> will automatically set <A TIEViewRulerParams.LabelFrequency> and <A TIEViewRulerParams.Frequency> to a relevant value

<FM>Example<FC>
ImageEnView1.LockUpdate();
ImageEnView1.RulerParams.Units := ieruInches;
ImageEnView1.RulerParams.LabelFrequency := 1/4;  // Labels every quarter inch
ImageEnView1.RulerParams.Frequency := 1/32; // Ticks every 1/32 inch
ImageEnView1.UnlockUpdate();
!!}
procedure TIEViewRulerParams.SetUnits(Value: TIERulerUnits);
var
  lfrq, tfrq: double;
begin
  if fUnits = Value then
    exit;

  LockUpdate();
  try
    fUnits := Value;

    case fUnits of
      ieruInches:
        begin
          lfrq := 0.25; // Every quarter inch
          tfrq := lfrq / 8;
        end;
      ieruMillimeters:
        begin
          lfrq := 2.5; // Every 2.5 mm
          tfrq := lfrq / 5;
        end;
      ieruCentimeters:
        begin
          lfrq := 0.25; // Every quarter CM
          tfrq := lfrq / 5;
        end;
      else { ieruPixels }
        begin
          lfrq := 100; // Every 100px
          tfrq := lfrq / 10;
        end;
    end;

    fHorzRuler.Frequency  := tfrq;
    fVertRuler.Frequency  := tfrq;
    fHorzRuler.LabelFrequency  := lfrq;
    fVertRuler.LabelFrequency  := lfrq;

  finally
    UnlockUpdate();
  end;
end;

{!!
<FS>TIEViewRulerParams.HorzPos

<FM>Declaration<FC>
property HorzPos: <A TGripsDir>;

<FM>Description<FN>
Specifies Whether the horizontal ruler is shown above (gdUp) or below (gdDown) the image.

Default: gdUp

<FM>Example<FC>
// Draw a horizontal ruler on bottom of image
ImageEnView1.LockUpdate();
ImageEnView1.ShowRulers := [ rdHorizontal ];
ImageEnView1.RulerParams.VertPos := gdDown;
ImageEnView1.UnlockUpdate();

<FM>See Also<FC>
- <A TIEViewRulerParams.VertPos>
- <A TIEViewRulerParams.HorzInverted>
- <A TIEViewRulerParams.VertInverted>
!!}
procedure TIEViewRulerParams.SetHorzPos(Value: TGripsDir);
begin
  if fHorzPos <> Value then
  begin
    fHorzPos := Value;
    fHorzRuler.GripsDir := Value;
    TImageEnView( fOwner).Update();
  end;
end;


{!!
<FS>TIEViewRulerParams.VertPos

<FM>Declaration<FC>
property VertPos: <A TGripsXDir>;

<FM>Description<FN>
Specifies whether the vertical ruler is shown left (gdLeft) or right (gdRight) of the image.

Default: gdLeft

<FM>Example<FC>
// Draw a vertical ruler on right of image
ImageEnView1.LockUpdate();
ImageEnView1.ShowRulers := [ rdVertical ];
ImageEnView1.RulerParams.VertPos := gdRight;
ImageEnView1.UnlockUpdate();

<FM>See Also<FC>
- <A TIEViewRulerParams.HorzPos>
- <A TIEViewRulerParams.HorzInverted>
- <A TIEViewRulerParams.VertInverted>
!!}
procedure TIEViewRulerParams.SetVertPos(Value: TGripsXDir);
begin
  if fVertPos <> Value then
  begin
    fVertPos := Value;
    fVertRuler.GripsDir := TGripsDir( ord( Value ));
    TImageEnView( fOwner).Update();
  end;
end;


{!!
<FS>TIEViewRulerParams.HorzHeight

<FM>Declaration<FC>
property HorzHeight: Integer;

<FM>Description<FN>
Specifies the height of the horizontal ruler.

Default: 40

<FM>Example<FC>
// Create narrow rulers
ImageEnView1.RulerParams.Font.Size  := 6;
ImageEnView1.RulerParams.HorzHeight := 20;
ImageEnView1.RulerParams.VertWidth  := 20;
ImageEnView1.RulerParams.GripHeight := 10;
!!}
procedure TIEViewRulerParams.SetHorzHeight(Value: Integer);
begin
  if fHorzHeight <> Value then
  begin
    fHorzHeight := Value;
    TImageEnView( fOwner).Update();
  end;
end;

{!!
<FS>TIEViewRulerParams.VertWidth

<FM>Declaration<FC>
property VertWidth: Integer;

<FM>Description<FN>
Specifies the width of the vertical ruler.

Default: 40

<FM>Example<FC>
// Create narrow rulers
ImageEnView1.RulerParams.Font.Size  := 6;
ImageEnView1.RulerParams.HorzHeight := 20;
ImageEnView1.RulerParams.VertWidth  := 20;
ImageEnView1.RulerParams.GripHeight := 10;
!!}
procedure TIEViewRulerParams.SetVertWidth(Value: Integer);
begin
  if fVertWidth <> Value then
  begin
    fVertWidth := Value;
    TImageEnView( fOwner).Update();
  end;
end;


function TIEViewRulerParams.GetHorzRulerRect: TRect;
var
  rLeft, rRight, rTop, rBottom: Integer;
begin
  rLeft   := 0;
  rRight  := -1;
  rTop    := 0;
  rBottom := -1;

  if VertRulerVisible then
  begin
    if fHorzPos = gdUp then
    begin
      // Top
      rTop    := 0;
      rBottom := fHorzHeight;
    end
    else
    begin
      // Bottom
      rTop    := TImageEnView( fOwner ).ClientHeight - fHorzHeight ;
      rBottom := TImageEnView( fOwner ).ClientHeight ;
    end;

    rLeft := 0;
    if VertRulerVisible and ( fVertPos = gdLeft ) then
      rLeft := fVertWidth;

    rRight := TImageEnView( fOwner ).ClientWidth ;
    if VertRulerVisible and ( fVertPos <> gdLeft ) then
      rRight := TImageEnView( fOwner ).ClientWidth - fVertWidth ;
  end;

  Result := Rect( rLeft, rTop, rRight, rBottom );
end;


function TIEViewRulerParams.GetVertRulerRect: TRect;
var
  rLeft, rRight, rTop, rBottom: Integer;
begin
  rLeft   := 0;
  rRight  := -1;
  rTop    := 0;
  rBottom := -1;

  if VertRulerVisible then
  begin
    if fVertPos = gdLeft then
    begin
      // Left
      rLeft  := 0;
      rRight := fVertWidth;
    end
    else
    begin
      // Right
      rLeft  := TImageEnView( fOwner ).ClientWidth - fVertWidth ;
      rRight := TImageEnView( fOwner ).ClientWidth ;
    end;

    rTop := 0;
    if HorzRulerVisible and ( fHorzPos = gdUp ) then
      rTop := fHorzHeight;

    rBottom := TImageEnView( fOwner ).ClientHeight ;
    if HorzRulerVisible and ( fHorzPos = gdDown ) then
      rBottom := TImageEnView( fOwner ).ClientHeight - fHorzHeight ;
  end;

  Result := Rect( rLeft, rTop, rRight, rBottom );
end;


function TIEViewRulerParams.RulerAreaLeft: Integer;
begin
  Result := 0;
  if VertRulerVisible and ( fVertPos = gdLeft ) then
    Result := fVertWidth;
end;

function TIEViewRulerParams.RulerAreaRight: Integer;
begin
  Result := 0;
  if VertRulerVisible and ( fVertPos = gdRight ) then
    Result := fVertWidth;
end;

function TIEViewRulerParams.RulerAreaTop: Integer;
begin
  Result := 0;
  if HorzRulerVisible and ( fHorzPos = gdUp ) then
    Result := fHorzHeight;
end;

function TIEViewRulerParams.RulerAreaBottom: Integer;
begin
  Result := 0;
  if HorzRulerVisible and ( fHorzPos = gdDown ) then
    Result := fHorzHeight;
end;


function TIEViewRulerParams.HorzRulerVisible: Boolean;
begin
  Result := rdHorizontal in TImageEnView( fOwner ).ShowRulers;
end;

function TIEViewRulerParams.VertRulerVisible: Boolean;
begin
  Result := rdVertical in TImageEnView( fOwner ).ShowRulers;
end;


// Bring grip g into view
procedure TIEViewRulerParams.ScrollToHorzGrip(g: Integer);
var
  z: Double;
  iev: TImageEnView;
  X: Integer;
begin
  iev := TImageEnView( fOwner );
  z   := iev.Zoom / 100;

  X := round( RulerToValueX( fHorzRuler.GripsPos[ g + 1 ], ierbBitmap ));
  if X < round( iev.ViewX / iev.Zoom * 100 ) then
    iev.ViewX := round( X * z )
  else
  if X > round(( iev.ViewX + iev.ExtentX ) / iev.Zoom * 100 ) then
    iev.ViewX := Round(( X - round( iev.ExtentX / iev.Zoom * 100 )) * z ) ;
end;

// Bring grip g into view
procedure TIEViewRulerParams.ScrollToVertGrip(g: Integer);
var
  z: Double;
  iev: TImageEnView;
  Y: Integer;
begin
  iev := TImageEnView( fOwner );
  z   := iev.Zoom / 100;

  Y := round( RulerToValueY( fVertRuler.GripsPos[ g + 1 ], ierbBitmap ));
  if Y < round( iev.ViewY / iev.Zoom * 100 ) then
    iev.ViewY := round( Y * z )
  else
  if Y > round(( iev.ViewY + iev.ExtentY ) / iev.Zoom * 100 ) then
    iev.ViewY := Round(( Y - round( iev.ExtentY / iev.Zoom * 100 )) * z ) ;
end;


// Call from TImageEnView.LockUpdate
procedure TIEViewRulerParams.LockUpdate();
begin
  fHorzRuler.LockUpdate();
  fVertRuler.LockUpdate();
end;

// Call from TImageEnView.UnlockUpdate
procedure TIEViewRulerParams.UnlockUpdate(DoUpdate: Boolean = True; DoInvalidate: Boolean = True);
begin
  fHorzRuler.UnlockUpdate( DoUpdate, False );
  fVertRuler.UnlockUpdate( DoUpdate, False );

  if DoUpdate and ( fHorzRuler.LockUpdateCount <= 0 ) then
    Update( DoInvalidate )
  else
  if DoInvalidate and ( HorzRulerVisible or VertRulerVisible ) then
    fOwner.Invalidate();
end;


function TIEViewRulerParams.GetOnRulerClick: TRulerClickEvent;
begin
  result := fHorzRuler.fOnRulerClick;
end;

procedure TIEViewRulerParams.SetOnRulerClick(const Value: TRulerClickEvent);
begin
  fHorzRuler.fOnRulerClick := Value;
  fVertRuler.fOnRulerClick := Value;
end;


function TIEViewRulerParams.GetOnRulerGripClick: TRulerGripClickEvent;
begin
  result := fHorzRuler.fOnRulerGripClick;
end;

procedure TIEViewRulerParams.SetOnRulerGripClick(const Value: TRulerGripClickEvent);
begin
  fHorzRuler.fOnRulerGripClick := Value;
  fVertRuler.fOnRulerGripClick := Value;
end;


function TIEViewRulerParams.GetOnRulerGripDblClick: TRulerGripClickEvent;
begin
  result := fHorzRuler.fOnRulerGripDblClick;
end;

procedure TIEViewRulerParams.SetOnRulerGripDblClick(const Value: TRulerGripClickEvent);
begin
  fHorzRuler.fOnRulerGripDblClick := Value;
  fVertRuler.fOnRulerGripDblClick := Value;
end;


function TIEViewRulerParams.GetOnRulerPosChange: TRulerGripPosChangeEvent;
begin
  result := fHorzRuler.fOnRulerGripPosChange;
end;

procedure TIEViewRulerParams.SetOnRulerPosChange(const Value: TRulerGripPosChangeEvent);
begin
  fHorzRuler.fOnRulerGripPosChange := Value;
  fVertRuler.fOnRulerGripPosChange := Value;
end;


end.