Create überschreiben (newbefrage)

[stephan007]

hallo!

ich weiß, eine newbe frage :-D
ich versuche gerade folgendes zu realisieren:
ein formular soll abhängig von dem in mode übergebenen style / erscheinungsbild angezeigt werden.

soll also folgendes machen:

Delphi-Quellcode:

 mywindow := window.create(self, Mode);

und wenn nichts angegeben wird für mode, dann soll es einfach den standard nehmen also

Delphi-Quellcode:

 mywindow := window.create(self);

bewirkt das gleiche wie

Delphi-Quellcode:

 mywindow := window.create(self, default);

wobei Mode z.b. von einer anderen anwendung oder in meinem fall halt mal per editbox vorgegeben wird.

muss ich da nun die create überschreiben oder die formcreate?
und wie schaut das dann im code genau aus? ich muss ja da auch die funktionen der überschriebenen erben.

stephan.

[mkinzler]

den Konstruktor (.Create).
.FormCreate ist ja nur eine Eventmethode

[oki]

und den Konstructor überladen, damit beide Varianten möglich sind.

Gruß oki

[stephan007]

und wie schaut das dann bitte genau aus?

ich habe nun eine überladene Create mit

Delphi-Quellcode:

procedure TForm.Create (AOwner: TComponent; Mode : Modetyp); override;

und wie muss ich die dann gestalten? ich hätte folgendes gemacht:

Delphi-Quellcode:

procedure TForm.Create (AOwner: TComponent; Mode : Modetyp); override;
begin
  inherited;
  Form.Create(self);
  if Mode = ....
  // case for mode here
end;

sehe ich das richtig oder hab ich da noch irgendwo einen fehler drinnen?

wie gesagt, ich will ein formular erstellen, das aus zwei bereichen besteht. jede beliebige kombination der bereiche soll wählbar sein. sagen wir der obere ist a und der untere b. nun solls möglich sein, das formular nur mit entweder a oder b anzuzeigen oder aber auch mit beiden. abhängig vom parameter.

wenn mir newbe da jemand bitte weiterhelfen könnte vielelicht auch mit code, damit ichs gleich an dem lerne, wäre mir sehr geholfen. danke!

[oki]

Hi, so:

Delphi-Quellcode:

Constructor Create(AOwner: TComponent; Mode : Modetyp); overload;

procedure TForm.Create (AOwner: TComponent; Mode : Modetyp); 
begin
  inherited create(AOwner);
  Form.Create(self);
  if Mode = ....
  // case for mode here
end;

Der Constructor wird somit überladen. Du kannst dann beide Constructoren aufrufen, den alten mit nur AOwner und den neuen. Es gibt die Funktion somit zweimal mit unterschiedlichen Parametern. die OH gibt da auch gut auskunft.

Gruß oki

[DeddyH]

Ist Form ein Childobjekt Deiner Komponente? Oder wofür steht das Form.Create?

[stephan007]

schaut so aus:

Delphi-Quellcode:

type TMyForm = class(TDForm)
     ....
     procedure FormCreate ....
     procedure FormDestroy ....
     private
     public
     constructor Create (AOwner: TComponent; Mode: Windowtyp); overload;
     .....
     end;

// und dann kommen die einzelnen Realisierungen im ImplementationTeil

das sollte eigentlich Create(AOwner) heißen. und ruft den alten Constructor auf.
oder meinst du im code von oki?

[oki]

Hi,

schau mal was dein Compiler sagt, ich glaube hinter das overload muß noch ein override.

Delphi-Quellcode:

Constructor Create(AOwner: TComponent; Mode : Modetyp); overload; override;

Komm da immer wieder durcheinander und vertrau auf die Compilermeldungen für meine Korrekturen.

Gruß oki

[DeddyH]

Ich meinte die Zeile Form.Create im Konstruktor.

[stephan007]

habs jetzt wie oki gesagt hat (ohne das form.create) gemacht und da kommt folgendes:

da bekomm ich nun mehrere fehlermeldungen:
zweimal "Deklaration 'Create' unterscheidet sich von vorheriger Deklaration" (bei der deklaration im type und im implementation)
dann "Diese Form des Methodenaufrufs ist nur in Methoden von abgeleiteten Typen erlaubt" (beim inherited) und beim type mit dem constructor nochmals "ungenügend Forward- oder External-Deklaration: 'MyForm.Create'"

also irgendwie will der compiler den code nicht! :roll:

[oki]

Sorry, Sorry!

ich hab jetzt wie empfohlen auch mal die Hilfe bemüht.

Da dein Constructor eine virtuelle Methode ist, mußt du folgendes tun:

Delphi-Quellcode:

Constructor Create(AOwner: TComponent; Mode : Modetyp); reintroduce; overload;

Nur wenn Du statische Funktionen und Methoden hasst reicht overload. Hier noch mal die Beispiele aus der OH:

Delphi-Quellcode:

type

     T1 = class(TObject)
       procedure Test(I: Integer); overload; virtual;
     end;
     T2 = class(T1)
       procedure Test(S: string); reintroduce; overload;
     end;
      ...
     SomeObject := T2.Create;
     SomeObject.Test('Hello!');  // Ruft T2.Test auf.
     SomeObject.Test(7);         // Ruft T1.Test auf.

und

Delphi-Quellcode:

function Func(X: Real; Y: Integer): Real; overload;

    ...
function Func(X: Integer; Y: Real): Real; overload;

Schau aber unbedingt noch mal in die OH. Da ist auch erläutert was man darf und was nicht!

Gruß oki

edit: Formatierung

[stephan007]

ok, werde mal auch die OH konsultieren.
aber noch zur weieren erklärung: ich will folgendes tun:

ich designe ein fortschritts / progress fenster. oben werden in einer liste die tasks mit zeit angezeigt, unten die balken für den aktuellen task und der total balken.

nun solls aber möglich sein, nicht nur beide panel (habs auf die weise gelöst) gemeinsam anzuzeigen, sondern eventuell auch nur eines der beiden. also z.b. nur die liste oder nur die balken.

und um das zu realisieren, hätte ich die create überschrieben und ihr einen weiteren parameter mitgegeben, in welchem ich mitliefere, wie das fenster auszusehen hat. also entweder eines der beiden oder beide (mach ich derzeit mit einem enum type).

das ein und ausblenden der fenster sollte ja nicht das problem sein, und die abfrage des parameters im create mit case und dann die gewünschten aktionen, aber ich brauch dazu die überladene create, damit ich den windowmodus mitgeben kann.

nur mal so zur ausführlichen erklärung, was ich damit bezwecke.

[oki]

Hi,

also, das mit dem überladenen Constructor müßte nun eigentlich klappen. Wenn nicht, muß ich es wohl mal selbst zum Test proggen.

Eine zweite Variante ist, deinem Formular eine neue Eigenschaft zu verpassen. diese nach dem Create setzen und dann das Formular anzeigen. Als bsp. mal der folgende code so eben weg geschrieben:

Delphi-Quellcode:

type
  TModeType =  (mt_none,
                mt_guckst_du_da,
                mt_guckst_du_hier
                );

  TMyGuckstDuForm = class(TForm)
  private
    FModeType: TModeType;
    procedure SetModeType(const Value: TModeType);
    { private-Deklarationen }
  protected
    { protected-Deklarationen }
  public
    { public-Deklarationen }
    property ModeType : TModeType read FModeType write SetModeType;
  published
    { published-Deklarationen }
  end;
implementation

{ TMyGuckstDuForm }

{-----------------------------------------------------------------------------
  Procedure: SetModeType
  Author:    oki
  Date:      19-Jun-2007
  Arguments: const Value: TModeType
  Result:    None
  Des.:      hiert wird die Ansicht des fensters in Abhängigkeit von ModeType
             geändert.
-----------------------------------------------------------------------------}

procedure TMyGuckstDuForm.SetModeType(const Value: TModeType);
begin
  FModeType := Value;
  case FModeType of
    mt_none: ............;
    mt_guckst_du_da: ............;
    mt_guckst_du_hier: .............;
  end;
end;

Jetzt kannst du zur Laufzeit dein Fenster normal über den mitgelieferten Constructor creieren, setzt dein Property und zeigst das Fenster an:

Delphi-Quellcode:

var MyForm : TMyGuckstDuForm;
begin
  MyForm := TMyGuckstDuForm.create(self);
  MyForm.ModeType := mt_guckst_du_da;
  MyForm.Show;
end;

Gruß oki

[stephan007]

danke für die hilfe.
nur eine frage: wozu brauch ich bei dieser variante dann eigentlich noch die überladene create??
die kann ich mir dann ja sparen, oder? achja, zum auslesen des modes brauch ichs ja, d.h. von dort einfach das setmode aufrurufen könnte ich machen :)

[Jelly]

Zitat:

Zitat von oki

Jetzt kannst du zur Laufzeit dein Fenster normal über den mitgelieferten Constructor creieren, setzt dein Property und zeigst das Fenster an:

Delphi-Quellcode:

var MyForm : TMyGuckstDuForm;
begin
  MyForm := TMyGuckstDuForm.create(self);
  MyForm.ModeType := mt_guckst_du_da;
  MyForm.Show;
end;

Genau darin seh ich eventuell eine Gefahr. Denn wenn du nicht unbedingt weisst, welche Eigenschaften du setzen musst, bevor du das Form zeigst, wird das wohl beim Anzeigen zu Exceptions führen (können), wenn ModeType elementar wichtig ist für die Darstellung.

Beim Constructor wird der Anwender gezwungen den ModeType mit anzugeben, zumindest dann, wenn der eigene constructor mit reintroduce eingeführt wird.

Delphi-Quellcode:

public
  constructor Create (AOwner : TComponent ; AModeType : TModeType) ; reintroduce ;

[oki]

Hi Jelly,

grundsätzlich geb ich dir recht. Nur ist hier nicht der Nutzer am Werk, sondern der Programmierer. Solche "Fehler" sollten dann aber auch abgefangen werden. Dafür schreibe ich bei meinen Typdeklarationen auch immer ein "none" mit rein. Zudem sollte der neue Constructor den alten überladen. Somit sind beide immer noch verwendbar. Der Aufruf ohne ModeType ist somit auch wieder möglich und der von dir beschriebene Fehler tritt auf.

Grundsätzlich glaube ich, dass der Programmierer in Abhängigkeit von den Anwendungsmöglichkeiten seines Fensters diese Entscheidung treffen sollte. Ein besser oder schlechter kann man hier wohl so nicht definieren. Vielleicht ist ein "Default" in der Vorbelegung ein guter Kompromiß.

Gruß oki

[edit]
Tschuldigung, hab Stephans Beitrag glatt übersehen.
Wenn du willst, kannst du ihn dir spaaren. Wenn nicht, spaart dir der neue Constructor eine Zeile Code; die Eigenschaft gibt dir die Möglichkeit den Style des Fensters während es angezeigt wird umzuschalten.

gruß

[stephan007]

hab mir da nun ein neues problem aufgegabelt:
wie ich schon erwähnt habe, besteht mein programm im wesentlichen aus 3 panels, ein panel enthält die listview, in welches ich einträge vornehmen kann, dann habe ich ein panel, dass den prozessfortschrittsbalken enthält und dann hab ich ein drittes panel, das den gesamt-fortschrittsbalken enthält.

nun will ich wie schon früher geschrieben über den mode angeben, wie mein angezeigtes fenster aussehen soll.
es gibt also die möglichkeiten
*) nur listview panel
*) nur prozessfortschrittsbalken
*) nur totalfortschrittsbalken
*) listivew und prozessbalken
*) listview und gesamtbalken
*) prozessbalken und gesamtbalken
*) alle drei

momentan hätte ich angedacht, mir für jede der 7 möglichkeiten / kombinationen ein element in der enumeration (modetype) zu machen, das gefällt mir aber nicht wirklich, weil ich dann auch 7 case abfragen habe. gibts da nicht eine einfachere lösung, als 7 enumeration typen und damit auch case abfragen?

bin für jede vereinfachung zu haben. und natürlich auch für jeden vorschlag.

wie würdet ihr das oben machen, damit alle 7 varianten für die fensterdarstellung realisierbar sind.

daran, dass das der überschriebenen create mitgeteilt wird, hat sich aber nichts geändert.

[DeddyH]

Wie wäre es mit einer Menge?

Delphi-Quellcode:

type 
  TMyModes = (mmListView,mmProgressBar,mmTotalProgress);
  TMyMode = set of TMyModes;
end;

[Jelly]

Für neue Fragen bitte ein neuer Thread. Auch wenn es weiter um den Mode geht hat das nichts mehr mit der ursprünglichen Frage zu tun. Deshalb mach ich hier mal zu

* * * LOCKED * * *