unit DzPngCollection;

SysUtils, Classes, Types, {$IFDEF HAS_SYSTEM_UITYPES}System.UITypes,{$ENDIF} Graphics

{$IFDEF DCC}{$IFDEF HAS_UNIT_SCOPE}, Vcl.Imaging.PngImage{$ELSE}, pngimage{$ENDIF}{$ENDIF};

{$IFDEF FPC}

TPngImage = TPortableNetworkGraphic;

{$ENDIF}

TDzPngCollectionItem = class;

TDzPngCollectionItems = class;

{$region ' --- TDzPngCollection --- '}

TDzPngCollection = class(TComponent)

private

FItems: TDzPngCollectionItems;

procedure EnableOrDisableAll(const Enable: Boolean);

public

constructor Create(AOwner: TComponent); override;

destructor Destroy; override;

procedure Clear;

procedure EnableAll;

procedure DisableAll;

function PngIndex(const PngName: string; IgnoreCase: Boolean = False): integer;

function Count: integer;

function IsValidIndex(const Index: integer): Boolean;

function AddPngImageFromFile(const FileName: string): integer; // Returns the index of the added item

function AddPngImage(Png: TPngImage; ImageName: string = ''; Description: string = ''; Enabled: Boolean = True; ATag: integer = 0): integer;

function GetPngImage(const Index: integer): TPngImage;

function GetPngImageByName(const PngName: string; IgnoreCase: Boolean = True): TPngImage; // Returns the first PngImage with the given name

function ReportStr: string; // for debug

published

property Items: TDzPngCollectionItems read FItems write FItems;

end;

{$endregion TDzPngCollection}

{$region ' --- TDzPngCollectionItems --- '}

TDzPngCollectionItems = class(TCollection)

private

FOwner: TPersistent;

function GetItem(Index: Integer): TDzPngCollectionItem;

procedure SetItem(Index: Integer; const Value: TDzPngCollectionItem);

protected

function GetOwner: TPersistent; override;

procedure Update(Item: TCollectionItem); override;

function IsValidIndex(const Index: integer): Boolean;

public

constructor Create(AOwner: TPersistent);

function Add: TDzPngCollectionItem; //reintroduce;

procedure Assign(Source: TPersistent); override;

function Insert(Index: Integer): TDzPngCollectionItem;

property Items[index: Integer]: TDzPngCollectionItem read GetItem write SetItem; default;

end;

{$endregion TDzPngCollectionItems}

{$region ' --- TDzPngCollectionItem --- '}

TDzPngCollectionItem = class(TCollectionItem)

private

FName: string;

FDescription: string;

FPngImage: TPngImage;

FTag: integer;

FEnabled: Boolean;

procedure SetPngImage(const Value: TPngImage);

function GetWidth: integer;

function GetHeight: integer;

protected

procedure AssignTo(Dest: TPersistent); override;

function GetDisplayName: string; override;

public

constructor Create(ACollection: TCollection); overload; override;

destructor Destroy; override;

procedure Assign(Source: TPersistent); override;

published

property Name: string read FName write FName;

property Description: string read FDescription write FDescription;

property PngImage: TPngImage read FPngImage write SetPngImage;

property Width: integer read GetWidth;

property Height: integer read GetHeight;

property Tag: integer read FTag write FTag default 0;

property Enabled: Boolean read FEnabled write FEnabled default True;

end;

{$endregion TDzPngCollectionItem}

constructor TDzPngCollection.Create(AOwner: TComponent);

inherited Create(AOwner);

FItems := TDzPngCollectionItems.Create(Self);

end;

destructor TDzPngCollection.Destroy;

FItems.Free;

inherited Destroy;

end;

procedure TDzPngCollection.Clear;

FItems.Clear;

end;

function TDzPngCollection.Count: integer;

Result := FItems.Count;

end;

procedure TDzPngCollection.DisableAll;

EnableOrDisableAll(False);

end;

procedure TDzPngCollection.EnableAll;

EnableOrDisableAll(True);

end;

procedure TDzPngCollection.EnableOrDisableAll(const Enable: Boolean);

i: integer;

for i := 0 to FItems.Count - 1 do

FItems[i].Enabled := Enable;

end;

function TDzPngCollection.IsValidIndex(const Index: integer): Boolean;

Result := Items.IsValidIndex(Index);

end;

function TDzPngCollection.AddPngImageFromFile(const FileName: string): integer;

Png: TPngImage;

if not FileExists(FileName) then Exit(-1);

Png := TPngImage.Create;

try

try

Png.LoadFromFile(FileName);

Result := AddPngImage(Png);

except

Result := -1;

end;

finally

Png.Free;

end;

end;

function TDzPngCollection.AddPngImage(Png: TPngImage; ImageName: string; Description: string; Enabled: Boolean; ATag: integer): integer;

pci: TDzPngCollectionItem;

pci := Items.Add;

try

pci.PngImage.Assign(Png);

Result := pci.Index;

if ImageName <> '' then pci.Name := ImageName;

pci.Description := Description;

pci.Enabled := Enabled;

pci.Tag := ATag;

except

Result := -1;

end;

end;

function TDzPngCollection.GetPngImage(const Index: integer): TPngImage;

Result := Items[Index].PngImage;

end;

function TDzPngCollection.GetPngImageByName(const PngName: string; IgnoreCase: Boolean): TPngImage;

x: integer;

x := PngIndex(PngName, IgnoreCase);

if x < 0 then Exit(nil);

Result := Items[x].PngImage;

end;

function TDzPngCollection.ReportStr: string;

ENDL = sLineBreak;

i: integer;

s, Sep: string;

pci: TDzPngCollectionItem;

b: Boolean;

function BoolToStrYN(const b: Boolean): string;

begin

if b then Result := 'Yes' else Result := 'No';

end;

s :=

'PngCollection: ' + Self.Name + ENDL +

'Items: ' + IntToStr(Items.Count) + ENDL;

Sep := ' ';

for i := 0 to Items.Count - 1 do

begin

pci := Items[i];

s := s + 'Item ' + IntToStr(i + 1) + ENDL;

s := s + Sep + 'Index: ' + IntToStr(pci.Index) + ENDL;

s := s + Sep + 'Name: ' + pci.Name + ENDL;

s := s + Sep + 'Description: ' + pci.Description + ENDL;

s := s + Sep + 'Enabled: ' + BoolToStrYN(pci.Enabled) + ENDL;

s := s + Sep + 'Tag: ' + IntToStr(pci.Tag) + ENDL;

b := pci.PngImage.Empty;

s := s + Sep + 'Empy image: ' + BoolToStrYN(b) + ENDL;

if b then Continue;

s := s + Sep + 'Width: ' + IntToStr(pci.PngImage.Width) + ENDL;

s := s + Sep + 'Height: ' + IntToStr(pci.PngImage.Height) + ENDL;

{$IFDEF DCC}

s := s + Sep + 'Bit depth: ' + IntToStr(pci.PngImage.Header.BitDepth) + ENDL;

s := s + Sep + 'Compression level: ' + IntToStr(pci.PngImage.CompressionLevel) + ENDL;

s := s + Sep + 'Compression method: ' + IntToStr(pci.PngImage.Header.CompressionMethod) + ENDL;

//s := s + Sep + 'Transparent color: ' + ColorToRgbIntStr(pci.PngImage.TransparentColor) + ENDL;

{$ENDIF}

end;

Result := s;

end;

function TDzPngCollection.PngIndex(const PngName: string; IgnoreCase: Boolean): integer;

i: integer;

s: string;

b: Boolean;

Result := -1;

if FItems.Count = 0 then Exit;

s := PngName;

if IgnoreCase then s := AnsiUpperCase(s);

for i := 0 to FItems.Count - 1 do

begin

if IgnoreCase then b := s = AnsiUpperCase(FItems[i].Name)

else b := s = FItems[i].Name;

if b then

begin

Result := i;

Break;

end;

end;

end;

constructor TDzPngCollectionItems.Create(AOwner: TPersistent);

inherited Create(TDzPngCollectionItem);

FOwner := AOwner;

end;

function TDzPngCollectionItems.Add: TDzPngCollectionItem;

Result := TDzPngCollectionItem(inherited Add);

end;

procedure TDzPngCollectionItems.Assign(Source: TPersistent);

inherited Assign(Source);

Update(nil);

end;

function TDzPngCollectionItems.IsValidIndex(const Index: integer): Boolean;

Result := (Index >= 0) and (Index < Count);

end;

function TDzPngCollectionItems.GetItem(Index: Integer): TDzPngCollectionItem;

if IsValidIndex(Index) then Result := TDzPngCollectionItem(inherited Items[Index])

else Result := nil;

end;

procedure TDzPngCollectionItems.SetItem(Index: Integer; const Value: TDzPngCollectionItem);

if IsValidIndex(Index) then inherited Items[Index] := Value;

end;

procedure TDzPngCollectionItems.Update(Item: TCollectionItem);

inherited Update(Item);

end;

function TDzPngCollectionItems.Insert(Index: Integer): TDzPngCollectionItem;

Result := TDzPngCollectionItem(inherited Insert(Index));

end;

function TDzPngCollectionItems.GetOwner: TPersistent;

Result := FOwner;

end;

constructor TDzPngCollectionItem.Create(ACollection: TCollection);

inherited Create(ACollection);

FPngImage := TPngImage.Create;

FName := 'Png_' + IntToStr(Index);

FTag := 0;

FEnabled := True;

end;

destructor TDzPngCollectionItem.Destroy;

FPngImage.Free;

inherited Destroy;

end;

procedure TDzPngCollectionItem.Assign(Source: TPersistent);

if Source is TDzPngCollectionItem then

begin

FPngImage.Assign(TDzPngCollectionItem(Source).PngImage);

FName := TDzPngCollectionItem(Source).Name;

FTag := TDzPngCollectionItem(Source).Tag;

FEnabled := TDzPngCollectionItem(Source).Enabled;

end

else

inherited Assign(Source);

end;

procedure TDzPngCollectionItem.AssignTo(Dest: TPersistent);

inherited AssignTo(Dest);

if (Dest is TDzPngCollectionItem) then TDzPngCollectionItem(Dest).PngImage := FPngImage;

end;

function TDzPngCollectionItem.GetDisplayName: string;

if Length(FName) = 0 then Result := inherited GetDisplayName

else Result := FName;

end;

function TDzPngCollectionItem.GetHeight: integer;

if PngImage.Empty then Result := 0

else Result := PngImage.Height;

end;

function TDzPngCollectionItem.GetWidth: integer;

if PngImage.Empty then Result := 0

else Result := PngImage.Width;

end;

procedure TDzPngCollectionItem.SetPngImage(const Value: TPngImage);

if FPngImage = nil then FPngImage := TPngImage.Create;

FPngImage.Assign(Value);

FTag := 0;

Changed(False);

end;

end.