Delphi

Delphi
Hier sind einfach ein paar hilfreiche Notizen, die mir beim Delphi-Lernen aufgefallen sind.
* Messagebox
* Pagecontrol
* Radiogroup
* Graphiken
* Tastaturcode
* Textdateien
* Druckformat
* Dynafenster
* Dynabuttons
* Integerliste
* Schleifenunterbrechung
* Exe-Datei
* Gleitkommaausgabe
* Komponentenentwicklung
* Vererben

Die Messagebox
Unit: Windows
Syntax: Application Messagebox('Mitteilung','Fenstername',[Aufbau]);

[Aufbau] setzt sich wie folgt zusammen:
[Aufbau] := Symbol + Schaltfläche + ButtonFocus

Symbol:

Bedeutung Virtueller Code

0 ohne

16 Kreuz MB_ICONSTOP

32 Fragezeichen MB_ICONQUESTION

48 Ausrufezeichen MB_ICONWARNING

64 Informationszeichen MB_ICONINFORMATION

ButtonFocus:

Bedeutung Virtueller Code

0 1. Schaltfläche wird focussiert MB_DEFBUTTON1

256 2. Schaltfläche wird focussiert MB_DEFBUTTON2

512 3. Schaltfläche wird focussiert MB_DEFBUTTON3

Schaltflächen:

Bedeutung Virtueller Code

0 OK MB_OK

1 OK-Abbrechen MB_OKCANCEL

2 Abbrechen-Wiederholen-Ignorieren MB_ABORTRETRYIGNORE

3 Ja-Nein-Abbrechen MB_YESNOCANCEL

4 Wiederholen-Abbrechen MB_RETRYCANCEL

5 Ja-Nein MB_YESNO

16384 Hilfe MB_HELP

Auswertung:

Bedeutung Virtueller Code

1 OK gewählt IDOK

2 Abbrechen gewählt IDCANCEL

3 Abbruch gewählt IDABORT

4 Wiederholen gewählt IDRETRY

5 Ignorieren gewählt IDIGNORE

6 Ja gewählt IDYES

7 Nein gewählt IDNO

Beispiele:

if Application.Messagebox('Ja?','Frage',MB_ICONQUESTION+MB_YESNO) = IDYES then begin ... end;
if Application.Messagebox('Ja?','Frage',32+4+256)=7 then begin ... end;
var antwort: integer;

antwort := Application.Messagebox('Ja?','Frage',MB_ICONQUESTION+MB_YESNO);

if antwort = 6 then begin ... end;

var antwort: integer;

antwort := Application.Messagebox('Ja?','Frage',32+4+0);

case antwort of

IDYES: begin ... end;

IDNO: begin ... end;

end;

Page Control
ActivePage - Name der aktuellen Seite
PageIndex - Nummer der aktuellen Seite
Pages - Stringliste der Seitennamen
Pages - Stringliste der Seitennamen

Die Tabsheets (also der Seitentitel) verdeckt man mit der Eigenschaft: TabVisible = False.
Mit so verdeckten Tabsheets können mehrere Formulare simuliert werden. Auf die einzelnen Seiten gelangt man mit dem ActivePageIndex. Dieser fängt bei 0 auf der 1. Seite an.

RadioGroup
Die einzelnen, anzukreuzenden Felder sind mit Items einzugeben. Um herauszufinden, welches Item angekreuzt ist:
Case RadioGroup.ItemIndex of
0: begin ... end;
1: begin ... end;
End;

Graphiken
Eine Möglichkeit, Graphiken ausgeben zu lassen, ist in der Paintbox (System). Nachteil hier-bei ist, daß die Graphik nicht dauerhaft gespeichert wird. Ein weiteres Formular darüber und alles ist fort.
Besser: Image (Komponentenleiste Zusätzlich).
Anzusprechen ist dieses Element genau so wie die Paintbox, mit Höhe, Breite, ... .

Virtueller Tastaturcode (virtual keycode)
Steuer- und andere Tasten sind nicht im ASCII-Code greifbar. Deshalb gibt es den sogenannten virtuellen Tastaturcode.
Procedure ...KeyDown(...;var key: word);
Begin
If key = VK_Escape then
...
End;

Einige wichtige Keys:

Bedeutung

VK_LBUTTON linke Maustaste

VK_RBUTTON rechte Maustaste

VK_CANCEL Strg + Pause

VK_BACK Backspace

VK_RETURN Enter

VK_SHIFT Shift

VK_CONTROL Strg (Ctrl)

VK_ESCAPE Escape

VK_SPACE Space

VK_LEFT linke Pfeiltaste

VK_UP Pfeiltaste nach oben

VK_RIGHT rechte Pfeiltaste

VK_DOWN Pfeiltaste nach unten

VK_F1 F1

... ...

VK_F24 F24

VK_DELETE Delete (?)

VK_SNAPSHOT Print-Taste (Druck)

Keys auf dem Nummernblock:

Bedeutung

VK_NUMPAD0 1

VK_NUMPAD1 2

... ...

VK_NUMPAD9 9

VK_ADD Plus +

VK_MULTIPLY Mal *

VK_SUBTRACT Minus -

VK_DECIMAL Geteilt /

Textdateien
Zunächst gibt es folgende Befehle:

AssignFile(datei,name_der_datei.dat);
Rewrite(datei);
Reset(datei);
CloseFile(datei);

Sie bedeuten das Übliche, rewrite kreiert eine neue Datei beziehungsweise überschreibt eine vorhandene. Reset öffnet eine vorhandene Datei. Es gibt eine Fehlermeldung, wenn er sie nicht findet.
Mit FileExists(name_der_datei.dat) wird geprüft, ob die Datei vorhanden ist. FALSE: nicht vorhanden.
Wird kein Pfad explizit angegeben, schreibt er die Datei ins aktuelle Verzeichnis, also da, wo das Programm steht, wenn es schon gespeichtert ist.
Um in eine Datei zu schreiben:
        Write(datei,'text');
        Writeln(datei,'text');
Um aus einer Datei zu lesen:
        Read(datei,Stringvariable);
        Readln(datei,Stringvariable);
Writeln und Readln bewirken ein Überspringen in die nächste Zeile in der Datei.

drucken: Hoch- oder Querformat
Printer.Orientation := poLandscape; // *** Querformat
Printer.Orientation := poPortrait; // *** Hochformat
ACHTUNG!
Printer.Orientation := ... darf nur außerhalb des Druckauftrages kommen!!!! sonst böser Fehler!
Aufgemerkt!
Bei Hochformat ist die kürzere Seite Printer.PageWidth und die längere Printer.PageHeight, bei Querformat ist das genau anders herum, die längere Seite ist Printer.PageWidth und die kürzere ist Printer.PageHeight!
Daher können Berechnungsprozeduren für graphische Element bedenkenlos übernommen werden, der Drucker dreht sie quasi auch mit.

Dynamische Fenster
Es muß ein Hauptformular geben, eine Haupt-Unit. Vor der werden alles weiteren Formulare aufgerufen, vorher müssen diese natürlich als Unit eingebunden werden. Sinnvollerweise im Implementationsteil.

Unit x;
Interface
   ...
Implementation
   uses y;
   ...
   Procedure ...Click (...);
   Var fenster: Tform2;
   Begin
     hide();
     fenster := Tform2.Create(self);
     Try
       fenster.ShowModal();
     Finally
       fenster.free;
     End;
     show();
   End;
end;

Dynamische Knöpfe
Ziel vorliegender Unit ist es, entsprechend einer "anzahl" Buttons zu erzeugen. Diese sind zunächst flach. Beim Anklicken derselben ändern sie ihre Flateigenschaft.
Achtung: Das Formular2 muß die Eigenschaft AutoSize := TRUE bekommen!

unit Unit_3;
interface
uses ...
type
    TFormular1 = class(TForm)
      E_Anzahl: TEdit;
      B_zeigen: TBitBtn;
      B_ende: TBitBtn;
      procedure B_endeClick(Sender: TObject);
      procedure B_zeigenClick(Sender: TObject);
    private
    public
end;
var Formular1: TFormular1;
        anzahl: integer = 0;
implementation
uses Unit_4;
procedure TFormular1.B_zeigenClick(Sender: TObject);
var code: integer;
        fenster: TFormular2;
begin
    val(E_Anzahl.Text,anzahl,code);
    if (code=0) and (anzahl>-1) then
    begin
      fenster := TFormular2.Create(application);
      fenster.ShowModal;
      fenster.free;
    end
    else ShowMessage('Das ist keine ganze positive Zahl!');
end;
end.

unit Unit_4;
interface
uses ..., Buttons;
type
    TFormular2 = class(TForm)
      B_ende: TBitBtn;
      L_Text: TLabel;
      procedure FormActivate(Sender: TObject);
      procedure B_endeClick(Sender: TObject);
      procedure klick(Sender: TObject);
    private
    public
end;
var Formular2: TFormular2;
implementation
uses Unit_3;
var knopf: TSpeedButton;
procedure TFormular2.FormActivate(Sender: TObject);
var nr, a: integer;
begin
    L_Text.Caption := 'Zum Markieren d`raufklicken';
    L_Text.SetBounds(80,1,150,15);
    a := 0;
    for nr := 1 to anzahl do
    begin
      knopf := TSpeedButton.Create(self);
      knopf.Parent := Self;
      knopf.Name := 'knopf'+IntToStr(nr);
      if (odd(nr)) then
      begin
        a := a+1;
        knopf.SetBounds(30,(30*a),100,30);
      end
      else knopf.SetBounds(160,(30*a),100,30);
      knopf.Caption := IntToStr(nr)+'. Knopf';
      knopf.Flat := TRUE;
      knopf.OnClick := klick;
    end;
    B_ende.SetBounds(160,(30*(a+1)),100,30);
end;
procedure TFormular2.B_endeClick(Sender: TObject);
begin
    close();
end;
procedure TFormular2.klick(Sender: TObject);
begin
    knopf:=TSpeedbutton(Sender);
    if knopf.flat then knopf.flat := FALSE
                   else knopf.flat := TRUE;
end;
end.

Liste mit Integerwerten
Nicht zu vergessen ist die Liste selbst:
var liste: TList;
...
liste := TList.Create();

Da die Elemente von TList Zeiger sein müssen. Daher wird ein Zeiger auf den Typ Integer deklariert:
var point: ^integer;

Ein neuer Speicherplatz wird wie folgt allokiert:
New(point);

Dann wird der entsprechende Wert zugewiesen:
point^ := integerzahl;

und in die Liste geschrieben:
liste.Add(point);

Jetzt sollen die Elemente wieder ausgelesen werden. Dazu muß nicht unbedingt eine Pointervariable benutzt werden. Es geht auch so:
integerzahl := integer(liste.Items[nr]^);

Zum Schluß darf dann nicht vergessen werden:
liste.Free;

Schleifenunterbrechung
Unter Delphi kann beispielsweise ein Tastatureingabe während eines Schleifendurchlaufs nur mit Application.Processmessages() realisiert werden:

var stop: boolean;
Procedure ...ButtonOnClick(...);
Begin
   stop := FALSE;
   Repeat
     ...
     Application.Processmessages();
   Until stop = TRUE;
End;
Procedure ...ButtonKeyPressed(...);
Begin
   stop := FALSE;
   Case key of
     'q': stop := TRUE;
     'm': Application.Messagebox('Ja?','Frage',51);
   End;
End;

Achtung: key kann nicht Leertaste sein. Das erkennt er nicht.

Exe-Datei ausführen und Parameter übergeben
Unit shellapi;

Aufruf: shellexecute(handle,'open','programm.exe',nil,nil,sw_show); bzw;
shellexecute(handle,'open','programm.exe',stringvariable,nil,sw_show);

Bei ersterem wird nur eine exedatei ausgeführt, bei letzterem auch noch ein Parameter übergeben. Im aufgerufenen Programm sie das wie folgt aus:

procedure ...OnCreate(...);
begin
if ParamCount>0 then
begin
ShowMessage('Es wurden '+ParamCount+' Paramerter übergeben'+#13+'Der erste lautet: '+ParamStr(0));
end;
end;

Formatierte Gleitkommaausgabe in Stringform
Unit: SysUtils
Syntax: Stringvar := FloatToStrF(kommazahl,ffFixed,Genauigkeit,Nachkommastellen);
Vorschlag: Stringvar := FloattoStrF(realzahl,ffFixed,15,3);

Komponentenentwicklung
Soll die Komponente nicht sichtbar sein: Basisklasse TComponent.
Sinnvoll auch: Basisklasse TObject, für abstrakte Typen.
Hier ein ganz einfaches Zugriffsbeispiel:

unit Kklasse1;
interface
   ...
type Tklasse1 = class(TObject)
      protected
        xWert: real;
      public
        property x: real read xWert write xWert;
        procedure berechnen;
end;
implementation
procedure Tklasse1.berechnen;
begin
    xWert := xWert+7;
end;
end.

unit Unit1
...
implementation
uses Kklasse1;
var klasse1: Tklasse1;
procedure ...Click(...);
begin
    klasse1:=Tklasse1.Create;
    klasse1.x := 5;
    edit1.Text:= floattostr(klasse1.x);
    klasse1.berechnen;
    edit2.Text:= floattostr(klasse1.x);
end;
end.

Vererben
Manchmal ist es sinnvoll, wenn zur Compilierzeit der genaue Typ einer Variablen noch nicht feststeht, wenn beispielsweise ein Gerät angesprochen werden soll, der Nutzer aber erst im Programm angibt, welches das sein soll.
Gewünscht wird folgendes:

var Device: TGeraet;
if x then Device := TGeraet1.Create(self)
else Device := TGeraet2.Create(self);
Device.a(15); // Beispiel für ein Prozeduraufruf

TGeraet ist die Basisklasse:

unit Basisklasse;
interface
type
    TGeraet = class(TComponent)
    private
    protected
      variable: boolean;
    public
      procedure a(b: integer); virtual;
      constructor Create(AOwner: TComponent); override;
      destructor Destroy; override;
    published
end;
implementation
constructor TGeraet.Create (AOwner: TComponent);
begin // Konstruktive Anweisungen für alle!
end;
destructor TGeraet.Destroy;
begin // Destruktive Anweisungen für alle!
end;
procedure TGeraet.a;
begin   // lediglich die Vorwarddeklaration, wird "overrided"
end;
end.

TGeraet1 ist eine Kindklasse, ebenso wie TGeraet2.
So sieht's beim Kind aus:

unit Kindklasse;
interface
uses Basisklasse;
type
    TGeraet1 = class(Geraet)
    private
    protected
      procedure eigen;
    public
      constructor Create (AOwner: TComponent); override;
      destructor Destroy; override;
      procedure a(b: integer); override;
    published
end;
implementation
constructor TGeraet1.Create (AOwner: TComponent);
begin   // Kindspezifische-spezifische Konstruktoren
end;
destructor TGeraet1.Destroy;
begin // Kindspezifische Destruktoren
end;
procedure TGeraet1.a(b: integer);
begin
    ...
end;
procedure TGeraet1.eigen;
begin
    variable := True;
end;
end.

home

	Bedeutung	Virtueller Code
0	ohne
16	Kreuz	MB_ICONSTOP
32	Fragezeichen	MB_ICONQUESTION
48	Ausrufezeichen	MB_ICONWARNING
64	Informationszeichen	MB_ICONINFORMATION

	Bedeutung	Virtueller Code
0	1. Schaltfläche wird focussiert	MB_DEFBUTTON1
256	2. Schaltfläche wird focussiert	MB_DEFBUTTON2
512	3. Schaltfläche wird focussiert	MB_DEFBUTTON3

	Bedeutung	Virtueller Code
0	OK	MB_OK
1	OK-Abbrechen	MB_OKCANCEL
2	Abbrechen-Wiederholen-Ignorieren	MB_ABORTRETRYIGNORE
3	Ja-Nein-Abbrechen	MB_YESNOCANCEL
4	Wiederholen-Abbrechen	MB_RETRYCANCEL
5	Ja-Nein	MB_YESNO
16384	Hilfe	MB_HELP

	Bedeutung	Virtueller Code
1	OK gewählt	IDOK
2	Abbrechen gewählt	IDCANCEL
3	Abbruch gewählt	IDABORT
4	Wiederholen gewählt	IDRETRY
5	Ignorieren gewählt	IDIGNORE
6	Ja gewählt	IDYES
7	Nein gewählt	IDNO

	Bedeutung
VK_LBUTTON	linke Maustaste
VK_RBUTTON	rechte Maustaste
VK_CANCEL	Strg + Pause
VK_BACK	Backspace
VK_RETURN	Enter
VK_SHIFT	Shift
VK_CONTROL	Strg (Ctrl)
VK_ESCAPE	Escape
VK_SPACE	Space

VK_LEFT	linke Pfeiltaste
VK_UP	Pfeiltaste nach oben
VK_RIGHT	rechte Pfeiltaste
VK_DOWN	Pfeiltaste nach unten
VK_F1	F1
...	...
VK_F24	F24
VK_DELETE	Delete (?)
VK_SNAPSHOT	Print-Taste (Druck)

	Bedeutung
VK_NUMPAD0	1
VK_NUMPAD1	2
...	...
VK_NUMPAD9	9
VK_ADD	Plus +
VK_MULTIPLY	Mal *
VK_SUBTRACT	Minus -
VK_DECIMAL	Geteilt /