vrslider.pas

作工控的好控件

{*****************************************************}
{                                                     }
{     Varian Component Workshop                       }
{                                                     }
{     Varian Software NL (c) 1996-2000                }
{     All Rights Reserved                             }
{                                                     }
{*****************************************************}

unit VrSlider;

{$I VRLIB.INC}

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  VrConst, VrTypes, VrClasses, VrControls, VrSysUtils, VrSystem;

type
  TVrSliderOption = (soActiveClick, soMouseClip, soHandPoint, soThumbOpaque);
  TVrSliderOptions = set of TVrSliderOption;
  TVrSliderStyle = (ssBottomLeft, ssTopRight);
  TVrSlider = class(TVrCustomImageControl)
  private
    FBevel: TVrBevel;
    FPalette: TVrPalette;
    FThumbRect: TRect;
    FThumbWidth: Integer;
    FThumbHeight: Integer;
    FThumbImage: TBitmap;
    FThumbImageIndex: Integer;
    FThumbStates: TVrNumGlyphs;
    FThumbIndent: Integer;
    FBackImageOrg: TBitmap;
    FBackImageNew: TBitmap;
    FMinValue: Integer;
    FMaxValue: Integer;
    FPosition: Integer;
    FOrientation: TVrOrientation;
    FSpacing: Integer;
    FTickWidth: Integer;
    FSolidFill: Boolean;
    FStyle: TVrSliderStyle;
    FOptions: TVrSliderOptions;
    FKeyIncrement: Integer;
    FBorderColor: TColor;
    FBorderWidth: Integer;
    FFocusColor: TColor;
    FHit: Integer;
    FClipOn: Boolean;
    FFocused: Boolean;
    FThumbDown: Boolean;
    FThumbHasMouse: Boolean;
    FBitmapList: TVrBitmapList;
    FBitmapListLink: TVrChangeLink;
    FOnChange: TNotifyEvent;
    procedure SetMinValue(Value: Integer);
    procedure SetMaxValue(Value: Integer);
    procedure SetPosition(Value: Integer);
    procedure SetTickWidth(Value: Integer);
    procedure SetSpacing(Value: Integer);
    procedure SetSolidFill(Value: Boolean);
    procedure SetOrientation(Value: TVrOrientation);
    procedure SetStyle(Value: TVrSliderStyle);
    procedure SetThumbImageIndex(Value: Integer);
    procedure SetThumbStates(Value: TVrNumGlyphs);
    procedure SetThumbIndent(Value: Integer);
    procedure SetOptions(Value: TVrSliderOptions);
    procedure SetBorderColor(Value: TColor);
    procedure SetBorderWidth(Value: Integer);
    procedure SetFocusColor(Value: TColor);
    procedure SetBitmapList(Value: TVrBitmapList);
    procedure SetPalette(Value: TVrPalette);
    procedure SetBevel(Value: TVrBevel);
    procedure BevelChanged(Sender: TObject);
    procedure PaletteModified(Sender: TObject);
    procedure BitmapListChanged(Sender: TObject);
    procedure WMSize(var Message: TWMSize); message WM_SIZE;
    procedure WMSetCursor(var Message: TWMSetCursor); message WM_SETCURSOR;
    procedure CMFocusChanged(var Message: TCMFocusChanged); message CM_FOCUSCHANGED;
    procedure CMEnabledChanged(var Message: TMessage); message CM_ENABLEDCHANGED;
    procedure WMGetDlgCode(var Msg: TWMGetDlgCode); message WM_GETDLGCODE;
    procedure CMColorChanged(var Message: TMessage); message CM_COLORCHANGED;
  protected
    procedure GetThumbImage;
    procedure SetThumbTop(ATop: Integer);
    procedure SetThumbLeft(ALeft: Integer);
    procedure CenterThumb;
    procedure CreateBackImages;
    procedure Loaded; override;
    procedure Paint; override;
    procedure PaintThumb;
    procedure Changed; dynamic;
    procedure Notification(AComponent: TComponent; Operation: TOperation); override;
    procedure CreateParams(var Params: TCreateParams); override;
    procedure DrawVert(Canvas: TCanvas; Rect: TRect; Color: TColor);
    procedure DrawHorz(Canvas: TCanvas; Rect: TRect; Color: TColor);
    function GetViewWidth: Integer;
    function GetOffsetByValue(Value: Integer): Integer;
    function GetValueByOffset(Offset: Integer): Integer;
    function GetBitmap(Index: Integer): TBitmap;
    function GetSliderRect: TRect;
    function GetMinIndent(Rect: TRect): Integer;
    procedure SetThumbOffset(Value: Integer);
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure KeyDown(var Key: Word; Shift: TShiftState); override;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property MaxValue: Integer read FMaxValue write SetMaxValue default 100;
    property MinValue: Integer read FMinValue write SetMinValue default 0;
    property Position: Integer read FPosition write SetPosition default 0;
    property Spacing: Integer read FSpacing write SetSpacing default 1;
    property TickWidth: Integer read FTickWidth write SetTickWidth default 1;
    property Orientation: TVrOrientation read FOrientation write SetOrientation default voVertical;
    property SolidFill: Boolean read FSolidFill write SetSolidFill default True;
    property Style: TVrSliderStyle read FStyle write SetStyle default ssBottomLeft;
    property ThumbStates: TVrNumGlyphs read FThumbStates write SetThumbStates default 1;
    property Options: TVrSliderOptions read FOptions write SetOptions
      default [soHandPoint, soThumbOpaque];
    property KeyIncrement: Integer read FKeyIncrement write FKeyIncrement default 5;
    property BorderColor: TColor read FBorderColor write SetBorderColor default clBtnFace;
    property BorderWidth: Integer read FBorderWidth write SetBorderWidth default 1;
    property FocusColor: TColor read FFocusColor write SetFocusColor default clBlue;
    property Bevel: TVrBevel read FBevel write SetBevel;
    property Palette: TVrPalette read FPalette write SetPalette;
    property ThumbImageIndex: Integer read FThumbImageIndex write SetThumbImageIndex default -1;
    property ThumbIndent: Integer read FThumbIndent write SetThumbIndent default 2;
    property BitmapList: TVrBitmapList read FBitmapList write SetBitmapList;
    property OnChange: TNotifyEvent read FOnChange write FOnChange;
{$IFDEF VER110}
    property Anchors;
    property Constraints;
{$ENDIF}
    property Enabled;
    property Color default clBlack;
    property Cursor;
    property DragMode;
{$IFDEF VER110}
    property DragKind;
{$ENDIF}
    property DragCursor;
    property ParentColor default false;
    property ParentShowHint;
    property ShowHint;
    property TabOrder;
    property TabStop default false;
    property Visible;
    property OnClick;
{$IFDEF VER130}
    property OnContextPopup;
{$ENDIF}
    property OnDblClick;
    property OnMouseMove;
    property OnMouseDown;
    property OnMouseUp;
    property OnKeyDown;
    property OnKeyUp;
    property OnKeyPress;
    property OnDragOver;
{$IFDEF VER110}
    property OnEndDock;
{$ENDIF}
    property OnDragDrop;
    property OnEndDrag;
{$IFDEF VER110}
    property OnStartDock;
{$ENDIF}
    property OnStartDrag;
  end;



implementation

{$R VRSLIDER.D32}

const
  ThumbNames: array[0..1] of PChar =
    ('VRSLIDERTHUMB_VERT', 'VRSLIDERTHUMB_HORI');

function CreateLCDImage(AWidth, AHeight: Integer;
  ForeColor, BackColor: TColor): TBitmap;
begin
  Result := TBitmap.Create;
  with TBitmap(Result) do
  begin
    Width := AWidth;
    Height := AHeight;
    Canvas.Brush.Bitmap := CreateDitherPattern(ForeColor, BackColor);
    Canvas.FillRect(BitmapRect(Result));
    Canvas.Brush.Bitmap.Free;
    Canvas.Brush.Bitmap := nil;
  end;
end;

constructor TVrSlider.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  ControlStyle := ControlStyle + [csOpaque];
  Width := 36;
  Height := 171;
  Color := clBlack;
  ParentColor := false;
  Tabstop := false;
  FMinValue := 0;
  FMaxValue := 100;
  FPosition := 0;
  FSpacing := 1;
  FTickWidth := 1;
  FOrientation := voVertical;
  FSolidFill := True;
  FStyle := ssBottomLeft;
  FOptions := [soHandPoint, soThumbOpaque];
  FKeyIncrement := 5;
  FBorderColor := clBtnFace;
  FBorderWidth := 1;
  FFocusColor := clBlue;
  FThumbStates := 1;
  FThumbIndent := 2;
  FThumbImage := TBitmap.Create;
  FBackImageOrg := TBitmap.Create;
  FBackImageNew := TBitmap.Create;
  FBevel := TVrBevel.Create;
  with FBevel do
  begin
    InnerStyle := bsLowered;
    InnerWidth := 2;
    InnerColor := clBlack;
    OnChange := BevelChanged;
  end;
  FPalette := TVrPalette.Create;
  FPalette.OnChange := PaletteModified;
  FThumbImageIndex := -1;
  FBitmapListLink := TVrChangeLink.Create;
  FBitmapListLink.OnChange := BitmapListChanged;
  GetThumbImage;
end;

destructor TVrSlider.Destroy;
begin
  FBevel.Free;
  FPalette.Free;
  FThumbImage.Free;
  FBackImageOrg.Free;
  FBackImageNew.Free;
  FBitmapListLink.Free;
  inherited Destroy;
end;

procedure TVrSlider.CreateParams(var Params: TCreateParams);
begin
  inherited CreateParams(Params);
  with Params do
    WindowClass.style := WindowClass.style and not (CS_HREDRAW or CS_VREDRAW);
end;

procedure TVrSlider.Loaded;
begin
  inherited Loaded;
  GetThumbImage;
end;

procedure TVrSlider.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (Operation = opRemove) then
    if AComponent = BitmapList then BitmapList := nil;
end;

procedure TVrSlider.GetThumbImage;
begin
  FThumbImage.Assign(GetBitmap(FThumbImageIndex));
  if FThumbImage.Empty then
  begin
    if Orientation = voVertical then
    FThumbImage.LoadFromResourceName(hInstance, ThumbNames[1])
    else FThumbImage.LoadFromResourceName(hInstance, ThumbNames[0]);
  end;
  FThumbHeight := FThumbImage.Height;
  FThumbWidth := FThumbImage.Width div ThumbStates;
  CenterThumb;
end;

function TVrSlider.GetBitmap(Index: Integer): TBitmap;
begin
  Result := nil;
  if Assigned(FBitmapList) then
    Result := FBitmapList.GetBitmap(Index);
end;

procedure TVrSlider.SetThumbLeft(ALeft: Integer);
begin
  FThumbRect := Bounds(ALeft, FThumbRect.Top, FThumbWidth, FThumbHeight);
end;

procedure TVrSlider.SetThumbTop(ATop: Integer);
begin
  FThumbRect := Bounds(FThumbRect.Left, ATop, FThumbWidth, FThumbHeight);
end;

procedure TVrSlider.CenterThumb;
begin
  if Orientation = voVertical then
    SetThumbLeft((Width - FThumbWidth) div 2)
  else SetThumbTop((Height - FThumbHeight) div 2);
end;

function TVrSlider.GetSliderRect: TRect;
begin
  Result := ClientRect;
  InflateRect(Result, -BorderWidth - ThumbIndent, -BorderWidth - ThumbIndent);
end;

function TVrSlider.GetMinIndent(Rect: TRect): Integer;
begin
  if Orientation = voVertical then
    Result := MaxIntVal(0, Rect.Top)
  else
    Result := MaxIntVal(0, Rect.Left);
end;

function TVrSlider.GetViewWidth: Integer;
var
  R: TRect;
begin
  R := GetSliderRect;
  if Orientation = voVertical then
  Result := HeightOf(R) - FThumbHeight
  else Result := WidthOf(R) - FThumbWidth;
end;

function TVrSlider.GetOffsetByValue(Value: Integer): Integer;
var
  Range: Double;
  R: TRect;
  MinIndent: Integer;
begin
  R := GetSliderRect;
  MinIndent := GetMinIndent(R);
  Range := MaxValue - MinValue;
  Result := Round((Value - MinValue) / Range * GetViewWidth) + MinIndent;
  if (FOrientation = voVertical) and (FStyle = ssBottomLeft) then
    Result := R.Top + R.Bottom - Result - FThumbHeight
  else
  if (FOrientation = voHorizontal) and (FStyle = ssTopRight) then
    Result := R.Left + R.Right - Result - FThumbWidth;
end;

function TVrSlider.GetValueByOffset(Offset: Integer): Integer;
var
  R: TRect;
  Range: Double;
  MinIndent: Integer;
begin
  R := GetSliderRect;
  MinIndent := GetMinIndent(R);
  if Orientation = voVertical then
    Offset := ClientHeight - Offset - FThumbHeight;
  Range := FMaxValue - FMinValue;
  Result := Round((Offset - MinIndent) * Range / GetViewWidth);
  Result := MinIntVal(FMinValue + MaxIntVal(Result, 0), FMaxValue);
end;

procedure TVrSlider.SetThumbOffset(Value: Integer);
var
  R: TRect;
  MinIndent: Integer;
begin
  R := GetSliderRect;
  MinIndent := GetMinIndent(R);
  Value := MinIntVal(MaxIntVal(Value, MinIndent),
    MinIndent + GetViewWidth);
  if FStyle = ssBottomLeft then Position := GetValueByOffset(Value)
  else Position := FMaxValue - GetValueByOffset(Value) + FMinValue;
end;

procedure TVrSlider.Paint;
var
  Value: Integer;
  BevelRect, SrcRect, DestRect: TRect;
  CurrentColor: TColor;
begin
  ClearBitmapCanvas;
  BevelRect := ClientRect;
  if BorderWidth > 0 then
  begin
    if FFocused then CurrentColor := FFocusColor
    else CurrentColor := FBorderColor;
    DrawFrame3D(BitmapCanvas, BevelRect,
      CurrentColor, CurrentColor, BorderWidth);
  end;

  Bevel.Paint(BitmapCanvas, BevelRect);
  BitmapCanvas.CopyRect(BevelRect,
    FBackImageOrg.Canvas, BitmapRect(FBackImageOrg));

  Value := GetOffsetByValue(Position);
  if Orientation = voVertical then
    SetThumbTop(Value) else SetThumbLeft(Value);

  DestRect := BevelRect;
  SrcRect := BitmapRect(FBackImageNew);
  if Orientation = voVertical then
  begin
    if Style = ssBottomLeft then
    begin
      DestRect.Top := FThumbRect.Top + FThumbHeight div 2;
      SrcRect.Top := DestRect.Top - BevelRect.Top;
    end else
    begin
      DestRect.Bottom := FThumbRect.Bottom - FThumbHeight div 2;
      SrcRect.Bottom := HeightOf(DestRect);
    end;
  end else
  begin
    if Style = ssBottomLeft then
    begin
      DestRect.Right := FThumbRect.Left + FThumbWidth div 2;
      SrcRect.Right := WidthOf(DestRect);
    end else
    begin
      DestRect.Left := FThumbRect.Right - FThumbWidth div 2;
      SrcRect.Left := DestRect.Left - BevelRect.Left;
    end;
  end;

  BitmapCanvas.CopyRect(DestRect, FBackImageNew.Canvas, SrcRect);

  PaintThumb;
  inherited Paint;
end;

procedure TVrSlider.PaintThumb;
var
  Index: Integer;
  SrcRect: TRect;
  TransColor: TColor;
begin
  Index := 0;
  if not Enabled then Index := 1;
  if FThumbDown then Index := 2;
  if (FThumbHasMouse) and (not FThumbDown) then Index := 3;
  if Index > ThumbStates - 1 then Index := 0;

  SrcRect := Bounds(Index * FThumbWidth, 0, FThumbWidth, FThumbHeight);
  with BitmapCanvas do
  begin
    TransColor := FThumbImage.TransparentColor;
    Brush.Color := TransColor;
    if soThumbOpaque in Options then Brush.Style := bsSolid
    else Brush.Style := bsClear;
    BrushCopy(FThumbRect, FThumbImage, SrcRect, TransColor);
  end;
end;

procedure TVrSlider.DrawVert(Canvas: TCanvas; Rect: TRect;
  Color: TColor);
var
  R: TRect;
  X, Y, W, I, Cnt: Integer;
  OffsetValue: Integer;
  Bm: TBitmap;
begin
  with Canvas do
  begin
    W := WidthOf(Rect);
    Cnt := (HeightOf(Rect) div (TickWidth + Spacing)) + 1;
    X := Rect.Left;