Lazarus Programm und ich hab als Anfänger gar kein Plan?

Wir haben in der Schule folgendes Layout bekommen (Bild). Wir hatten noch gar nichts mit programmieren zu tun und unser Wissen beträgt genau null. Jetzt sollen wir uns mal selber durchschlagen, aber bis jetzt hab ich nur den löschen button hinbekommen. Den beenden button auch, aber das reicht leider nicht. Wie man im Bild sehen kann sollen wir mit dem Layout ungefähr eine Art Suchmaschine programmieren. Das heißt oben im Edit Feld gibt ein Begriff ein und unten wird es mit dem ausgeben button auf das nächste Edit Feld übertragen. Das Memo Feld soll dabei auch einfach nur das gleiche wie die Edit Felder angeben. Das Radiozeug soll mit dem hinzufügen button den Begriff darein speichern und immer wieder rufen können. Hilfe pls

Answer 1

[regex9]

(...) und unser Wissen beträgt genau null.

Nun, ganz so schlimm scheint es ja glücklicherweise nicht zu sein.

Gehen wir einmal die Aufgaben durch:

Das heißt oben im Edit Feld gibt ein Begriff ein und unten wird es mit dem ausgeben button auf das nächste Edit Feld übertragen.

Nun, der Anfang sollte ja nicht so schwer sein. Erst einmal musst du die notwendigen Komponenten auf deinem Fenster platzieren. Ihnen allen gibst du über den Objekteditor (der sämtliche Eigenschaften auflistet (ansonsten siehe hier: http://wiki.lazarus.freepascal.org/File:Windows_8.png ) einen sinnvollen, passenden Namen. Zum Beispiel TextInput, TextOutput und für den Button.. CopyButton. Dann gibt es im Objektinspektor den Tab Events. Dort werden alle Events aufgeführt, auf die das gerade selektierte Element reagieren kann. Markiere den Button und füge dem OnClick-Event via Doppelklick in das Feld rechts daneben einen Event-Handler hinzu. Dieser wird im Quelltexteditor automatisch für dich angelegt.

procedure TForm1.CopyButtonClick(Sender: TObject);
begin

end;

Im Grunde genommen handelt es sich hier nun um eine Prozedur. In Prozeduren wird der Programmcode geschrieben, der irgendwann einmal ausgeführt werden soll. Bei Events wird diese Prozedur aufgerufen, sobald das Event ausgelöst wird.

Nach dem Schlüsselwort procedure siehst du den Namen der Prozedur und die folgenden Begriffe begin und end leiten einen Code-Block ein. Anweisungen dürfen meist nur innerhalb von Code-Blöcken stehen und damit diese von woanders aus aufgerufen werden können, werden sie benannt. Beim Aufruf der Prozedur springt das Programm also an die Stelle, wo es den benannten Block findet und führt diesen aus.

Hinter dem Namen (TForm1.CopyButtonClick - im Grunde zeigt der Name, in welcher Form / zu welchem Fensterobjekt die Methode heißt und dann folgt, abgetrennt durch einen Punkt der eindeutige Name) ist des Weiteren noch die Parameterliste zu sehen, eingeleitet und später abgeschlossen durch die runden Klammern. In dieser Parameterliste werden Parameter aufgezählt, die dem Code-Block von außen, also anderer Stelle (bei Aufruf) mitgegeben werden müssen. Bei Events wird stets das Senderobjekt mitgeliefert, welches das Event ausgelöst hat (dies wäre in unserem Fall also der Button). Über den Parameternamen könntest du dann also z.B. Informationen über den Sender beziehen. Das ist bspw. nützlich, wenn mehrere Buttons sich einen Klickhandler teilen, aber stets andere Verhaltensweisen auslösen sollen. Mittels des Parameters könnte daraufhin bestimmt werden, welcher Button geklickt wurde, um anschließend den richtigen Programmfluss zu nutzen. Nach dem Doppelpunkt steht der Typ des Parameters. Der Typ gibt Auskunft darüber, was für ein Wert da gerade übergeben wurde - ob er als Zeichenkette interpretiert werden soll, als Button, als Zahl, o.a.. Dies soweit als kleiner Exkurs. 

So, was wollen wir nun machen? Wir wollen, dass TextOutput den selben Textinhalt bekommt, wie TextInput. Also müssen wir den Inhalt des letzgenannten Feldes auslesen und dann in das Zielfeld einfügen.

Dies funktioniert so:

procedure TForm1.CopyButtonClick(Sender: TObject);
begin
   TextOutput.Text := TextInput.Text;
end;

Über die vergebenen Namen sind die Textfelder ansprechbar und über die Punktnotation können nun Eigenschaften von diesen Komponenten aufgerufen werden. Insgesamt siehst du dort eine Zuweisung. Auf der rechten Seite (R-Wert) wird der Text aus dem Eingabefeld geholt und der Eigenschaft auf der linken Seite (L-Wert) zugewiesen. Speicher dein Projekt einmal und führe es dann aus (mit F9 oder dem Play-Button oben im Menü).

Das Memo Feld soll dabei auch einfach nur das gleiche wie die Edit Felder angeben.

Dies solltest du nun allein hinbekommen, das Verfahren ist ja gleich, mit dem einzigen Unterschied, dass die Komponente nun TMemo und nicht TEdit heißt.

Das Radiozeug soll mit dem hinzufügen button den Begriff darein speichern und immer wieder rufen können.

Handelt es sich hierbei wieder um die Eingabe aus dem ersten Textfeld? Und wie viele Radiobuttons darf es insgesamt geben bzw. wird die Liste mit jedem Begriff unendlich erweitert?

Ich nehme für meine Erklärung einfach mal die Eingabe aus dem ersten Feld und überschreibe die Einträge der Radiobuttons, wenn sie die 3 übersteigen.

Ich füge hierfür zuerst einmal eine TRadioGroup ein und gebe ihr den Namen WordCache, denn sie speichert ja temporär Wörter. Hinzu kommt ein Button (AddButton), welcher wieder einen Klickhandler zugewiesen bekommt (übrigens ein Shortcut: Doppelklick auf den Button, und der Klickhandler wird ebenso angelegt).

Diesmal soll der Itemliste der Radiogruppe etwas zugefügt werden. Dies funktioniert über die Add-Methode. (Tipp: Mit Strg + Leertaste wird die Auto-Suggestion aufgerufen, die verfügbare Möglichkeiten anbietet. Dazu gehören Komponenten/Variablen und bei der Punktnotation Methoden und Eigenschaften).

Meine Prozedur sieht daraufhin so aus:

procedure TForm1.AddButtonClick(Sender: TObject);
begin
  WordCache.Items.Add(TextInput.Text);
end;

Die aufgerufene Methode fordert ein Argument, welches innerhalb der Argumentenliste (runde Klammern) angegeben wird. Das Argument muss vom Typ TString sein, was einer Zeichenkette entspricht. Der eingegebene Text im Eingabefeld ist glücklicherweise von selbem Typ, passt also.

Führe es einmal aus und du siehst, du kannst zig Texte einfügen. Aber auch Texte, die den gleichen Wert haben. Das wollen wir nicht, daher erweitern wir unseren Quellcode ein bisschen:

procedure TForm1.AddButtonClick(Sender: TObject);
begin
  if -1 = WordCache.Items.IndexOf(TextInput.Text) then
   begin
       WordCache.Items.Add(TextInput.Text);
   end;
end;

Unsere bisherige Anweisung kommt in einen neuen Block - hierzu sei gesagt, du kannst Blöcke bis zum Erbrechen ineinander verschachteln. Ein Unterschied zu der Prozedur ist allerdings, dass die Blöcke in ihr immer anonym sind, also keinen Namen besitzen (an dieser Stelle muss ich sagen, dass dies möglicherweise nicht ganz korrekt ist, denn ich weiß gerade nicht, ob es in Lazarus lokale Klassen o.ä, gibt - für dich ist es jedoch überhaupt nicht relevant). Vielleicht kann unser innerer Block also keinen Namen bekommen, dafür kann er sich etwas anderes Cooles leisten: Einen Guard, bekannt als if-then (auf die Erweiterung mit else gehe ich hier jetzt nicht ein). Dieser Guard prüft, ob ein ihm übergebene Aussage wahr oder falsch ist. Ist sie wahr, darf der Programmfluss passieren und den Folgeblock betreten, ansonsten nicht.

Die Aussage hier ist ein Vergleich. Auf der rechten Seite wird die Methode IndexOf aufgerufen. Sie schaut, an welcher Stelle in ihrer Liste sich der Wert befindet, der möglicherweise eingetragen werden soll. Wenn sie das Ergebnis -1 zurückgibt (Methoden können auch Ergebnisse/Werte, die sie berechnen sollen, zurückgeben), heißt das, dass sie den Text nicht in ihrer Liste gefunden hat.

Nun gibt es nur noch eine Sache in dem Programm zu bemängeln: Es können nach wie vor unendlich viele Einträge in die Radiogruppe eingefügt werden. Wir fügen deshalb einen weiteren Guard hinzu:

procedure TForm1.AddButtonClick(Sender: TObject);
begin
  if -1 = WordCache.Items.IndexOf(TextInput.Text) then
   begin
       if 3 = WordCache.Items.Count then
        begin
            WordCache.Items.Delete(0);
        end;

        WordCache.Items.Add(TextInput.Text);
   end;
end;

Der hinzugefügte Vergleich ist ziemlich einfach. Er schaut, ob die Anzahl an Radiobuttons derzeit 3 beträgt. Wenn ja, wird der erste Button in der Liste gelöscht (in der Programmierung wird stets bei Index 0 angefangen zu zählen).

Zuletzt widmen wir uns der letzten Anforderung, dem Wiederaufruf eines gespeicherten Wertes. Fügen wir der Radiogruppe also einen neuen Klickhandler zu. 

procedure TForm1.WordCacheClick(Sender: TObject);
begin
  TextOutput.Text := WordCache.Items[WordCache.ItemIndex];
end;

Die Zuweisung selbst ist dir bereits bekannt. Neu für dich ist wieder einmal das, was beim R-Wert passiert. Fangen wir hiermit an:

WordCache.Items[irgendEineZahl]

Die Eigenschaft Items selbst ist vom Typ TStrings. Dieser Typ stellt eine Kollektion von mehrere Zeichenketten dar. Jede gespeicherte Zeichenkette kann über einen Index (wie immer beginnend bei 0) aufgerufen werden. Die Eigenschaft ItemIndex beinhaltet den aktuell selektierten Index, wir nutzen ihn, um an das dazugehörige Item bzw. seinem Wert zu kommen.

Damit ist die Aufgabe auch schon erledigt. Ich habe die Erklärungen grob gehalten, um es kurz und einfach zu gestalten. Solltest du dennoch Fragen haben, schreibe diese gerne in den Kommentarbereich.

Comments

[bobforlive]

Sehr vielen Dank für diese ausführliche Antwort. Sie hat mir sehr geholfen :)