Programmierkurs: Delphi: Erstellung einer grafischen Oberfläche Fortgeschrittene Themen

Aus Wikibooks

Wechseln zu: Navigation, Suche

Inhaltsverzeichnis

[Bearbeiten] Grafiken

Für Grafiken gibt es die Komponente TImage. Man findet sie in dem Register „Zusätzlich“. Doppelklickt man auf es bzw. wählt man die Eigenschaft „Picture“ und klickt auf die drei Punkte daneben, öffnet sich der Bild-Editor. In ihm wird per „Laden ...“ die Grafik in einem Dialog geladen, die erscheinen soll.

An Eigenschaften bietet das Image noch Stretch. Bei Stretch = true bedeutet dies, dass das Bild auf die Größe der TImage-Komponente gezerrt werden soll, ansonsten behält es seine Originalgröße, unabhängig von der Größe des Images.

Wenn Proportional = true gestellt ist (neuere Delphi-Versionen), heißt das, dass das Image so gezerrt wird, dass das Verhältnis von Höhe und Breite trotzdem noch denen des Originals entspricht.

Bei AutoSize = true erhält das Image automatisch die Größe des Originalbildes. Somit werden Stretch und Proportional ignoriert und die Breite und Höhe verändert.

Die Eigenschaften Left und Top geben (auch bei anderen Komponenten) die linke obere Position an. Für Spiele kann man diese verändern. Bei Spielen sollte man allerdings die Eigenschaft DoubleBuffered des Formulars auf true stellen (geht nur im Code-Editor im OnCreate-Ereignis):

procedure TForm1.FormCreate(Sender: TObject);
begin
  Form1.DoubleBuffered := true;
end;

Es wird jedoch im allgemeinen davon abgeraten eine TImagekomponente als Zeichenfläche (für Spiele oder ähnliches) zu missbrauchen. Für dynamische Grafiken (also bei Grafiken die sich öfters ändern, wie bei Spielen) sollte man die TPaintbox-Komponente verwenden. Diese eignet sich auch nur bedingt für Spiele, alles was über ein einfache Dinge wie Tetris hinausreicht, sollte man eher OpenGL verwenden. Dafür gibt es auch einige 2D-Engines die von der Delphi-Community entwickelt wurden. Im deutschsprachigem Raum werden vor allem Fear2D und Andorra 2D. Für 3D-Spieleprogammierung ist die DGL-Community besonders zu empfehlen, da diese sehr gute Tutorials zu 3D-Programmierung verfasst hat.

[Bearbeiten] Menüs

[Bearbeiten] Hauptmenüs

Professionelle Anwendungen haben meist ein Hauptmenü. Dazu wird die Komponente TMainMenu benötigt. Man findet sie in der Komponentenpalette unter Standard. Setzt man sie auf das Formular, so sieht man rein gar nichts. Außer eine nicht-visuelle Komponente (eine Komponente, die zwar im Erstellungsmodus gekennzeichnet wird, zur Laufzeit jedoch nicht sichtbar ist). Nun klickt man doppelt auf das TMainMenu. Der Menü-Editor öffnet sich. Dort gibt man einem Platzhalter einen Caption. Über Enter bestätigt man die Eingabe. Ein neuer Platzhalter wird erstellt. In erster Ebene sieht man nur Menüpunkte wie „Datei“, „Bearbeiten“, ... Diese können Untermenüs enthalten wie z.B. Datei / Neu, Datei / Öffnen. Selektiert man einen Menüpunkt, sieht man darunter einen Platzhalter. Ihm kann genauso ein Caption zugewiesen werden, z.B. "Neues Dokument". Per Enter wird bestätigt und ein neues Item wird erstellt, z.B. „Öffnen“. Das geht endlos weiter. Wenn der Caption „-“ ist, wird er als Trennlinie interpretiert. Einem Buchstaben kann ein „&“ vorangestellt werden, um das Item per Alternativtaste (Alt) aufzurufen. Weiterhin hat jedes Item die Eigenschaft Shortcut. Dort kann ein Tastenkürzel wie z.B. „Strg+S“, „Strg+Alt+V“, „F1“ oder „Strg+Leer“ eingestellt werden. Per Klick wird genauso wie über Betätigung des Shortcuts das OnClick-Ereignis ausgelöst, das wie oben beschrieben definiert werden kann.

Weiterhin kann jedes Item Untermenüs erhalten. Diese können per Kontextmenü / Untermenü erstellen erstellt werden und wieder Untermenüs erhalten.

[Bearbeiten] Kontextmenüs

Für ein Kontextmenü wird die Komponente TPopupMenu verwendet. Sie befindet sich unter Standard neben TMainMenu. Die Vorgehensweise ist dieselbe wie beim MainMenu. Der Komponente, die per Rechtsklick das Kontextmenü aufruft (es können auch mehrere sein), wird bei der Eigenschaft „PopupMenu“ (wenn vorhanden, in neueren Delphi-Versionen rot gekennzeichnet) die PopupMenu-Komponente zugewiesen (in der Liste ausgewählt).

[Bearbeiten] Ribbon Bar

In den neueren Delphi-Versionen (ab Delphi 2009) gibt es weiters die Ribbon Bar-Komponente, um den Programmen ein ähnliches Aussehen wie den neueren Microsoft Office-Anwendungen zu verpassen. Will man diese Komponenten jedoch benutzen muss man bei Microsoft eine kostenlose Lizenz beantragen und bestimmte Design-Richtlinien beachten. Gedacht ist diese Komponente als einfache und schnelle Alternative zu den Menüs.

[Bearbeiten] Toolbars

Toolbars bzw. Werkzeugleisten sind ebenfalls in professionellen Anwendungen oft anzutreffen. Man verwendet dazu die Windows-Komponente TToolbar im Register „Win32“. Weiterhin wird eine ImageList benötigt (ebenfalls im Register Win32). Auf diese wird nun doppelt geklickt. Im ImageList-Editor werden per Hinzufügen die benötigten Glyphs (Bitmaps in den Formaten 16x16, 24x24, 32x32, ...) zugewiesen. Diese können per Drag&Drop verschoben werden.

Nun wird der Toolbar-Komponente unter der Eigenschaft „Images“ (rot hervorgehoben) die ImageList zugewiesen. Per Rechtsklick auf die Toolbar kann im Kontextmenü „Neuer Schalter“ oder „Neuer Trenner“ gewählt werden. Bei Schaltern (TToolButton) gibt es die Eigenschaft ImageIndex, die den Index des Glyphs innerhalb der ImageList bestimmt. Erwartet wird eine Ganzzahl. -1 bedeutet: Kein Glyph. Die Nummerierung beginnt bei 0.

Soll der Schalter ein Checker sein, also angeben, ob ein Zustand 1 (true) oder 0 (false) hat, z.B. ob eine andere Toolbar sichtbar ist, wird ihr bei der Eigenschaft „Style“ der Wert „tbsCheck“ zugewiesen. Bei der Eigenschaft Down findet man den Wert False, wenn er nicht gedrückt ist, und True, wenn nicht. Wichtig dazu ist noch der Name des Buttons, den man unter der Eigenschaft „Name“ findet bzw. verändern kann.

Soll der Schalter ein Menü sein, also eine Liste enthalten, die bei Klick „aufpoppt“, stellt man den Wert der Eigenschaft „Style“ auf tbsDropDown. Der Eigenschaft „DropDownMenu“ wird ein PopupMenu zugewiesen, das sich bei einem Klick mit der linken Maustaste auf den Pfeil neben dem Button öffnet.

[Bearbeiten] Statuszeilen

Eine Statuszeile enthält wertvolle Informationen für den Benutzer. Sie befindet sich (meist) im unteren Teil des Formulars. Im einfachsten Fall zeigt sich eine Beschreibung zu einer Schaltfläche an. Diese Beschreibung wird angezeigt, sobald der Benutzer mit der Maus über die Komponente fährt. Ebenfalls wird ein gelber Hinweis angezeigt.

Um den gelben Hinweis (QuickInfo oder Hint genannt) zu definieren, muss die Eigenschaft „ShowHint“ der jeweiligen Komponente auf True gestellt werden. Die Eigenschaft „Hint“ enthält den Text, der angezeigt wird.

Um eine Statuszeile zu erstellen, zieht man eine TStatusbar (Register Win32) auf das Formular. Die Eigenschaft „AutoHint“ wird ebenso wie die Eigenschaft „SimplePanel“ auf True gestellt. Damit erscheinen nun in der Statuszeile die Hints, die bei der Eigenschaft „Hint“ der Komponente unter der Verwendung von AutoHint = true definiert wurde.

[Bearbeiten] Vorlagen

Für grafische Benutzeroberflächen (GUIs) gibt es drei wesentliche Vorlagen:

  • VCL-Formularanwendung: Leeres Formular, wird (bei älteren Delphi-Versionen) standardmäßig erstellt
  • MDI-Anwendung: Multiple Document Interface. Eine Basis, die es möglich macht, mehrere Dokumente zur gleichen Zeit zu verwalten. Beispiel: Photoshop, Phase5
  • SDI-Anwendung: Single Document Interface. Eine Basis, die grundsätzlich nur ein Dokument offen unterstützt. Dennoch ist es auch mit SDI möglich, mehrere Dokumente zu verwalten, wenn man die Komponenten dynamisch zur Laufzeit erzeugt.

Alle Vorlagen lassen sich über Datei / Neu / Weitere ... verwenden.

[Bearbeiten] MDI-Anwendungen

Eine MDI-Anwendung besteht aus einem Hauptformular (Parent) und mehreren MDI-Kindfenstern (MDI-Children). Im Parent sind Werkzeugleisten (TToolbar oder Zusätze wie Toolbar2000 von Jordan Russell oder TAdvToolbar von TMS Software) und ein Menü (TMainMenu oder gerade genannte Zusätze) untergebracht.

Alle Child-Fenster werden dynamisch erzeugt. In ihnen befindet sich nur der Editor. Die Fenster erhalten im Menü ihre Schaltflächen für Verkleinern, Maximieren und Schließen. Im Maximierten Zustand bekommt das Hauptfenster ein Caption der Form Titel - [Dateiname] in der Annahme, dass die Children wie standardmäßig den Dateinamen der geöffneten Datei oder „Unbenannt n“ als Caption erhalten.

Zu beachten ist, das man beim Schließen des Childfensters das Formular mittels Action := caFree; aus dem Speicher frei gibt.

Tipp: Zum Verwalten der Childfenster bietet sich das dynamisches Array an, welches das Parentfenster automatisch erzeugt. Man kann dann mittels MDIChildren[i] (wobei i den Index des MDI-Childfensters angibt) auf die einzelnen Fenster zugreifen.

[Bearbeiten] SDI-Anwendungen

SDI-Anwendungen unterscheiden sich nicht von einer VCL-Formularanwendung, lediglich die automatisch von der IDE erzeugten Komponenten sind unterschiedlich.

[Bearbeiten] Dialoge

Dialoge sind ebenfalls wichtig. Z.B. der SaveDialog, der OpenDialog, der PrintDialog, der PrinterSetupDialog, der FontDialog oder der ColorDialog. Sie befinden sich im Register Dialoge. Alle diese Dialoge lassen sich mit der Prozedur Execute aufrufen:

OpenDialog1.Execute;

Bei Execute handelt es sich um eine Funktion handelt, die einen Wahrheitswert, also True oder False, zurückgibt. Diesen sollte man auswerten, da True bedeutet, dass der Benutzer auf OK geklickt hat, während er bei False die Dialog mit Abbrechen verlassen hat.

Wie nun die Daten in den einzelnen Dialogen ausgewertet werden, würde hier zu weit führen. Bitte ziehen Sie hierfür Ihre Delphi-Hilfe zurate.

Weiters gibt es noch Dialoge mit denen man Benutzerabfragen gestalten kann. Diese sind in der selben Unit wie die Öffungs- und Speicherndialoge enthalten.

Mit dem Befehl MessageDlg erzeugt man Dialoge, die zum Beispiel abfragen können ob man das Programm wirklich beenden will. Der Befehl MessageDlg braucht in Klammern folgende Parameter mit: der Text der in der Box angezeigt werden soll; die Art des Dialoges (mtNone, mtInformation, mtConfirmation, mtCustom, mt Error); die Buttons die zur Verfügung stehen sollen (da kann man entweder eine vorgefertigte Mischung nehmen, oder mittels Array selbst die Buttons bestimmen); den Hilfeindex. MessageDlg gibt auch einen Wert zurück mit dem man prüfen kann welchen Button der Benutzer gedrückt hat. Diese können mrYes, mrNo und so weiter sein, für genaueres bitte die Delphi-Hilfe konsultieren.

ein Beispielaufruf könnte jetzt dann so aussehen:

procedure TForm1.Button1Click(Sender: TObject);
begin
  if MessageDlg('Wollen sie beenden?', mtConfirmation, [mbYes, mbNo], 0)=mrYes then
     Close;
end;

Außerdem gibt es dann noch die sogenannte InputBox. Mit Hilfe dieser kann man Eingaben vom Benutzer einfordern, auch Zahlen und Gleitkommawerte. Für nähere Informationen steht ihnen die Delphi-Hilfe zur Verfügung.

[Bearbeiten] Formatierter Text

Wikipedia
Wikipedia hat einen Artikel zum Thema:

Als erste GUI-Anwendung eignet sich ein Texteditor für das Rich Text Format (RTF). Mit ihm ist es möglich, Formatierungen bis hin zu Bildern darzustellen. Auch wenn die Komponente RichEdit (Register Win32) nur formatierten Text ohne Bilder unterstützt, ist es doch eine interessante Komponente, die man kennen sollte.

Man zieht sie auf das Formular.

[Bearbeiten] Öffnen und Speichern

Als erstes zum Laden und Speichern von Dateien - wir brauchen LoadFromFile und SaveToFile. In Klammern wird ihnen als Parameter der Dateiname übergeben. Hat man die Funktion der Dialoge verstanden, lässt sich das erweitern:

procedure TFormEditor.ladeDatei(Sender: TObject);
begin
  try
    if OpenDialog1.Execute then
      editor.Lines.LoadFromFile(OpenDialog1.FileName);                           {{{1}}}
  except
    ShowMessage('Fehler beim Öffnen einer Datei');
  end;
end;

Ähnlich ist es beim Speichern:

procedure TFormEditor.speicherDatei(Sender: TObject);
begin
  try
    if SaveDialog1.Execute then
      editor.Lines.SaveToFile(SaveDialog1.FileName);                           {{{1}}}
  except
    ShowMessage('Fehler beim Speichern einer Datei');
  end;
end;

[Bearbeiten] Formatierung

[Bearbeiten] Schriftfarbe

Der ColorDialog wird aufgerufen und die Schriftfarbe des gewählten Bereichs im RichEdit wird verändert. Das Ganze funktioniert folgendermaßen:

procedure TForm1.Button3Click(Sender: TObject);
begin
  if ColorDialog1.Execute then                        // ColorDialog aufrufen
    RichEdit1.SelAttributes.Color :=                  // Farbe des gewählten Bereichs
    ColorDialog1.Color;                               // gewählte Farbe im ColorDialog
end;

[Bearbeiten] Kompletter Font

Für den kompletten Font sieht es so aus:

procedure TForm1.Button4Click(Sender: TObject);
begin
  if FontDialog1.Execute then                         // FontDialog aufrufen
  begin
    RichEdit1.SelAttributes.Color :=                  // Farbe des gewählten Bereichs
      FontDialog1.Font.Color;                         // gewählte Schriftfarbe
    RichEdit1.SelAttributes.Name :=                   // Schriftart des gewählten Bereichs
      FontDialog1.Font.Name;                          // gewählte Schriftart
    RichEdit1.SelAttributes.Size :=                   // Schriftgröße des gewählten Bereichs
      FontDialog1.Font.Size;                          // gewählte Schriftgröße
    RichEdit1.SelAttributes.Style :=                  // Style des gewählten Bereichs (fett, kursiv, unterstrichen)
      FontDialog1.Font.Style;                         // gewählter Schriftstyle
  end;
end;

Style kann folgende Werte haben: [fsBold] für Fett. [fsItalic] für kursiv. [fsUnderline] für unterstrichen. [fsStrikeOut] für durchgestrichen. Möchte man einem Style einen Style hinzufügen oder entnehmen, geht das folgendermaßen:

RichEdit1.Font.Style := [fsBold];                          // Fett stellen

RichEdit1.Font.Style := RichEdit1.Font.Style + [fsItalic]; // Kursiv hinzufügen, Ergebnis: fett, kursiv

RichEdit1.Font.Style := RichEdit1.Font.Style - [fsBold];   // Bold wegnehmen, Ergebnis: kursiv

Möchte man mehrere Styles listen, gelingt das mit [fsBold, fsItalic] für fett + kursiv. Soll es wieder Standard sein, ist es [].


Tipp:

Info bulb.png

Die Komponente RichEdit ist auf der einen Seite nützlich, auf der anderen Seite aber auch etwas seltsam. Wenn man der Eigenschaft „Text“ etwas zuweist, bekommt man beim Auslesen möglicherweise nicht dasselbe zurück. Beim Zuweisen hat man nämlich die Möglichkeit, RTF-Code zu verwenden, beim Auslesen bekommt man einen unformatierten Text ohne jegliche RTF-Formatierung. „{\b Hallo }“ wird dann zu „Hallo“.



Arrow left.png Erstellung einer grafischen Oberfläche Grundlagen Inhaltsverzeichnis Erstellung einer grafischen Oberfläche weitere Themen Arrow right.png
Persönliche Werkzeuge