Hallo, ich habe ein Projekt mit folgender Daten- und Klassenstruktur:

zusammenfalten · markieren

Delphi-Quellcode:

    { TmySelectableItem }

    TmySelectableItem = class(TObject)
               private
                fString: string;
                fselected: boolean;
                procedure SetPicture(AValue: gfxImage);
               public
                constructor Create;
                destructor Destroy; override;
                property theString : string read fString write fString;
                property selected : boolean read fSelected write fSelected;
               end;

    { TmySelectableItems }

    TmySelectableItems = class(TList) //Erzeugt eine Liste in einer Spalte
    private
       FSelItems: TList;
       function GetSelected(Index: Integer): boolean;
       function GetStrings(Index: Integer): String;
       procedure SetSelected(Index: Integer; AValue: boolean);
       procedure SetStrings(Index: Integer; AValue: String);
    public
       constructor create;
       function AddItem(aItem: TmySelectableItem): Integer;
       property Strings[Index: Integer]: String read GetStrings write SetStrings; default;
       property Selected[Index: Integer]: boolean read GetSelected write SetSelected;
    end;

    { TmySelectBox }

    TmySelectBox = class (TmyAnyBox)
        public
            

            strings : TmySelectableItems; //Hier entsteht die Spalte die in dieser Klasse auch angezeigt wird
            
    end;

Mein NachfolgeObjekt sieht so aus:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TmySelectableMatrixOfCols_And_Rows = class(TList) //Weil ich nicht nur Zeilen, sondern auch Spalten haben will
    FColCount: Integer;
    FRowCount: Integer;
    FGridCols: TmySelectBox.Strings;
    
    //TMySelectBox soll hier die Spalten liefern, deren Inhalt TmySelectableItems sind und zeilenweise angeordnet sind
    //TmySelectBox ist sichtbar und enthält das Feld Strings vom Typ TmySelectableItems
    
    function GetCells(ColIX, RowIX: Integer): TmySelectableItem; //TMySelectBox ist die Spalte, die Strings (TmySelectableItems) die Zeileninhalte
    function GetCols: Integer;
    function GetRows: Integer;
    procedure SetCells(ColIX, RowIX: Integer; AValue: TmySelectableItem);
    procedure SetCols(AValue: Integer);
    procedure SetRows(AValue: Integer);
  public
    constructor Create;
    function AddCol(aCol:TmySelectableItems): Integer;
    property GridCells[ColIX,RowIX: Integer]: TmySelectableItem read GetCells write SetCells;
    property GridCols: Integer read GetCols write SetCols;
    property GridRows: Integer read GetRows write SetRows;
  end;

  TmySelectableItemsUsingObject = class
    GridCells: TmySelectableMatrixOfCols_And_Rows;
  end;
  
  
  procedure TmySelectableMatrixOfCols_And_Rows.SetCells(ColIX, RowIX: Integer;
    AValue: TMySelectableItem);

  begin
    if (ColIX<=GetCols-1) and (RowIX<=GetRows) then
    TMySelectableItem(TMySelectBox(GridCols.Items[ColIX]).strings.Items[RowIX]) := AValue; //Hier meckert der Compiler !!!!!!!!!!!!!!!
                                      //Items[] kommt von TList, dem Vorgängerobjekt
  end;


constructor TmySelectableItemsUsingObject.Create
begin
  for c:=0 to Columns-1 do
  begin
    TuiItem := TtuiSelectableItem.Create;
    GridCells.AddCol(TmySelectBox.Create(
         theParentBox,
         theX+c*ColWidth+1,
         theY,
         ColWidth,
         RowHeight
         ));
    for r:=0 to Rows-1 do
    begin
      MyItem.theString:='1234';
      TMySelectBox(GridCols.Items[c])).addItem(MyItem); //Hier meckert der FPC Compiler!!!!!!!!!!!!!!!!!!!!
    end;
  end;
end;

Hier meckert der FPC Compiler an den kommentierten Stellen, der Delphi Compiler wurde das vermutlich auch.

Wie mache ich die Datenabfrage bzw. Zuweisung hier richtig? (Freepascal) Oder ist die Syntax hierfür in Freepascal und Delphi wirklich gleich?

Ich sehe eine nicht geöffnete Klammer.
TMySelectBox(GridCols.Items[c])).addItem(MyItem);

FPC kennt doch auch irgendwie Generics?

TList<TmySelectableItem> und schon hat man eine Liste, mit automatischem Cast ... muß man selbst nichts machen und macht dadurch auch keine Fehler.



Und dann SoftCasts, anstatt HardCasts, zu mindestens so lange du nicht weißt was wo wie richtig ist (kann man ja später aus Performancegründen wieder umdrehen).
Der Compiler meckert nur, wo es komplett inkompatibel wird, wenn man z.B. direkt TmySelectableItems zu TmySelectBox casten will.
Schon sagt dir zur Laufzeit das Programm auch, wenn wo Intern was falsch läuft. z.B. TmySelectableItems zu TmySelectBox casten, aber mit TObjekt oder Pointer als Zwischentypen.

markieren

Delphi-Quellcode:

// statt
TmySelectableItem(xxx.Items[i])

(xxx.Items[i] as TmySelectableItem)
// bzw.
(TObject(xxx.Items[i]) as TmySelectableItem) // wenn es ein Pointer ist und AS nicht direkt geht

Generics sind in FPC und Delphi unterschiedlich da FPC schon viel länger Generics implementiert als Delphi.
Man kann aber FPC im Mode Delphi compilieren und dann kann man das genau wie in Delphi umsetzen.

markieren

Code:

{$mode Delphi}

TMyGenericList = class(TList<TmySelectableItem>)
end;

{$mode ObjFPC}

TSMyGenericList = specialize TList<TmySelectableItem>;

TMyGenericList = class(TSMyGenericList)
end;

Ich persönlich bevorzuge da die Delphi Variante, da ich viel weniger schreiben muss.

FPC wird doch bestimmt auch CodeTemplates kennen?
Da könntest dir ja ein Template für erstellen.

So geht es nicht?
TMyGenericList = class(specialize TList<TmySelectableItem>)

Wenn doch, dann
TMyGenericList = class({$IFDEF FPC}specialize{$ENDIF} TList<TmySelectableItem>)
OK, wegen dem $MODE dann wohl irgendwie so
TMyGenericList = class({$IF Defined(FPC) and not Defined(DelphiMode)}specialize{$IFEND} TList<TmySelectableItem>)

Nein leider nicht ich wollte dies auch gern so in meiner anderen Klasse umsetzen,
aber das key Wort specialize darf leider nicht in einer Klassen Ableitung eingesetzt werden.

Da bleibt dann nur die Variante den Mode der ganzen unit zu switchen oder halt die andere schreibweise zu benutzen.

Danke Euch allen für Eure Antworten und Anregungen, jetzt guck ich mir das alles noch mal an.

Zitat von himitsu:

FPC wird doch bestimmt auch CodeTemplates kennen?
Da könntest dir ja ein Template für erstellen.

FPC ist nur der Compiler. Das Äquivalent zu CodeTemplates wird von der IDE bereitgestellt und zumindest Lazarus unterstützt diese.

Zitat von himitsu:

Wenn doch, dann
TMyGenericList = class({$IFDEF FPC}specialize{$ENDIF} TList<TmySelectableItem>)
OK, wegen dem $MODE dann wohl irgendwie so
TMyGenericList = class({$IF Defined(FPC) and not Defined(DelphiMode)}specialize{$IFEND} TList<TmySelectableItem>)

Korrekterweise wäre es {$IF Defined(FPC) and not Defined(FPC_DELPHI)}specialize{$IFEND}

Zitat von itblumi:

Nein leider nicht ich wollte dies auch gern so in meiner anderen Klasse umsetzen,
aber das key Wort specialize darf leider nicht in einer Klassen Ableitung eingesetzt werden.

Seit FPC 3.2.0 geht das.

Ja sorry, Lazarus natülich.

Wir sind hier einfach zu verwöhnt, da hier im Delphi die Sprache, der Compiler und die IDE gleich heißen.

OK, die Sprache hieß früher mal Pascal, vor Delphi (als die IDE noch Turbo Pascal hieß, bzw. PolyPascal, davor BLS-Pascal und zu Begin nur Pascal) und inzwischen heißt sie seit wenigen Jahren nun offiziell "Delphi Language" (weil die Sprache hat sich weiterentwickelt und ist nun was Besseres Anderes), auch wenn scheinbar fast niemand diese Bezeichnung benutzt.
Und ja, die IDE heißt intern immernoch noch anders, nämlich so, wie Delphi ursprünglich mal heißen sollte, also TAppBuilder, aber durch einen glücklichen Zufall fiel kurz vor Veröffentlichung auf das Er bereits vergeben war.