nspeedButton[d7]

[cgm2k7 0]

Olá pessoal:
Andei procurando muito na net um speedbutton que tivesse a opção ImgList não achei
resolvi criar um.
Adicionei várias outras novidades:
Opção GrayScale - > para o botão fica com a cor cinsa quando desabilitado ou com transparente com a opção Opacity.
Opções GlyphOver e GlyphDown e também com ImgList.

Suporta: Bitmap 32 Bits, mas se estiver instalado o Component TPNGGraphics no seu delphi vai aceitar png também.
Estou postando para quem estiver precisando:

Previa:


https://youtu.be/iiKtrm2zN0w


download Install dpk nSpeedButton
http://www.mediafire.com/download/oqm3pea1ouy29af/Button2.rar
http://www.4shared.com/rar/Fz1C6wTbba/Button2.html

se quiser o TPNGGraphics:
http://www.mediafire.com/download/ct11e5avx26m0s2/PngGraphics.rar
http://www.4shared.com/rar/-hTI0WoGce/PngGraphics.html

Se você não Gosta de instar qualquer component em seu delphi pode usar em runtime mesmo:

unit Button2;



interface

          

uses Windows, Messages, Classes, Controls, Forms, Graphics, StdCtrls,

  ExtCtrls, CommCtrl, ImgList;



type

 TnRGB = packed record

    B, G, R: Byte;

  end;

  TnRGBA = packed record

    B, G, R, A: Byte;

  end;

 TnColor = record

    case integer of

      0  : (C : TColor);

      1  : (R, G, B, A : Byte);

      2  : (I : integer);

      3  : (nsBGRA : TnRGBA);

      4  : (RGB : TnRGB; nMASK : Byte);

    end;

 TnColor_ = record

    case integer of

      0  : (C : TColor);

      1  : (B, G, R, A : Byte);

      2  : (I : integer);

      3  : (nBGRA : TnRGBA);

      4  : (BGR : TnRGB; nMASK : Byte);

    end;

  PRGBAArray = ^TRGBAArray;

  TRGBAArray = array[0..100000] of TnColor_;

    

  TButtonLayout = (blImageLeft, blImageRight, blImageTop, blImageBottom);

  TButtonState = (bsUp, bsDisabled, bsDown, bsExclusive);

  TButtonStyle = (bsAutoDetect, bsWin31, bsNew);

  TNumGlyphs = 1..4;



  TEnabledImage_e_Glyphs = (bsGrayScale, bsOpacity);

  TEnabled_IGs = set of TEnabledImage_e_Glyphs;



  TnSpeedButton = class;



  TcSpeedButtonActionLink = class(TControlActionLink)

  protected

    FClient: TnSpeedButton;

    procedure AssignClient(AClient: TObject); override;

    function IsCheckedLinked: Boolean; override;

    function IsGroupIndexLinked: Boolean; override;

    procedure SetGroupIndex(Value: Integer); override;

    procedure SetChecked(Value: Boolean); override;

  end;

 

  TnSpeedButton = class(TGraphicControl)

  private

    FOriginal     : TBitmap;

    FOriginalOver : TBitmap;

    FOriginalDown : TBitmap;

    FIndexs: array[TButtonState] of Integer;

    FTransparentColor: TColor;

    FImageList: TCustomImageList;

    FGlyphImgList : TImageList;

    FInternalImageList: TImageList;

    FImageChangeLink: TChangeLink;

    FImageIndex: TImageIndex;

    FDown: Boolean;

    FDragging: Boolean;

    FAllowAllUp: Boolean;

    FLayout: TButtonLayout;

    FSpacing: Integer;

    FTransparent: Boolean;

    FMargin: Integer;

    FFlat: Boolean;

    FMouseInControl: Boolean;

    FEOpacity: integer;

    FEnabledGrayScale: TEnabled_IGs;

    FGroupIndex: Integer;

    FOnChange: TNotifyEvent;

    FOnMouseLeave, FOnMouseEnter: TNotifyEvent;

    FOverDraw : Boolean;

    FOverIndexOver, FOverIndexNormal, FOverIndexDown: Integer;

    FImgOvSize: Boolean;

    FImgOvNoFlat: Boolean;



    function CreateButtonGlyph2(State: TButtonState): Integer;

    procedure DrawButtonGlyph(Canvas: TCanvas; const GlyphPos: TPoint;

      State: TButtonState; Transparent, SetGrayScaleAndOpacity: Boolean);

    procedure DrawButtonImgList(Canvas: TCanvas; const GlyphPos: TPoint;

      State: TButtonState; Transparent, SetGrayScaleAndOpacity: Boolean);

    procedure DrawButtonText(Canvas: TCanvas; const Caption: string;

      TextBounds: TRect; State: TButtonState; BiDiFlags: Longint);

    procedure CalcButtonLayout(Canvas: TCanvas; const Client: TRect;

      const Offset: TPoint; const Caption: string; Layout: TButtonLayout;

        Margin, Spacing: Integer; var GlyphPos: TPoint; var TextBounds: TRect;

          BiDiFlags: Longint);

    procedure GlyphChanged(Sender: TObject);

    procedure UpdateExclusive;

    procedure SetGlyph(Value: TBitmap);

    procedure SetGlyphOver(const Value: TBitmap);

    procedure SetGlyphDown(const Value: TBitmap);

    procedure SetDown(Value: Boolean);

    procedure SetFlat(Value: Boolean);

    procedure SetAllowAllUp(Value: Boolean);

    procedure SetGroupIndex(Value: Integer);

    procedure SetLayout(Value: TButtonLayout);

    procedure SetSpacing(Value: Integer);

    procedure SetTransparent(Value: Boolean);

    procedure SetMargin(Value: Integer);

    procedure UpdateTracking;

    procedure WMLButtonDblClk(var Message: TWMLButtonDown); message WM_LBUTTONDBLCLK;

    procedure CMEnabledChanged(var Message: TMessage); message CM_ENABLEDCHANGED;

    procedure CMButtonPressed(var Message: TMessage); message CM_BUTTONPRESSED;

    procedure CMDialogChar(var Message: TCMDialogChar); message CM_DIALOGCHAR;

    procedure CMFontChanged(var Message: TMessage); message CM_FONTCHANGED;

    procedure CMTextChanged(var Message: TMessage); message CM_TEXTCHANGED;

    procedure CMSysColorChange(var Message: TMessage); message CM_SYSCOLORCHANGE;

    procedure CMMouseEnter(var Message: TMessage); message CM_MOUSEENTER;

    procedure CMMouseLeave(var Message: TMessage); message CM_MOUSELEAVE;

    procedure SetEnabledGrayScale(const Value: TEnabled_IGs);

    procedure SetEnabledOpacity(const Value: integer);

    procedure SetImageIndex(const Value: TImageIndex);

    procedure SetImages(const Value: TCustomImageList);

    procedure ImageListChange(Sender: TObject);

    procedure SetOverDraw(const Value: Boolean);

    procedure SetImgOvSize(const Value: Boolean);

    procedure SetImgOvNoFlat(const Value: Boolean);

  protected

    FState: TButtonState;

    procedure ActionChange(Sender: TObject; CheckDefaults: Boolean); override;

    function GetActionLinkClass: TControlActionLinkClass; override;

    function GetPalette: HPALETTE; override;

    procedure Loaded; override;

    procedure MouseDown(Button: TMouseButton; Shift: TShiftState;

      X, Y: Integer); override;

    procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;

    procedure MouseUp(Button: TMouseButton; Shift: TShiftState;

      X, Y: Integer); override;

    procedure Paint; override;

    property MouseInControl: Boolean read FMouseInControl;

  public

    constructor Create(AOwner: TComponent); override;

    destructor Destroy; override;

    procedure Click; override;

    procedure AlphaTransBitmap(Canvas: TCanvas; const PsW,

     PsH: Integer; const SrcBmp: TBitmap; Enabled_GScale_Opacity: Boolean);

    function Draw(Canvas: TCanvas; const Client: TRect; const Offset: TPoint;

      const Caption: string; Layout: TButtonLayout; Margin, Spacing: Integer;

       State: TButtonState; Transparent, SetGrayScaleAndOpacity: Boolean; BiDiFlags: Longint): TRect;

    property OnChange: TNotifyEvent read FOnChange write FOnChange;

  published

    property Action;

    property AllowAllUp: Boolean read FAllowAllUp write SetAllowAllUp default False;

    property Anchors;

    property BiDiMode;

    property Constraints;

    property GroupIndex: Integer read FGroupIndex write SetGroupIndex default 0;

    property Down: Boolean read FDown write SetDown default False;

    property Caption;

    property Enabled;

    property Flat: Boolean read FFlat write SetFlat default False;

    property Font;

    property Glyph: TBitmap read FOriginal write SetGlyph;

    property GlyphDown: TBitmap read FOriginalDown write SetGlyphDown;

    property GlyphOver: TBitmap read FOriginalOver write SetGlyphOver;

    property Layout: TButtonLayout read FLayout write SetLayout default blImageLeft;

    property Margin: Integer read FMargin write SetMargin default -1;

    property ParentFont;

    property ParentShowHint;

    property ParentBiDiMode;

    property PopupMenu;

    property ShowHint;

    property Spacing: Integer read FSpacing write SetSpacing default 4;

    property Transparent: Boolean read FTransparent write SetTransparent default True;

    property Visible;

    property OnClick;

    property OnDblClick;

    property OnMouseDown;

    property OnMouseMove;

    property OnMouseUp;

    property OnMouseEnter : TNotifyEvent read FOnMouseEnter write FOnMouseEnter;

    property OnMouseLeave : TNotifyEvent read FOnMouseLeave write FOnMouseLeave;

    property ImgOverDraw : Boolean read FOverDraw write SetOverDraw default false;

    property ImgOvNoFlatRec : Boolean read FImgOvNoFlat write SetImgOvNoFlat default false;

    property ImgOvIdxNormal : Integer read FOverIndexNormal write FOverIndexNormal default 0;

    property ImgOvIdxDown : Integer read FOverIndexDown write FOverIndexDown default 1;

    property ImgOvIdxOver : Integer read FOverIndexOver write FOverIndexOver default 2;

    property ImgOvSize: Boolean read FImgOvSize write SetImgOvSize default false;

    property EnabledGrayScale: TEnabled_IGs read FEnabledGrayScale write SetEnabledGrayScale default [bsGrayScale];

    property EnabledOpcValue : integer read FEOpacity write SetEnabledOpacity default 50; //50% de 100 a 1

    property ImageList: TCustomImageList read FImageList write SetImages;

    property ImageIndex: TImageIndex read FImageIndex write SetImageIndex default -1;

  end;



//procedure Register;



implementation



uses Consts, SysUtils, ActnList, Themes, Math, DateUtils, Types;



{procedure Register;

begin

  RegisterComponents('Standard', [TnSpeedButton]);

end; }



function TnSpeedButton.CreateButtonGlyph2(State: TButtonState): Integer;

var

  TmpImage: TBitmap;

  IWidth, IHeight: Integer;

  IRect, ORect: TRect;

  I: TButtonState;

begin

  Result := FIndexs[State];

  if Result <> -1 then Exit;

  if (FOriginal.Width or FOriginal.Height) = 0 then Exit;

  IWidth  := FOriginal.Width;

  IHeight := FOriginal.Height;

  TmpImage := TBitmap.Create;

  try

    TmpImage.Width   := IWidth;

    TmpImage.Height  := IHeight;

    FGlyphImgList.Width  := TmpImage.Width;

    FGlyphImgList.Height := TmpImage.Height;

    IRect := Rect(0, 0, IWidth, IHeight);

    TmpImage.Canvas.Brush.Color := clBtnFace;

    TmpImage.Palette := CopyPalette(FOriginal.Palette);

    I := State;



    ORect := Rect(Ord(I) * IWidth, 0, (Ord(I) + 1) * IWidth, IHeight);

    case State of

      bsUp, bsDown,

      bsExclusive:

      begin

        TmpImage.Canvas.CopyRect(IRect, FOriginal.Canvas, ORect);

        if FOriginal.TransparentMode = tmFixed then

          FIndexs[State] := FGlyphImgList.AddMasked(TmpImage, FTransparentColor)

        else

          FIndexs[State] := FGlyphImgList.AddMasked(TmpImage, clDefault);



        if FOriginalOver <> nil then begin

        TmpImage.Palette := CopyPalette(FOriginalOver.Palette);

        TmpImage.Canvas.CopyRect(IRect, FOriginalOver.Canvas, ORect);

        if FOriginalOver.TransparentMode = tmFixed then

          FIndexs[State] := FGlyphImgList.AddMasked(TmpImage, FTransparentColor)

        else

          FIndexs[State] := FGlyphImgList.AddMasked(TmpImage, clDefault);

        end;



        if FOriginalDown <> nil then begin

        TmpImage.Palette := CopyPalette(FOriginalDown.Palette);

        TmpImage.Canvas.CopyRect(IRect, FOriginalDown.Canvas, ORect);

        if FOriginalDown.TransparentMode = tmFixed then

          FIndexs[State] := FGlyphImgList.AddMasked(TmpImage, FTransparentColor)

        else

          FIndexs[State] := FGlyphImgList.AddMasked(TmpImage, clDefault);

        end;

      end;

      bsDisabled:

      begin

        BitBlt(TmpImage.Canvas.Handle, 0, 0, IWidth, IHeight, FOriginal.Canvas.Handle, 0, 0, SRCCOPY);

        FIndexs[State] := FGlyphImgList.AddMasked(TmpImage, clDefault);

      end;

    end;

  finally

    TmpImage.Free;

  end;

  Result := FIndexs[State];

  FOriginal.Dormant;

  FOriginalOver.Dormant;

  FOriginalDown.Dormant;

end;



procedure TnSpeedButton.DrawButtonGlyph(Canvas: TCanvas; const GlyphPos: TPoint;

  State: TButtonState; Transparent, SetGrayScaleAndOpacity: Boolean);

var

 R: TRect;

 bmp : TBitmap;

 MakeColor : TColor;



  procedure PreparingBitmap(IndexToInsert: Integer; ImageListToInsert: TCustomImageList);

  begin

    Bmp.Width  := ImageListToInsert.Width;

    Bmp.Height := ImageListToInsert.Height;

    Bmp.PixelFormat := pf32bit;

    if ImageListToInsert.BkColor <> clNone then

      MakeColor := ImageListToInsert.BkColor

    else

      MakeColor := clFuchsia;

    Bmp.Canvas.Brush.Color := MakeColor;

    Bmp.Canvas.FillRect(Rect(0, 0, Bmp.Width, Bmp.Height));

    ImageListToInsert.GetBitmap(IndexToInsert, Bmp);

  end;



begin

  if FOriginal = nil then Exit;

  if (FOriginal.Width = 0) or (FOriginal.Height = 0) and

    ((FGlyphImgList = nil) and ((FOverIndexNormal < 0) or (FOverIndexOver < 0) or (FOverIndexDown < 0)) and

    ((FOverIndexNormal > FGlyphImgList.Count) or (FOverIndexOver > FGlyphImgList.Count) and (FOverIndexDown > FGlyphImgList.Count))) then Exit;



  CreateButtonGlyph2(State);

  bmp := TBitmap.Create;

  if FOverDraw then

  begin

    if (FState = bsDown) or (Down) then

      PreparingBitmap(FOverIndexDown, FGlyphImgList)

    else

    if MouseInControl then

      PreparingBitmap(FOverIndexOver, FGlyphImgList)

    else



     PreparingBitmap(FOverIndexNormal, FGlyphImgList)

  end else



  PreparingBitmap(FOverIndexNormal, FGlyphImgList);

  with GlyphPos do

  begin

    if ThemeServices.ThemesEnabled then

    begin

      R.TopLeft := GlyphPos;

      R.Right := R.Left + bmp.Width;

      R.Bottom := R.Top + bmp.Height;



      AlphaTransBitmap(Canvas, r.Left, r.Top, Bmp, SetGrayScaleAndOpacity);

    end else

     if Transparent or (State = bsExclusive) then

      begin

       // ImageList_DrawEx(FGlyphImgList.Handle, FOverIndexNormal, Canvas.Handle, X, Y, 0, 0,

       //   clNone, clNone, ILD_Transparent);



      AlphaTransBitmap(Canvas, GlyphPos.X, GlyphPos.Y, Bmp, SetGrayScaleAndOpacity);

      end else begin

      //  ImageList_DrawEx(FGlyphImgList.Handle, FOverIndexNormal, Canvas.Handle, X, Y, 0, 0,

      //    ColorToRGB(clBtnFace), clNone, ILD_Normal);



      AlphaTransBitmap(Canvas, GlyphPos.X, GlyphPos.Y, Bmp, SetGrayScaleAndOpacity);

    end;

    FreeAndNil(bmp);

  end;

end;



procedure TnSpeedButton.DrawButtonText(Canvas: TCanvas; const Caption: string;

  TextBounds: TRect; State: TButtonState; BiDiFlags: LongInt);

begin

  with Canvas do

  begin

    Brush.Style := bsClear;

    if State = bsDisabled then

    begin

      OffsetRect(TextBounds, 1, 1);

      Font.Color := clBtnHighlight;

      DrawText(Handle, PChar(Caption), Length(Caption), TextBounds,

        DT_CENTER or DT_VCENTER or BiDiFlags);

      OffsetRect(TextBounds, -1, -1);

      Font.Color := clGrayText;

      DrawText(Handle, PChar(Caption), Length(Caption), TextBounds,

        DT_CENTER or DT_VCENTER or BiDiFlags);

    end else

      DrawText(Handle, PChar(Caption), Length(Caption), TextBounds, DT_CENTER or DT_VCENTER or BiDiFlags);

  end;

end;

    

procedure TnSpeedButton.CalcButtonLayout(Canvas: TCanvas; const Client: TRect;

  const Offset: TPoint; const Caption: string; Layout: TButtonLayout; Margin,

  Spacing: Integer; var GlyphPos: TPoint; var TextBounds: TRect;

  BiDiFlags: LongInt);

var

  TextPos: TPoint;

  ClientSize, GlyphSize, TextSize: TPoint;

  TotalSize: TPoint;

begin

  if (BiDiFlags and DT_RIGHT) = DT_RIGHT then

    if Layout = blImageLeft then Layout := blImageRight

    else

      if Layout = blImageRight then Layout := blImageLeft;

  { calculate the item sizes }

  ClientSize := Point(Client.Right - Client.Left, Client.Bottom - Client.Top);

    

  if FOriginal <> nil then

    GlyphSize := Point(FOriginal.Width, FOriginal.Height) else

    GlyphSize := Point(0, 0);

    

  if Length(Caption) > 0 then

  begin

    TextBounds := Rect(0, 0, Client.Right - Client.Left, 0);

    DrawText(Canvas.Handle, PChar(Caption), Length(Caption), TextBounds,

      DT_CALCRECT or BiDiFlags);

    TextSize := Point(TextBounds.Right - TextBounds.Left, TextBounds.Bottom -

      TextBounds.Top);

  end

  else

  begin

    TextBounds := Rect(0, 0, 0, 0);

    TextSize := Point(0,0);

  end;

    

  { If the layout has the glyph on the right or the left, then both the

    text and the glyph are centered vertically.  If the glyph is on the top

    or the bottom, then both the text and the glyph are centered horizontally.}

  if Layout in [blImageLeft, blImageRight] then

  begin

    GlyphPos.Y := (ClientSize.Y - GlyphSize.Y + 1) div 2;

    TextPos.Y := (ClientSize.Y - TextSize.Y + 1) div 2;

  end

  else

  begin

    GlyphPos.X := (ClientSize.X - GlyphSize.X + 1) div 2;

    TextPos.X := (ClientSize.X - TextSize.X + 1) div 2;

  end;

    

  { if there is no text or no bitmap, then Spacing is irrelevant }

  if (TextSize.X = 0) or (GlyphSize.X = 0) then

    Spacing := 0;

    

  { adjust Margin and Spacing }

  if Margin = -1 then

  begin

    if Spacing = -1 then

    begin

      TotalSize := Point(GlyphSize.X + TextSize.X, GlyphSize.Y + TextSize.Y);

      if Layout in [blImageLeft, blImageRight] then

        Margin := (ClientSize.X - TotalSize.X) div 3

      else

        Margin := (ClientSize.Y - TotalSize.Y) div 3;

      Spacing := Margin;

    end

    else

    begin

      TotalSize := Point(GlyphSize.X + Spacing + TextSize.X, GlyphSize.Y +

        Spacing + TextSize.Y);

      if Layout in [blImageLeft, blImageRight] then

        Margin := (ClientSize.X - TotalSize.X + 1) div 2

      else

        Margin := (ClientSize.Y - TotalSize.Y + 1) div 2;

    end;

  end

  else

  begin

    if Spacing = -1 then

    begin

      TotalSize := Point(ClientSize.X - (Margin + GlyphSize.X), ClientSize.Y -

        (Margin + GlyphSize.Y));

      if Layout in [blImageLeft, blImageRight] then

        Spacing := (TotalSize.X - TextSize.X) div 2

      else

        Spacing := (TotalSize.Y - TextSize.Y) div 2;

    end;

  end;

    

  case Layout of

    blImageLeft:

      begin

        GlyphPos.X := Margin;

        TextPos.X := GlyphPos.X + GlyphSize.X + Spacing;

      end;

    blImageRight:

      begin

        GlyphPos.X := ClientSize.X - Margin - GlyphSize.X;

        TextPos.X := GlyphPos.X - Spacing - TextSize.X;

      end;

    blImageTop:

      begin

        GlyphPos.Y := Margin;

        TextPos.Y := GlyphPos.Y + GlyphSize.Y + Spacing;

      end;

    blImageBottom:

      begin

        GlyphPos.Y := ClientSize.Y - Margin - GlyphSize.Y;

        TextPos.Y := GlyphPos.Y - Spacing - TextSize.Y;

      end;

  end;

    

  { fixup the result variables }

  with GlyphPos do

  begin

    Inc(X, Client.Left + Offset.X);

    Inc(Y, Client.Top + Offset.Y);

  end;



  { Themed text is not shifted, but gets a different color. }

  if ThemeServices.ThemesEnabled then

    OffsetRect(TextBounds, TextPos.X + Client.Left, TextPos.Y + Client.Top)

  else

    OffsetRect(TextBounds, TextPos.X + Client.Left + Offset.X, TextPos.Y + Client.Top + Offset.Y);



end;

    

function TnSpeedButton.Draw(Canvas: TCanvas; const Client: TRect;

  const Offset: TPoint; const Caption: string; Layout: TButtonLayout;

  Margin, Spacing: Integer; State: TButtonState; Transparent, SetGrayScaleAndOpacity: Boolean;

  BiDiFlags: LongInt): TRect;

var

  GlyphPos: TPoint;

begin

  CalcButtonLayout(Canvas, Client, Offset, Caption, Layout, Margin, Spacing, GlyphPos, Result, BiDiFlags);

  if ((FImageList <> nil) and (FImageIndex >= 0) and (FImageIndex < FImageList.Count)) then

    DrawButtonImgList(Canvas, GlyphPos, State, Transparent, SetGrayScaleAndOpacity)

  else  

  DrawButtonGlyph(Canvas, GlyphPos, State, Transparent, SetGrayScaleAndOpacity);

  DrawButtonText(Canvas, Caption, Result, State, BiDiFlags);

end;



{ TcSpeedButtonActionLink }



procedure TcSpeedButtonActionLink.AssignClient(AClient: TObject);

begin

  inherited AssignClient(AClient);

  FClient := AClient as TnSpeedButton;

end;



function TcSpeedButtonActionLink.IsCheckedLinked: Boolean;

begin

  Result := inherited IsCheckedLinked and (FClient.GroupIndex <> 0) and

    FClient.AllowAllUp and (FClient.Down = (Action as TCustomAction).Checked);

end;



function TcSpeedButtonActionLink.IsGroupIndexLinked: Boolean;

begin

  Result := (FClient is TnSpeedButton) and

    (TnSpeedButton(FClient).GroupIndex = (Action as TCustomAction).GroupIndex);

end;



procedure TcSpeedButtonActionLink.SetChecked(Value: Boolean);

begin

  if IsCheckedLinked then TnSpeedButton(FClient).Down := Value;

end;



procedure TcSpeedButtonActionLink.SetGroupIndex(Value: Integer);

begin

  if IsGroupIndexLinked then TnSpeedButton(FClient).GroupIndex := Value;

end;



{ TnSpeedButton }

    

constructor TnSpeedButton.Create(AOwner: TComponent);

var

  I: TButtonState;

begin

FGlyphImgList := TImageList.Create(Self);

FOriginalOver := TBitmap.Create;

FOriginalDown := TBitmap.Create;



  FOriginal := TBitmap.Create;

  FOriginal.OnChange := GlyphChanged;

  FTransparentColor := clOlive;

  for I := Low(I) to High(I) do

    FIndexs[I] := -1;



  inherited Create(AOwner);

  SetBounds(0, 0, 76, 26);

  ControlStyle := [csCaptureMouse, csDoubleClicks];

  ParentFont := True;

  Color := clBtnFace;

  FSpacing := 4;

  FMargin := -1;

  FLayout := blImageLeft;

  FTransparent := True;



  FEnabledGrayScale := [bsGrayScale];

  FEOpacity := 50; //50% de 100 a 1

  FImageChangeLink := TChangeLink.Create;

  FImageChangeLink.OnChange := ImageListChange;

  FImageIndex := -1;

  FOverDraw := false;

  FOverIndexNormal := 0;

  FOverIndexDown   := 1;

  FOverIndexOver   := 2;

  FImgOvSize := false;

end;

    

destructor TnSpeedButton.Destroy;

begin

FGlyphImgList.Clear;

FreeAndNil(FGlyphImgList);

FOriginalOver.Free;

FOriginalDown.Free;

  FOriginal.Free;

  FreeAndNil(FImageChangeLink);

  if Assigned(FInternalImageList) then

    FreeAndNil(FInternalImageList);



  inherited Destroy;

  Invalidate;

end;

    

procedure TnSpeedButton.Paint;

const

  DownStyles: array[Boolean] of Integer = (BDR_RAISEDINNER, BDR_SUNKENOUTER);

  FillStyles: array[Boolean] of Integer = (BF_MIDDLE, 0);

var

  PaintRect: TRect;

  DrawFlags: Integer;

  Offset: TPoint;

  Button: TThemedButton;

  ToolButton: TThemedToolBar;

  Details: TThemedElementDetails;

begin

  if ImgOvSize and (Glyph.Width > 0) and (Glyph.Height > 0) then

      SetBounds(Left, Top, Glyph.Width, Glyph.Height);



  if not Enabled then

  begin

    FState := bsDisabled;

    FDragging := False;

  end else

  if FState = bsDisabled then

    if FDown and (GroupIndex <> 0) then

      FState := bsExclusive

    else

      FState := bsUp;

  Canvas.Font := Self.Font;



  if ThemeServices.ThemesEnabled then

  begin

    PerformEraseBackground(Self, Canvas.Handle);



    if not Enabled then

      Button := tbPushButtonDisabled

    else

      if FState in [bsDown, bsExclusive] then

        Button := tbPushButtonPressed

      else

        if MouseInControl then

          Button := tbPushButtonHot

        else

          Button := tbPushButtonNormal;



    ToolButton := ttbToolbarDontCare;

    if FFlat then

    begin

      case Button of

        tbPushButtonDisabled : Toolbutton := ttbButtonDisabled;

        tbPushButtonPressed  : Toolbutton := ttbButtonPressed;

        tbPushButtonHot      : Toolbutton := ttbButtonHot;

        tbPushButtonNormal   : Toolbutton := ttbButtonNormal;

      end;

    end;



    PaintRect := ClientRect;

    if ToolButton = ttbToolbarDontCare then

    begin

      if not FImgOvNoFlat then

      begin

        Details := ThemeServices.GetElementDetails(Button);

        ThemeServices.DrawElement(Canvas.Handle, Details, PaintRect);

        PaintRect := ThemeServices.ContentRect(Canvas.Handle, Details, PaintRect);

      end;

    end

    else

    begin

      if not FImgOvNoFlat then

      begin

        Details := ThemeServices.GetElementDetails(ToolButton);

        ThemeServices.DrawElement(Canvas.Handle, Details, PaintRect);

        PaintRect := ThemeServices.ContentRect(Canvas.Handle, Details, PaintRect);

      end;

    end;



    if Button = tbPushButtonPressed then

    begin

      // A pressed speed button has a white text. This applies however only to flat buttons.

      if ToolButton <> ttbToolbarDontCare then

        Canvas.Font.Color := clHighlightText;

      Offset := Point(0, 1);

    end

    else

      Offset := Point(0, 0);



    if ((FImageList <> nil) and (FImageIndex >= 0) and (FImageIndex < FImageList.Count)) then

    begin

     Draw(Canvas, PaintRect, Offset, Caption, FLayout, FMargin, FSpacing, FState, Transparent, Enabled, DrawTextBiDiModeFlags(0));

    end else



    Draw(Canvas, PaintRect, Offset, Caption, FLayout, FMargin, FSpacing, FState, Transparent, Enabled, DrawTextBiDiModeFlags(0));

  end else //sen theme

  begin

    PaintRect := Rect(0, 0, Width, Height);



    if not FFlat then

    begin

     if not FImgOvNoFlat then

     begin

      DrawFlags := DFCS_BUTTONPUSH or DFCS_ADJUSTRECT;

      if FState in [bsDown, bsExclusive] then

        DrawFlags := DrawFlags or DFCS_PUSHED;

      DrawFrameControl(Canvas.Handle, PaintRect, DFC_BUTTON, DrawFlags);

     end;

    end else //com FFlat

    begin

      if (FState in [bsDown, bsExclusive]) or (FMouseInControl and (FState <> bsDisabled)) or (csDesigning in ComponentState) then

        if not FImgOvNoFlat then

        DrawEdge(Canvas.Handle, PaintRect, DownStyles[FState in [bsDown, bsExclusive]], FillStyles[Transparent] or BF_RECT)

     else

      if not Transparent then

      begin

        Canvas.Brush.Color := Color;

        Canvas.FillRect(PaintRect);

      end;

      InflateRect(PaintRect, -1, -1);

    end;

    if FState in [bsDown, bsExclusive] then

    begin

      if (FState = bsExclusive) and (not FFlat or not FMouseInControl) then

      begin

        if not FOverDraw then

        begin

         Canvas.Brush.Bitmap := AllocPatternBitmap(clBtnFace, clBtnHighlight);

         Canvas.FillRect(PaintRect);

        end;

      end;

      Offset.X := 1;

      Offset.Y := 1;

    end

    else

    begin

      Offset.X := 0;

      Offset.Y := 0;

    end;

    if ((FImageList <> nil) and (FImageIndex >= 0) and (FImageIndex < FImageList.Count)) then

    begin

     if (FImageIndex > -1) and (FImageIndex < FImageList.Count) then

     begin

       Glyph.Width  := FImageList.Width; Glyph.Height := FImageList.Height;

     end;

     Draw(Canvas, PaintRect, Offset, Caption, FLayout, FMargin, FSpacing, FState, Transparent, Enabled, DrawTextBiDiModeFlags(0));

    end else



    Draw(Canvas, PaintRect, Offset, Caption, FLayout, FMargin, FSpacing, FState, Transparent, Enabled, DrawTextBiDiModeFlags(0));

  end;

end;

    

procedure TnSpeedButton.UpdateTracking;

var

  P: TPoint;

begin

  if FFlat then

  begin

    if Enabled then

    begin

      GetCursorPos(P);

      FMouseInControl := not (FindDragTarget(P, True) = Self);

      if FMouseInControl then

        Perform(CM_MOUSELEAVE, 0, 0)

      else

        Perform(CM_MOUSEENTER, 0, 0);

    end;

  end;

end;

    

procedure TnSpeedButton.Loaded;

var

  State: TButtonState;

begin

  inherited Loaded;

  if Enabled then

    State := bsUp

  else

    State := bsDisabled;

    

  CreateButtonGlyph2(State);

end;

    

procedure TnSpeedButton.MouseDown(Button: TMouseButton; Shift: TShiftState;

  X, Y: Integer);

begin

  inherited MouseDown(Button, Shift, X, Y);

  if (Button = mbLeft) and Enabled then

  begin

    if not FDown then

    begin

      FState := bsDown;

      Invalidate;

    end;

    FDragging := True;

  end;

end;

    

procedure TnSpeedButton.MouseMove(Shift: TShiftState; X, Y: Integer);

var

  NewState: TButtonState;

begin

  inherited MouseMove(Shift, X, Y);

  if FDragging then

  begin

    if not FDown then NewState := bsUp

    else NewState := bsExclusive;

    if (X >= 0) and (X < ClientWidth) and (Y >= 0) and (Y <= ClientHeight) then

      if FDown then NewState := bsExclusive else NewState := bsDown;

    if NewState <> FState then

    begin

      FState := NewState;

      Invalidate;

    end;

  end

  else if not FMouseInControl then

    UpdateTracking;

end;

    

procedure TnSpeedButton.MouseUp(Button: TMouseButton; Shift: TShiftState;

  X, Y: Integer);

var

  DoClick: Boolean;

begin

  inherited MouseUp(Button, Shift, X, Y);

  if FDragging then

  begin

    FDragging := False;

    DoClick := (X >= 0) and (X < ClientWidth) and (Y >= 0) and (Y <= ClientHeight);

    if FGroupIndex = 0 then

    begin

      { Redraw face in-case mouse is captured }

      FState := bsUp;

      FMouseInControl := False;

      if DoClick and not (FState in [bsExclusive, bsDown]) then

        Invalidate;

    end

    else

      if DoClick then

      begin

        SetDown(not FDown);

        if FDown then Repaint;

      end

      else

      begin

        if FDown then FState := bsExclusive;

        Repaint;

      end;

    if DoClick then Click;

    UpdateTracking;

  end;

end;

    

procedure TnSpeedButton.Click;

begin

  inherited Click;

end;

    

function TnSpeedButton.GetPalette: HPALETTE;

begin

  Result := Glyph.Palette;

end;



function TnSpeedButton.GetActionLinkClass: TControlActionLinkClass;

begin

  Result := TcSpeedButtonActionLink;

end;



procedure TnSpeedButton.SetGlyph(Value: TBitmap);

begin

  Invalidate;

  FOriginal.Assign(Value);

  if (Value <> nil) and (Value.Height > 0) then

    FTransparentColor := Value.TransparentColor;

end;



procedure TnSpeedButton.SetGlyphOver(const Value: TBitmap);

begin

  Invalidate;

  FOriginalOver.Assign(Value);

  if (Value <> nil) and (Value.Height > 0) then

    FTransparentColor := Value.TransparentColor;

end;



procedure TnSpeedButton.SetGlyphDown(const Value: TBitmap);

begin

  Invalidate;

  FOriginalDown.Assign(Value);

  if (Value <> nil) and (Value.Height > 0) then

    FTransparentColor := Value.TransparentColor;

end;



procedure TnSpeedButton.GlyphChanged(Sender: TObject);

begin

  if (Sender = FOriginal) or (Sender = FOriginalDown) or (Sender = FOriginalOver) then

  begin

    FTransparentColor := FOriginal.TransparentColor or FOriginalDown.TransparentColor or FOriginalOver.TransparentColor;

    Invalidate;

    if Assigned(FOnChange) then FOnChange(Self);

  end;

  Invalidate;

end;

    

procedure TnSpeedButton.UpdateExclusive;

var

  Msg: TMessage;

begin

  if (FGroupIndex <> 0) and (Parent <> nil) then

  begin

    Msg.Msg := CM_BUTTONPRESSED;

    Msg.WParam := FGroupIndex;

    Msg.LParam := Longint(Self);

    Msg.Result := 0;

    Parent.Broadcast(Msg);

  end;

end;

    

procedure TnSpeedButton.SetDown(Value: Boolean);

begin

  if FGroupIndex = 0 then Value := False;

  if Value <> FDown then

  begin

    if FDown and (not FAllowAllUp) then Exit;

    FDown := Value;

    if Value then

    begin

      if FState = bsUp then Invalidate;

      FState := bsExclusive

    end

    else

    begin

      FState := bsUp;

      Repaint;

    end;

    if Value then UpdateExclusive;

  end;

end;

    

procedure TnSpeedButton.SetFlat(Value: Boolean);

begin

  if Value <> FFlat then

  begin

    FFlat := Value;

    Invalidate;

  end;

end;

    

procedure TnSpeedButton.SetGroupIndex(Value: Integer);

begin

  if FGroupIndex <> Value then

  begin

    FGroupIndex := Value;

    UpdateExclusive;

  end;

end;

    

procedure TnSpeedButton.SetLayout(Value: TButtonLayout);

begin

  if FLayout <> Value then

  begin

    FLayout := Value;

    Invalidate;

  end;

end;

    

procedure TnSpeedButton.SetMargin(Value: Integer);

begin

  if (Value <> FMargin) and (Value >= -1) then

  begin

    FMargin := Value;

    Invalidate;

  end;

end;

    

procedure TnSpeedButton.SetSpacing(Value: Integer);

begin

  if Value <> FSpacing then

  begin

    FSpacing := Value;

    Invalidate;

  end;

end;



procedure TnSpeedButton.SetTransparent(Value: Boolean);

begin

  if Value <> FTransparent then

  begin

    FTransparent := Value;

    if Value then

      ControlStyle := ControlStyle - [csOpaque] else

      ControlStyle := ControlStyle + [csOpaque];

    Invalidate;

  end;

end;



procedure TnSpeedButton.SetAllowAllUp(Value: Boolean);

begin

  if FAllowAllUp <> Value then

  begin

    FAllowAllUp := Value;

    UpdateExclusive;

  end;

end;

    

procedure TnSpeedButton.WMLButtonDblClk(var Message: TWMLButtonDown);

begin

  inherited;

  if FDown then DblClick;

end;

    

procedure TnSpeedButton.CMEnabledChanged(var Message: TMessage);

const

  NewState: array[Boolean] of TButtonState = (bsDisabled, bsUp);

begin

  CreateButtonGlyph2(NewState[Enabled]);

  UpdateTracking;

  Repaint;

end;

    

procedure TnSpeedButton.CMButtonPressed(var Message: TMessage);

var

  Sender: TnSpeedButton;

begin

  if Message.WParam = FGroupIndex then

  begin

    Sender := TnSpeedButton(Message.LParam);

    if Sender <> Self then

    begin

      if Sender.Down and FDown then

      begin

        FDown := False;

        FState := bsUp;

        if (Action is TCustomAction) then

          TCustomAction(Action).Checked := False;

        Invalidate;

      end;

      FAllowAllUp := Sender.AllowAllUp;

    end;

  end;

end;

    

procedure TnSpeedButton.CMDialogChar(var Message: TCMDialogChar);

begin

  with Message do

    if IsAccel(CharCode, Caption) and Enabled and Visible and

      (Parent <> nil) and Parent.Showing then

    begin

      Click;

      Result := 1;

    end else

      inherited;

end;

    

procedure TnSpeedButton.CMFontChanged(var Message: TMessage);

begin

  Invalidate;

end;

    

procedure TnSpeedButton.CMTextChanged(var Message: TMessage);

begin

  Invalidate;

end;

    

procedure TnSpeedButton.CMSysColorChange(var Message: TMessage);

begin

  Invalidate;

end;



procedure TnSpeedButton.CMMouseEnter(var Message: TMessage);

var

  NeedRepaint, OnOffThemeServices: Boolean;

begin

  inherited;

  if Assigned(FOnMouseEnter) then FOnMouseEnter(Self);

  { Don't draw a border if DragMode <> dmAutomatic since this button is meant to

    be used as a dock client. }

  if FOverDraw then

    OnOffThemeServices := FOverDraw

  else

    OnOffThemeServices := ThemeServices.ThemesEnabled;



  NeedRepaint := FFlat and not FMouseInControl and Enabled and (DragMode <> dmAutomatic) and (GetCapture = 0);



  { Windows XP introduced hot states also for non-flat buttons. }

  if (NeedRepaint or OnOffThemeServices) and not (csDesigning in ComponentState) then

  begin

    FMouseInControl := True;

    if Enabled then

      Repaint;

  end;           

end;



procedure TnSpeedButton.CMMouseLeave(var Message: TMessage);

var

  NeedRepaint, OnOffThemeServices: Boolean;

begin

  inherited;

  if Assigned(FOnMouseLeave) then FOnMouseLeave(Self);



  if FOverDraw then

    OnOffThemeServices := FOverDraw

  else

    OnOffThemeServices := ThemeServices.ThemesEnabled;



  NeedRepaint := FFlat and FMouseInControl and Enabled and not FDragging;

  { Windows XP introduced hot states also for non-flat buttons. }

  if NeedRepaint or OnOffThemeServices then

  begin

    //if FOverDraw then

    FMouseInControl := False;

    if Enabled then

      Repaint;

  end;

end;



procedure TnSpeedButton.ActionChange(Sender: TObject; CheckDefaults: Boolean);



  procedure CopyImage(ImageList: TCustomImageList; Index: Integer);

  begin

    with Glyph do

    begin

      Width := ImageList.Width;

      Height := ImageList.Height;

      Canvas.Brush.Color := clFuchsia;//! for lack of a better color

      Canvas.FillRect(Rect(0,0, Width, Height));

      ImageList.Draw(Canvas, 0, 0, Index);

    end;

  end;



begin

  inherited ActionChange(Sender, CheckDefaults);

  if Sender is TCustomAction then

    with TCustomAction(Sender) do

    begin

      if CheckDefaults or (Self.GroupIndex = 0) then

        Self.GroupIndex := GroupIndex;

      { Copy image from action's imagelist }

      if (Glyph.Empty) and (ActionList <> nil) and (ActionList.Images <> nil) and

        (ImageIndex >= 0) and (ImageIndex < ActionList.Images.Count) then

        CopyImage(ActionList.Images, ImageIndex);

    end;

end;



procedure TnSpeedButton.AlphaTransBitmap(Canvas: TCanvas; const PsW, PsH: Integer;

  const SrcBmp: TBitmap; Enabled_GScale_Opacity: Boolean);

var

 TmpDstBmp: TBitmap;

 w,h : Integer;

 aR1 : TRect;



//===Opacidade bitmap  e  tom cinza Bitmap============================

 function nGrayScaleOpacity(Bmp: TBitmap): TBitmap;

 var

   ScanL, SA : PRGBAArray;

   x, Y, w, h : integer;

 begin

  if (FEnabledGrayScale = [bsGrayScale]) or (FEnabledGrayScale = [bsGrayScale, bsOpacity]) then

  begin

   h := Bmp.Height - 1;

   w := Bmp.Width - 1;

   for Y := 0 to h do begin

     SA := Bmp.scanline[Y];

     for x := 0 to w do begin

       SA[x].R := (SA[x].R + SA[x].G + SA[x].B) div 3;

       SA[x].G := SA[x].R;

       SA[x].B := SA[x].R;

     end;

   end;

  end;

 if (FEnabledGrayScale = [bsOpacity]) or (FEnabledGrayScale = [bsOpacity, bsGrayScale]) then

 begin

   for Y := 0 to Bmp.Height - 1 do

   begin

     ScanL := Bmp.ScanLine[Y];

     for X := 0 to Bmp.Width - 1 do

     ScanL[X].A := (ScanL[X].A * FEOpacity) div 100;

   end;

 end;

 Result := Bmp;

 end;

//====================================================================

 //Criar Bitmap Virtual 32 Btis

 function CreateBmpV32(const Width, Height : integer) : TBitmap;

 begin

  Result := TBitmap.Create;

  Result.PixelFormat := pf32bit;

  Result.HandleType := bmDIB;

  Result.Width  := Width;

  Result.Height := Height;

 end;

  // converte canal alpha!

 procedure ConvertAlphaChannelBmp32b(R1, R2 : TRect; const BmpDst, BmpSrc : TBitmap);

 var

   S1 : PRGBAArray;

   S2 : PRGBAArray;

   X, Y, h, w, sX1, sX2: Integer;

   Col_ : TnColor_;

 begin

   if BmpSrc = nil then Exit;



   BmpSrc.PixelFormat := pf32Bit;



   h := Min((R1.Bottom - R1.Top),(R2.Bottom - R2.Top));

   h := Min(h, BmpDst.Height - R1.Top);

   h := Min(h, BmpSrc.Height - R2.Top) - 1;

   if h < 0 then Exit;

   w := Min((R1.Right - R1.Left), (R2.Right - R2.Left));

   w := Min(w, BmpDst.Width - R1.Left);

   w := Min(w, BmpSrc.Width - R2.Left);

   if w < 0 then Exit;



   w := Min(w, BmpDst.Width - R1.Left);

   w := Min(w, BmpSrc.Width - R2.Left) - 1;



   for Y := 0 to h do

   begin

     S1 := BmpDst.ScanLine[R1.Top + Y];

     S2 := BmpSrc.ScanLine[R2.Top + Y];

     sX1 := R1.Left;

     sX2 := R2.Left;

     for X := 0 to w do

     begin

       Col_ := S2[sX2];

       if Col_.C <> clFuchsia then

       begin

         S1[sX1].R := (((S2[sX2].R - S1[sX1].R) * S2[sX2].A + S1[sX1].R shl 8) shr 8) and MaxByte;

         S1[sX1].G := (((S2[sX2].G - S1[sX1].G) * S2[sX2].A + S1[sX1].G shl 8) shr 8) and MaxByte;

         S1[sX1].B := (((S2[sX2].B - S1[sX1].B) * S2[sX2].A + S1[sX1].B shl 8) shr 8) and MaxByte;

       end;

       inc(sX1);

       inc(sX2);

     end;

   end;

 end;



 //Inicio da Funcção no Bitmap

begin

 aR1:= Rect(0, 0, SrcBmp.Width, SrcBmp.Height);

 w := aR1.Right  - aR1.Left;

 h := aR1.Bottom -  aR1.Top;

 TmpDstBmp := CreateBmpV32(w, h);



 if not Enabled_GScale_Opacity then

   nGrayScaleOpacity(SrcBmp);



  if not ((w = SrcBmp.Width) or (h = SrcBmp.Height)) then Exit;

  try

    SrcBmp.PixelFormat := pf32bit;

    SrcBmp.Width  := w;

    SrcBmp.Height := h;

    BitBlt(TmpDstBmp.Canvas.Handle, 0, 0, w, h, Canvas.Handle, PsW, PsH, SRCCOPY);

    ConvertAlphaChannelBmp32b(Classes.Rect(0, 0, w, h), Classes.Rect(0, 0, w, h), TmpDstBmp, SrcBmp);

    BitBlt(Canvas.Handle, PsW, PsH, TmpDstBmp.Width, TmpDstBmp.Height, TmpDstBmp.Canvas.Handle, 0, 0, SRCCOPY);

  finally

   FreeAndNil(TmpDstBmp);

  end;

end;



procedure TnSpeedButton.SetEnabledGrayScale(const Value: TEnabled_IGs);

begin

  if not Enabled then begin

    if EnabledGrayScale <> Value then

      FEnabledGrayScale := Value;

    Invalidate;

  end;

end;



procedure TnSpeedButton.SetEnabledOpacity(const Value: integer);

begin

  if not Enabled then

  begin

    if FEOpacity <> Value then

    begin

      if Value < 0 then

        FEOpacity := 0

      else

        if Value > 100 then

          FEOpacity := 100

        else

        FEOpacity := Value;

    Invalidate;

    end;

  end;

end;



procedure TnSpeedButton.SetImageIndex(const Value: TImageIndex);

begin

 if (FImageIndex <> Value) then

 begin

  FImageIndex := Value;



  if FImageIndex = -1 then

  begin

      FOriginal.Assign(nil);

      Glyph.Assign(nil);

  end;

 Invalidate;

 end;

end;



procedure TnSpeedButton.SetImages(const Value: TCustomImageList);

begin

 if ImageList <> Value then

 begin

    if ImageList <> nil then ImageList.UnRegisterChanges(FImageChangeLink);

    FImageList := Value;

    if FImageList <> nil then

    begin

      ImageList.RegisterChanges(FImageChangeLink);

      ImageList.FreeNotification(Self);

    end;

 end;

end;



procedure TnSpeedButton.ImageListChange(Sender: TObject);

begin

  Invalidate;

end;



procedure TnSpeedButton.DrawButtonImgList(Canvas: TCanvas; const GlyphPos: TPoint;

  State: TButtonState; Transparent, SetGrayScaleAndOpacity: Boolean);

var

 Bmp : TBitmap;

 MakeColor : TColor;



  procedure PreparingBitmap(IndexToInsert: Integer; ImageListToInsert: TCustomImageList);

  begin

    Bmp.Width  := ImageListToInsert.Width;

    Bmp.Height := ImageListToInsert.Height;

    Bmp.PixelFormat := pf32bit;

    if ImageListToInsert.BkColor <> clNone then

      MakeColor := ImageListToInsert.BkColor

    else

      MakeColor := clFuchsia;

    Bmp.Canvas.Brush.Color := MakeColor;

    Bmp.Canvas.FillRect(Rect(0, 0, Bmp.Width, Bmp.Height));

    ImageListToInsert.GetBitmap(IndexToInsert, Bmp);

  end;    

begin

  bmp := TBitmap.Create;

  if FOverDraw then

  begin

    if (FState = bsDown) or (Down) then

      PreparingBitmap(ImgOvIdxDown, FImageList)

    else

    if MouseInControl then

      PreparingBitmap(ImgOvIdxOver, FImageList)

    else



     PreparingBitmap(ImgOvIdxNormal, FImageList)

  end else



   PreparingBitmap(FImageIndex, FImageList);

  try

   AlphaTransBitmap(Canvas, GlyphPos.X, GlyphPos.Y, Bmp, SetGrayScaleAndOpacity);

  finally

   FreeAndNil(Bmp);

  end;

end;



procedure TnSpeedButton.SetOverDraw(const Value: Boolean);

begin

 if FOverDraw <> Value then

 begin

   FOverDraw := Value;

   if not FFlat then

     FFlat := true;

   Flat := FFlat;  

   Invalidate;

 end;

end;



procedure TnSpeedButton.SetImgOvSize(const Value: Boolean);

begin

  if FImgOvSize <> Value then

  begin

    FImgOvSize := Value;

     if ImgOvSize and (Glyph.Width > 0) and (Glyph.Height > 0) then

       SetBounds(Left, Top, Glyph.Width, Glyph.Height);

    Invalidate;

  end;

end;



procedure TnSpeedButton.SetImgOvNoFlat(const Value: Boolean);

begin

  if FImgOvNoFlat <> Value then

  begin

    FImgOvNoFlat := Value;

    Invalidate;

  end;

end;



initialization

  {$IFDEF Pnggraphics}

   // TPicture.RegisterFileFormat('png','Portable network graphics (TPNGGraphic)', TPNGGraphic);

  {$ENDIF}



finalization

  {$IFDEF Pnggraphics}

     //TPicture.UnregisterGraphicClass(TPNGGraphic);

  {$ENDIF}



end.