RAD 11 Delphi - Wie erstelle ich Collections ?

[paule32.jk]

Hallo,
wie der Betreff schon sagt: wie erstelle ich Collections, die im Designer erstellt werden können ?
Habe dazu schon ein wenig Cose-Schnippsel:

Delphi-Quellcode:

unit ResComponent;

interface

uses
  System.SysUtils, System.Classes,
  System.Generics.Collections,
  System.Contnrs;

type
  TResourceHolderElements = class
  private
    FElementId: Integer;
    FName: String;
  public
    constructor Create(const AElementId: Integer; const AName: String);

    property ElementID: Integer read FElementId;
    property Name: String read FName;
  end;

  TResourceHolderCategories = class(TComponent)
  private
    FName: String;
    FElements: TObjectList<TResourceHolderElements>;
  public
    constructor Create(const AName: String);
    destructor Destroy; override;

    property Name: String read FName;
    property Elements: TObjectList<TResourceHolderElements> read FElements;
  end;

  TResourceHolderElementName = record
  public
    ElementId: Integer;
    Name: String;
    constructor Create(const AElementID: Integer; const AName: String);
  end;

  TComponent1 = class(TComponent)
  private
  protected
  public
  published
  end;

procedure Register;

implementation

constructor TResourceHolderCategories.Create(const AName: string);
begin
  FName := AName;
  FElements := TObjectList<TResourceHolderElements>.Create;
end;

destructor TResourceHolderCategories.Destroy;
begin
  FElements.Free;
  inherited Destroy;
end;

constructor TResourceHolderElementName.Create(const AElementID: Integer; const AName: string);
begin
  ElementID := AElementID;
  Name := AName;
end;

constructor TResourceHolderElements.Create(const AElementId: Integer; const AName: string);
begin
  FElementID := AElementID;
  FName := AName;
end;

procedure Register;
begin
  RegisterComponents('KALLUP', [TComponent1, TResourceHolderCategories]);
end;

end.

[Olli73]

Hier mal eine nicht visuelle Komponente, die eine Stringlist (hier nicht relevant) und eine Collection von StringListen enthält.

Delphi-Quellcode:

unit StringsContainer;

interface

uses
  Windows, Messages, SysUtils, Classes;

type


  TStringsColItm = class(TCollectionItem)
  private
    FESL: TStringList;
    procedure SetESL(Value: TStringList);
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;
  published
    property ESL: TStringList read FESL write SetESL;
  end;


  TStringsCol = class(TCollection)
  private
    function GetItem(Idx: Integer): TStringsColItm;
    procedure SetItem(Idx: Integer; Value: TStringsColItm);
  public
    property XItems[Idx: Integer]: TStringsColItm read GetItem write SetItem; default;
  published
  end;



  TStringsContainer = class(TComponent)
  private
    { Private declarations }
    FSL: TStringList;
    FSC: TStringsCol;
    procedure SetSL(Value: TStringList);
    procedure SetSC(Value: TStringsCol);
  protected
    { Protected declarations }
  public
    { Public declarations }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    { Published declarations }
    property SL: TStringList read FSL write SetSL;
    property SC: TStringsCol read FSC write SetSC;
  end;

procedure Register;

implementation


constructor TStringsColItm.create(Collection: TCollection);
begin
  inherited;
  FESL := TStringList.Create;
end;


destructor TStringsColItm.destroy;
begin
  FESL.Free;
  inherited;
end;


function TStringsCol.GetItem(Idx: Integer): TStringsColItm;
begin
  result := TStringsColItm(inherited Items[Idx]);
end;


procedure TStringsCol.SetItem(Idx: Integer; Value: TStringsColItm);
begin
  inherited Items[Idx] := Value;
end;


procedure TStringsContainer.SetSL(Value: TStringList);
begin
  FSL.Assign(Value);
end;


constructor TStringsContainer.Create(AOwner: TComponent);
begin
  inherited;
  FSL := TStringList.Create;
  FSC := TStringsCol.Create(TStringsColItm);
end;


destructor TStringsContainer.destroy;
begin
  FSL.Free;
  FSC.Free;
  inherited;
end;


procedure Register;
begin
  RegisterComponents('MyComps', [TStringsContainer]);
end;

procedure TStringsColItm.SetESL(Value: TStringList);
begin
  FESL.Assign(Value);
end;

procedure TStringsContainer.SetSC(Value: TStringsCol);
begin
  FSC.Assign(Value);
end;

end.

[himitsu]

aus Array registrieren - geht das ?

Zitat:

Zitat von himitsu (Beitrag 1526992)

Warum eine komische Collection?
TDictionary

Delphi-Quellcode:

TDictionary<string,TArray<deintyp>>

[paule32.jk]

@olli73:
Danke für Deine Bemühungen !

Du verwendest zwei mal TStringList.Create im Code ...
liegen dann nicht 2 Kopien des gleichen Typs im Speicher ?

[Olli73]

das eine (FSL) ist eine Stringlist der Komponente, also keine Collection, hier nicht relevant. Das andere (FESL) ist dann eine StringList pro CollectionItem.

[paule32.jk]

okay.

kann man nun Dein Beispiel so erweitern,
- das man nur das Property SC im Container hat,
- ein Property für einen Property-Editor, evtl. Marke Eigenbau,
- das 2. Property an ein TComponent wie TImage oder TMemo übergeben kann ?

sprich:
- man hat pro SC, ein entsprechendes Objekt auf der Form Zugriff

[Olli73]

Zitat:

Zitat von paule32.jk (Beitrag 1527004)

okay.

kann man nun Dein Beispiel so erweitern,

Zitat:

- das man nur das Property SC im Container hat,

Das "SL" kannst du ja rauswerfen...

Zitat:

- ein Property für einen Property-Editor, evtl. Marke Eigenbau,

Du kannst einen eigenen Property-Editor programmieren, habe ich aber noch nie gemacht.

Zitat:

- das 2. Property an ein TComponent wie TImage oder TMemo übergeben kann ?

Wie meinst du das?

Zitat:

sprich:
- man hat pro SC, ein entsprechendes Objekt auf der Form Zugriff

Dann musst du das create und assign weglassen...

[Olli73]

Beim letzten Punkt bin ich mir nicht sicher, ob ich dich richtig verstanden habe.

Falls du doch eine Subkomponente haben möchtest, musst du ggf. noch "SetSubComponent" aufrufen:

https://docwiki.embarcadero.com/Libr...etSubComponent

[paule32.jk]

ich Versuche es mal verständlicher:

- ein Property für Collection
- pro Collection Item ein Property, wo man einen Property-Editor öffnen kann, mit dessen Hilfe
man eine Datei laden kann, und die Bytes dieser Datei and das Property in der Collection
übergeben kann
- die Datei-Daten - die Bytes also, wenn man RAD Weg nimmt, in der DFM gespeichert werden, so wie
man das mit den TImage machen kann - dort liegt doch auch unter den Property "Picture" die Daten
für das Bild.

Man könnte auch zwei Properties nehmen, eins für den Editor, und eins für die Daten.
Wobei ich da mir noch nicht sicher bin, ob und wie man da DesignTime Editor in einen DesignTime
Package, mit einen Runtime-Package auslagert.

Weil, ich irgendwo hier mal gelesen habe, das Emberracado das mitschleifen von DesignEditor Packages
aus Eigenen Haus, untersagt - deshalb die Sache, mit den selber basteln...

[Olli73]

Warum nicht einfach ein property vom Typ TFileName machen, dann hast du schonmal einen Dateiauswahldialog, und im Setter die Datei dann als Base64-String speichern, dies landet dann in der DFM.

[paule32.jk]

sodele, jetzt habe ich wieder ein Problem:

Delphi-Quellcode:

uses
  System.SysUtils, System.Classes,
  System.Generics.Collections,
  System.Contnrs,

  DesignIntf, DesignEditors;

Die letzten beiden Units können nicht gefunden werden.

[paule32.jk]

okay, ToolsApi Pfad, und designide.dcp ...
dann erhalte ich sowas (keine Fehlermeldung, aber bei Collection->Text öffnet sich kein Editor):

Delphi-Quellcode:

unit ResComponent;

interface

uses
  System.SysUtils, System.Classes,
  System.Generics.Collections,
  System.Contnrs,
  VCL.Forms,

  DesignIntf, DesignEditors;

type
  TText0 = type Integer;
  TText0Property = class(TPropertyEditor)
  public
    function GetAttributes: TPropertyAttributes; override;
    procedure Initialize; override;
    procedure Edit; override;
    function GetValue: string; override;
    procedure SetValue(const Value: string); overload; override;
  end;

type
  TResourceHolderItem = class(TCollectionItem)
  private
    FStringList: TStringList;
    FTextProperty: TText0Property;
    procedure setStringList(AValue: TStringList);
  public
    constructor Create(Collention: TCollection); override;
    destructor Destroy; override;
  published
    property Element: TStringList read FStringList write setStringList;
    property Text: TText0Property read FTextProperty write FTextProperty;
  end;

  TResourceHolder = class(TCollection)
  private
    function GetItem(AIndex: Integer): TResourceHolderItem;
    procedure SetItem(AIndex: Integer; AValue: TResourceHolderItem);
  public
    property Items[Index : Integer]: TResourceHolderItem read GetItem write SetItem;
  end;

  TCompressedResource = class(TComponent)
  private
    FStringList: TStringList;
    FCollection: TResourceHolder;
    procedure SetStringList(AValue: TStringList);
    procedure SetCollection(AValue: TResourceHolder);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
  published
    property Collection: TResourceHolder read FCollection write SetCollection;
    property StringList: TStringList read FStringList write SetStringList;
  end;

procedure Register;

implementation

constructor TResourceHolderItem.Create(Collention: TCollection);
begin
  inherited;
  FStringList := TStringList.Create;
end;

destructor TResourceHolderItem.Destroy;
begin
  FStringList.Clear;
  FStringList.Free;
  FStringList := nil;
  inherited;
end;

procedure TResourceHolder.SetItem(AIndex: Integer; AValue: TResourceHolderItem);
begin
  inherited Items[AIndex] := AValue;
end;

function TResourceHolder.GetItem(AIndex: Integer): TResourceHolderItem;
begin
  result := TResourceHolderItem(inherited Items[AIndex]);
end;

procedure TResourceHolderItem.setStringList(AValue: TStringList);
begin
  FStringList.Assign(AValue);
end;

constructor TCompressedResource.Create(AOwner: TComponent);
begin
  inherited;

  FStringList := TStringList.Create;
  FCollection := TResourceHolder.Create(TResourceHolderItem);
end;

destructor TCompressedResource.Destroy;
begin
  FStringList.Clear;
  FStringList.Free;
  FStringList := nil;

  FCollection.Clear;
  FCollection.Free;
  FCollection := nil;

  inherited;
end;

procedure TCompressedResource.SetStringList(AValue: TStringList);
begin
  FStringList.Assign(AValue);
end;

procedure TCompressedResource.SetCollection(AValue: TResourceHolder);
begin
  FCollection.Assign(AValue);
end;


procedure TText0Property.Edit;
var
  F: TForm;
begin
  F := TForm.Create(nil);
  try
    F.Position := poScreenCenter;
    F.Height := Screen.Height - 100;
    F.Width := 500;
    F.ShowModal;
  finally
    F.Free;
  end;
end;

function TText0Property.GetAttributes: TPropertyAttributes;
begin
  Result := [paDialog];
end;

function TText0Property.GetValue: string;
begin
   Result := '100';
end;

procedure TText0Property.Initialize;
begin
  inherited;
end;

procedure TText0Property.SetValue(const Value: string);
begin
  SetOrdValue(StrToInt(Trim(Copy(Value, 1, Pos(':', Value + ':') - 1))));
end;

procedure Register;
begin
  RegisterPropertyEditor(
    TypeInfo(TText0),
    TResourceHolderItem,
    'Text',
    TText0Property);

  RegisterComponents('KALLUP', [TCompressedResource]);
end;

end.

[Olli73]

Wie oben schon geschrieben habe ich noch keinen Property-Editor geschrieben, aber muss es nicht heißen:

FTextProperty: TText0;

[himitsu]

Dass es diese Units nicht als PAS/DCU gibt, wird doch überall erklärt?`
Es muß das Package "designide" benutzt (via requires gelinkt) werden.


Beim RegisterPropertyEditor müssen nicht alle Parameter gefüllt werden.
* Type der Klasse
* Name des Property
* Type des Property

ist es ein eindeutiger Type, dann reicht Letzteres,
ansonsten auch Klasse+Name
aber aber Klasse+Name+Propertytyp geht auch

In Teilen hat man den Vorteil, dass man mehrere Klassen/Property damit versorgen kann.