nSpeedButton

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.