Zugriff auf vererbte Eigenschaften

[glunzl]

Hallo!

Ich bastel weiter an meinem Panel, mit Labels (Array) drauf. Das Panel wird von der Form1 in einer Scrollbox erzeugt. Jetzt komme icuh nicht weiter, weil ich es nicht hinbekomme weder aus meiner Klassen-Unit, noch aus der Main-Unit auf die Panels, bzw. Labels zuzugreifen.

Delphi-Quellcode:

unit DatPanel;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls, StdCtrls;

const
  AnzLabelsProPanel = 8       ;   // Anzahl der Label (Zeilen) pro Panel
  LabelHeight = 13            ;   // Höhe der Label (Zeilen); an Textgröße anpassen
  RandObenuUnten = 4          ;   // Rand oben und unten (jeweils Wert - Rand komplett = 2*Wert)
  LabelAbstandlinks = 0       ;   // Abstand links vom Label zum Panel (O = kein li. Rand)
  FarbeLabelOdd = clSilver    ;   // Farbe der ungeraden Labels
  FarbeLabelEven = clMedGray  ;   // Farbe der geraden Labels

type TDatPanel = class(TPanel)
  private
    fLabel : Array [0..AnzLabelsProPanel - 1] of TLabel ;
    function GetLabelText: String;
    procedure SetLabelText(const Value: String);
  public
    constructor Create(AOwner: TComponent); override ;
  published
    property LabelText : String read GetLabelText write SetLabelText ;
  end ;

implementation

constructor TDatPanel.Create(AOwner: TComponent);
var
  i : integer ;
begin
  inherited ;
  for i := 0 to AnzLabelsProPanel -1 do begin
    fLabel[i] := TLabel.Create(self);
    with fLabel[i] do begin
      Parent:= self ;
      Top := i * LabelHeight + RandObenuUnten ; Left := LabelAbstandlinks ; Height := LabelHeight  ;
      Caption := 'TestLine: ' + IntToStr(i+1) ;
      Name := 'DatLabel' + IntToStr(i) ;
      Tag := i ;
      end ;
    end ;
end;

function TDatPanel.GetLabelText: String;
begin
  // Großes Fragezeichen wie ich auf das Array der Labels von dieser Unit aus zugreifen kann (Ausser im Constructor)
end;

procedure TDatPanel.SetLabelText(const Value: String);
begin
  // Großes Fragezeichen wie ich auf das Array der Labels von dieser Unit aus zugreifen kann (Ausser im Constructor)
end;
end.

Der Zugriff aus Form1:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
  aDP: Array [0..15] of TDatPanel ;
  i : integer ;
begin
  for i := 0 to 15 do begin
    aDP[i] := TDatPanel.Create(ScrollBox);
    aDP[i].Parent := Scrollbox ;
    aDP[i].Height := aDP[i].MinPanelHeight ;
    aDP[i].Top := i * aDP[i].Height ;
    aDP[i].Width := Scrollbox.ClientWidth ;
    aDP[i].LabelText  // Wie geschieht hier der Zugriff auf das Label-Array  des DatPanels?
    end ;
end;

Und dann noch gemeiner ... Kann man über Scrollbox. ... nach auf die Labels zugreifen?

Gruß
glunzl

[mkinzler]

Die Methode sollte auch public sein nicht private

[TBx]

Hallo!
Ich gehe davon aus, dass Du mit einer indizierten Property arbeiten möchtest.
Dann könntest Du die LabelCaptions mit folgender Syntax ansprechen:

Delphi-Quellcode:

aDP[i].LabelText[j]

Dazu deklarierst Du Deine Property LabelText im public-Abschnitt (nicht published, das funktioniert nicht) folgendermaßen:

Delphi-Quellcode:

property LabelText [index : integer] : String read GetLabelText write SetLabelText;

Deine Getter und Setter Routinen müssen dann so aussehen:

Delphi-Quellcode:

function TDatPanel.GetLabelText(index: integer): String;
begin
  if ((index >= low (flabel)) and (index <= high (flabel)))  then
  begin
    Result := flabel [index].Caption;
  end
  else
  begin
    // Fehlermeldung
  end;
end;

procedure TDatPanel.SetLabelText(index: integer; const Value: String);
begin
  if ((index >= low (flabel)) and (index <= high (flabel)))  then
  begin
    flabel [index].Caption := Value;
  end
  else
  begin
    // Fehlermeldung
  end;
end;

Zitat:

Und dann noch gemeiner ... Kann man über Scrollbox. ... nach auf die Labels zugreifen?

generell ja. In Deinem jetzigen Aufbau müßtest Du allerdings eine ganze Menge casten.
Ich gehe mal davon aus, dass Du damit liebäugelst, eine Komponente zu bauen, die aus einer Scrollbox besteht, die n Datpanels enthält. In dieser könntest Du dann entsprechend die Properties nach außen durchschleifen.
Du könntest dann in dieser abgeleiteten Scrollbox eine property LabelText einfügen, die über zwei Indexe verfügt, einen für das DatPanel und einen für das Label auf den Panel. Das sähe dann so aus:

Delphi-Quellcode:

TDatScrollBox = class (TScrollBox)
private
    function GetLabelsText(PanelNo, LabelNo: integer): string;
    procedure SetLabelsText(PanelNo, LabelNo: integer; const Value: string);
public
  LabelText [PanelNo, LabelNo : integer]:String read GetLabelText write SetLabelText
end;

Hope it helps

onlinekater

@mkienzler: ?????

@Threadersteller: Titel paßt nicht so ganz, Du möchtest nicht auf vererbte Eigenschaften sondern auf Eigenschaften von Unterkomponenten zugreifen.

[mkinzler]

Zitat:

Zitat von onlinekater

@mkienzler: ?????

Zitat:

Zitat von glunzl

Delphi-Quellcode:

private
    fLabel : Array [0..AnzLabelsProPanel - 1] of TLabel ;
    function GetLabelText: String;
    procedure SetLabelText(const Value: String);

[TBx]

@mkinzler: klar, ich bezog mich hier auch auf Deine unkorrekte Aussage. Die Getter- u. Setterroutinen sind von Hause aus immer private deklariert. Die sollen schließlich von außen nicht sichtbar sein, man soll über die Property arbeiten.

Gruß

onlinekater

[mkinzler]

Zitat:

Die Getter- u. Setterroutinen sind von Hause aus immer private deklariert. Die sollen schließlich von außen nicht sichtbar sein, man soll über die Property arbeiten.

Nein Getter/Setter sollten normalerweise public sein.

[Jürgen Thomas]

Zitat:

Zitat von mkinzler

Nein Getter/Setter sollten normalerweise public sein.

Auf Eigenschaften zugreifen (Objekt-Pascal Sprachreferenz, bei mir Delphi 5) sagt als Standard:

Delphi-Quellcode:

type
  THeading = 0..359;
  TCompass = class(TControl)
private
  FHeading: THeading;
  procedure SetHeading(Value: THeading);
published
  property Heading: THeading read FHeading write SetHeading;
  ...
end;

Gruß Jürgen

[TBx]

@mkienzler: Dann wäre ja die Codevervollständigung von Delphi Deiner Aussage nach für den Allerwertesten.
Beispiel:

Delphi-Quellcode:

type
  TMyClass = class
  public
    property Test : String;
  end;

nun die Klassenvervollständigung über strg+alt+c

heraus kommt folgendes:

Delphi-Quellcode:

type
  TMyClass = class
  private
    FTest : String;
    procedure SetTest(const Value: String);
  public
    property Test : String;
  end;

// ......

implemtentation

procedure TMyClass.SetTest(const Value: String);
begin
  FTest := Value;
end;

Gruß

onlinekater

PS: Mir fällt gerade auf, daß wir inzwischen OffTopic geworden sind. Ist daher mein letzter Post zu diesem Thema. :wall:

[glunzl]

Hello again!

4 Tage ohne eigenen DSL-Zugang ist ganz schön bescheiden ...

Zuerst wurde meine Umstellung auf ADSL2 durchgeführt, allerdings wohl ein Stecker nicht richtig gesteckt, so das mein Anschluß nicht funktionierte. Die Leitung war tot. Einen Tag später sollte das gefixt werden, da kamen dem Techniker aber die Bauarbeiten an meiner Hütte in die Quere, die Leitung wurde gekappt (von dem Gleichen, der 2 Tage zuvor die Stromleitung gekappt hatte). Als die Telefonleitung wieder ok war, dachte man, damit müsste auch mein speziefisches Anschlußproblem gelöst sein und beließ es dabei. Wieder angeurufen, den Sachverhalt erklärt, wiederum einen Tag später ein neuer Techniker, der meinen Anschluß dann zum laufen bekam ...

Nun zu den wichtigen Sachen :-)

Danke für die rege Beteiligung hier! Mir sind einige neue Erkenntnisse und Ideen gekommen.
Ich denke aber auch, das es sinnvoller ist die Getter und Setterroutinen als privat zu dekalrieren und die Property dann als öffentlich. So las ich es auchin einem Tut von M. Puff zum Thema Klassen.

Die Idee mit einer eigenen Komponente, bzw. der abgeleiteten Scrollbox geht sogar noch einen Schritt weiter, diesen Ansatz werde ich mal versuchen umzusetzen. Danke dafür!

Hier noch ein Auszug aus der OH, zum Thema published Eigenschaften:
published-Eigenschaften sind auf bestimmte Datentypen beschränkt. Ordinal-, String-, Klassen-, Schnittstellen- Variant- und Methodenzeigertypen können mit dieser Sichtbarkeit deklariert werden. Bei Mengentypen ist dies nur möglich, wenn die Ober- und Untergrenze des Basistyps einen Ordinalwert zwischen 0 und 31 hat. (Die Menge muss also in ein Byte, Wort oder Doppelwort passen.) Auch alle Real-Typen außer Real48 können als published deklariert werden. Für Eigenschaften von Array-Typen ist published dagegen nicht zulässig (im Gegensatz zu den weiter unten beschriebenen Array-Eigenschaften).

Gruß
glunzl