Το Delphi είναι μια εφαρμογή των Windows που στηρίζεται στον αντικειμενοστραφή προγραμματισμό (object-oriented programming) και στη γλώσσα προγραμματισμού Pascal. Όποιος έχει μια εμπειρία από άλλες αντικειμενοστραφείς εφαρμογές, όπως είναι η Visual Basic, θα βρει αρκετές ομοιότητες στην ανάπτυξη των εφαρμογών. 

Αντίθετα με τα παλαιότερα, «παραδοσιακά» συστήματα ανάπτυξης εφαρμογών, το Delphi είναι καθοδηγούμενο από συμβάντα (event driven), που σημαίνει ότι δεν εκτελεί διαδοχικά τις εντολές ενός προγράμματος, από την αρχή μέχρι το τέλος, αλλά περιμένει την εμφάνιση συμβάντων (events) και εκτελεί τον κώδικα του προγράμματος (διαδικασία ή συνάρτηση) που σχετίζεται με τα συμβάντα αυτά.

Ένα συμβάν (event) είναι μια ενέργεια που προέρχεται από τον χρήστη ή από το σύστημα και παραδείγματα συμβάντων είναι το πάτημα (κλικ) με το ποντίκι πάνω σ’ ένα πλήκτρο εντολής, η μετακίνηση του ποντικιού πάνω από ένα αντικείμενο, η επιλογή ενός αντικειμένου σ’ ένα μενού κ.ά.

Μόλις φορτωθεί το Delphi, θα δούμε την οθόνη να χωρίζεται σε κάποια τμήματα. Στην κορυφή του παραθύρου υπάρχουν τα γνωστά μας πτυσσόμενα μενού (File, Edit, Search, View, Compile, Run, Options, Tools, Help) και στην άνω αριστερή γωνία υπάρχει μια χρήσιμη γραμμή εργαλείων με εικονίδια για το άνοιγμα και την αποθήκευση του έργου (project) και των αρχείων μιας εφαρμογής σε Delphi.

Στο μέσο της οθόνης εμφανίζεται ένα παράθυρο με τον τίτλο Form1, που είναι η προκαθορισμένη φόρμα της εφαρμογής. Τις φόρμες τις χρησιμοποιούμε για να τοποθετούμε εκεί τα αντικείμενα γραφικών της εφαρμογής μας. Πάνω από τη φόρμα βρίσκεται μια παλέτα με πολλές καρτέλες (Standard, Additional, System, Win95, Dialogs, Data Access, Data Controls, Win 3.1, Internet, Samples κ.ά.). Οι καρτέλες αυτές περιέχουν τα αντικείμενα ή εξαρτήματα (components) που μπορούμε να προσθέσουμε στις φόρμες.

Τέλος, υπάρχει και το παράθυρο του Object Inspector, που εμφανίζει τις ιδιότητες του αντικειμένου που έχουμε επιλέξει και έχει δύο καρτέλες : Properties και Events. Η καρτέλα Properties εμφανίζει τις ιδιότητες του επιλεγμένου αντικειμένου, όπως χρώμα, ύψος, πλάτος κ.ά. και η καρτέλα Events εμφανίζει τα συμβάντα που σχετίζονται με το επιλεγμένο αντικείμενο, όπως OnClick, OnDblClick, OnKeyDown, OnMouseMove κ.ά. Οι επιλογές και για τις δύο αυτές καρτέλες διαφέρουν ανάλογα με τον τύπο του επιλεγμένου αντικειμένου.

Για να κάνουμε μια εφαρμογή στο Delphi, επιλέγουμε τη φόρμα πάνω στην οποία θα εργαστούμε, προσθέτουμε στη φόρμα τα αντικείμενα που θέλουμε, όπως πλήκτρα εντολών, πλαίσια κειμένου, ετικέτες κ.ά., ρυθμίζουμε τις ιδιότητες των εξαρτημάτων με τον Object Inspector και γράφουμε τον κατάλληλο κώδικα προγράμματος για τα διάφορα συμβάντα.

Για να προσθέσουμε ένα πλήκτρο εντολής (command button) σε μια φόρμα, μπορούμε να κάνουμε διπλό κλικ πάνω στο εικονίδιο της καρτέλας Standard που γράφει ΟΚ, οπότε θα προστεθεί ένα πλήκτρο εντολής στο κέντρο της φόρμας με προκαθορισμένες διαστάσεις ή να κάνουμε απλό κλικ στο ίδιο εικονίδιο και μετά να σχεδιάσουμε το πλήκτρο όπως το θέλουμε ή να κάνουμε απλό κλικ στο ίδιο εικονίδιο και μετά κλικ μέσα στη φόρμα, οπότε θα προστεθεί ένα πλήκτρο εντολής στο σημείο που κάναμε κλικ και με προκαθορισμένες διαστάσεις.

Αφού επιλέξουμε το πλήκτρο εντολής, μπορούμε να αλλάξουμε την ιδιότητά του Caption ή την ιδιότητά του Name από τον Object Inspector. Η ιδιότητα Caption είναι η ετικέτα (τίτλος) που εμφανίζεται πάνω του, ενώ η ιδιότητα Name είναι το όνομά του, με το οποίο αναφερόμαστε στο πλήκτρο εντολής στα διάφορα συμβάντα που θα δημιουργήσουμε γι’ αυτό. Εξ ορισμού και τα δύο έχουν αρχικά την τιμή Button1, Button2, κοκ.

Αφού προσθέσουμε ένα πλήκτρο εντολής στη φόρμα, το τοποθετήσουμε εκεί που θέλουμε, ρυθμίσουμε το πλάτος και το ύψος του και τις ιδιότητες Caption και Name, κάνουμε διπλό κλικ πάνω του για να ανοίξει το παράθυρο κώδικα όπου θα γράψουμε τις εντολές που θα εκτελεστούν όταν θα κάνουμε κλικ στο πλήκτρο αυτό.

Οι παρακάτω γραμμές κώδικα εμφανίζονται αυτόματα :

procedure TForm1.Button1Click(Sender: TObject);

begin

end;

Βλέπουμε ότι το Delphi δημιουργεί μόνο του μια διαδικασία με όνομα TForm1.Button1Click, που σημαίνει ότι περιέχει τον κώδικα που θα εκτελεστεί όταν κάνουμε Click στο πλήκτρο εντολής που έχει το όνομα (Name) Button1 και ανήκει στην τρέχουσα φόρμα Form1.

Για να δημιουργήσουμε τώρα το πρώτο μας πρόγραμμα σε Delphi, ανάμεσα στις δεσμευμένες λέξεις begin και end, γράφουμε τις εξής εντολές :

ShowMessage(‘Φλώρινα‘);

Close;

Η εντολή (διαδικασία) ShowMessage() εμφανίζει ένα επιτακτικό (modal) παράθυρο, που περιέχει το μήνυμα Φλώρινα και ένα πλήκτρο εντολής με τον τίτλο ΟΚ και στο οποίο πρέπει να κάνουμε κλικ για να μπορέσουμε να συνεχίσουμε. Προσέξτε τη χρήση του χαρακτήρα ; στο τέλος της κάθε εντολής και τη χρήση των μονών εισαγωγικών (‘ ‘) για τα μηνύματα.

Για να τρέξει τώρα αυτή η εφαρμογή, μπορούμε να επιλέξουμε την εντολή Run από το μενού Run ή να πατήσουμε το πλήκτρο F9 ή να πατήσουμε το πλήκτρο με τον τίτλο (ToolTip) Run της γραμμής εργαλείων, που έχει το σχήμα4. Μόλις εκτελεστεί η εφαρμογή, μπορούμε να κάνουμε κλικ στο πλήκτρο εντολής για να εμφανιστεί ένα μικρό παράθυρο διαλόγου με το μήνυμα Φλώρινα, με τον τίτλο PROJECT1.EXE και με ένα πλήκτρο εντολής με τον τίτλο ΟΚ, το οποίο θα περιμένει να κάνουμε κλικ στο πλήκτρο αυτό εντολής για να συνεχίσει η εφαρμογή μας, δηλ. στην ουσία να τελειώσει με την εντολή Close.

Είδαμε προηγουμένως πώς η διαδικασία ShowMessage εμφανίζει μηνύματα σ’ ένα παράθυρο διαλόγου. Υπάρχει και η συνάρτηση InputBox(), με την οποία μπορούμε να πάρουμε πληροφορίες από τον χρήστη. Η συνάρτηση αυτή εμφανίζει ένα παράθυρο διαλόγου που περιέχει έναν τίτλο, ένα μήνυμα, ένα πλαίσιο κειμένου και, αν θέλουμε, και μια προκαθορισμένη τιμή στο πλαίσιο κειμένου. Η τιμή επιστροφής της συνάρτησης είναι αυτό που θα γράψουμε στο πλαίσιο κειμένου.

Το παρακάτω κομμάτι προγράμματος δείχνει τη χρήση της συνάρτησης InputBox() :

procedure TForm1.Button1Click(Sender: TObject);

var

            Response : String;

begin

Response := InputBox('Γεια σου', 'Πώς λέγεσαι;', 'Γιάννης');

ShowMessage(‘Γεια σου ‘+Response);

Close;

end;

Το μήνυμα Γεια σου θα εμφανισθεί στη γραμμή τίτλου του παραθύρου διαλόγου, το μήνυμα Πώς λέγεσαι; θα εμφανισθεί μέσα στο παράθυρο διαλόγου και το Γιάννης θα είναι η προκαθορισμένη τιμή για τη μεταβλητή Response, αν δεν γράψουμε κάτι στο πλαίσιο κειμένου. Ό,τι γράψουμε στο πλαίσιο κειμένου θα θεωρηθεί σαν η τιμή επιστροφής της συνάρτησης και θα καταχωρηθεί στη μεταβλητή Response.

Για να γράψουμε σχόλια (comments) στο Delphi, που όλοι ξέρουμε πόσο σημαντικά είναι για ένα σωστό και ολοκληρωμένο πρόγραμμα, μπορούμε να επιλέξουμε έναν από τους εξής τρεις τρόπους :

{ με τη χρήση των αγκίστρων δεν πρέπει να ξεχάσουμε να κλείσουμε τα σχόλια }

(* τα σχόλια αυτά ανοίγουν με παρένθεση-αστερίσκο και κλείνουν με αστερίσκο-παρένθεση *)

// αυτά τα σχόλια ισχύουν μέχρι το τέλος μόνο της τρέχουσας γραμμής

Οι τύποι δεδομένων του Delphi είναι ίδιοι με τους τύπους δεδομένων της Pascal : 

Με το εξάρτημα ετικέτα (label) μπορούμε να εμφανίσουμε μηνύματα στους χρήστες, τα οποία όμως δεν θα μπορούν να τα αλλάξουν κατά την εκτέλεση της εφαρμογής. Μπορούμε να προσθέσουμε μια ετικέτα σε μια φόρμα με τον ίδιο ακριβώς τρόπο που προσθέτουμε ένα πλήκτρο εντολής. Για τον σκοπό αυτό χρησιμοποιούμε το εικονίδιο που έχει ένα μεγάλο γράμμα Α μέσα του.

Οι προκαθορισμένες τιμές για τις ιδιότητες Caption και Name μιας ετικέτας είναι Label1, Label2 κοκ. Μπορούμε να αλλάξουμε την τιμή της ιδιότητας Caption μιας ετικέτας κατά τη σχεδίαση μιας εφαρμογής ή και κατά την εκτέλεση, δίνοντας τιμή στην ιδιότητα Caption ως εξής :

Label1.Caption := ‘Δώστε όνομα : ’; 

Μπορούμε ακόμα και να εκχωρήσουμε την ιδιότητα Caption μιας ετικέτας σε μια μεταβλητή τύπου String, ως εξής :

S := Label1.Caption; 

Το πλαίσιο κειμένου ή εξάρτημα σύνταξης (edit) χρησιμοποιείται για να καταχωρούμε διάφορες τιμές κατά την εκτέλεση μιας εφαρμογής. Μπορούμε να προσθέσουμε ένα πλαίσιο κειμένου σε μια φόρμα με τον ίδιο ακριβώς τρόπο που προσθέτουμε ένα πλήκτρο εντολής ή μια ετικέτα. Για τον σκοπό αυτό χρησιμοποιούμε το εικονίδιο που έχει τα γράμματα ab μέσα του.

Σ’ ένα πλαίσιο κειμένου μάς ενδιαφέρει η ιδιότητα Text, που περιέχει το κείμενο που γράφει ο χρήστης. Οι προκαθορισμένες τιμές για τις ιδιότητες Text και Name ενός πλαισίου κειμένου είναι Edit1, Edit2 κοκ. Μπορούμε να διαβάσουμε την ιδιότητα Text ή να την αλλάξουμε κατά την εκτέλεση μιας εφαρμογής, ως εξής : 

var

            S : String;

...

            S := Edit1.Text;

...

            Edit1.Text := ‘ ‘;

            ...

            Edit1.Text := ‘ΙΕΚ Φλώρινας’;

Τα πλαίσια κειμένου παρέχουν έναν εύκολο τρόπο λήψης πληροφοριών και αλληλεπίδρασης με τους χρήστες. Η ιδιότητα MaxLength ενός πλαισίου κειμένου καθορίζει το μέγιστο πλήθος χαρακτήρων που μπορούμε να γράψουμε και η ιδιότητα PasswordChar εμφανίζει στη θέση των χαρακτήρων που γράφουμε έναν προκαθορισμένο χαρακτήρα, π.χ. έναν αστερίσκο *. Αυτό γίνεται συνήθως όταν εισάγουμε κάποιον κωδικό και δεν θέλουμε να εμφανίζονται αυτά που πληκτρολογούμε. 

Για να στοιχίσουμε κάποια εξαρτήματα σε μια φόρμα, πρώτα τα επιλέγουμε κρατώντας πατημένο το πλήκτρο Shift και κάνοντας διαδοχικά κλικ πάνω τους και μετά επιλέγουμε την εντολή Align... από το μενού Edit ή κάνουμε δεξί κλικ πάνω στη φόρμα και από το μενού συντόμευσης που εμφανίζεται επιλέγουμε Align... Εμφανίζεται το πλαίσιο διαλόγου Alignment, όπου μπορούμε να επιλέξουμε ένα από έξι πλήκτρα επιλογής (radio buttons) για Horizontal ή/και για Vertical στοίχιση.

Για να μπορούμε να προσθέτουμε διαδοχικά πολλά εξαρτήματα του ίδιου τύπου σε μια φόρμα, για παράδειγμα πολλά πλαίσια κειμένου, κρατάμε πατημένο το πλήκτρο Shift, επιλέγουμε το εξάρτημα που θέλουμε να επαναλάβουμε, αφήνουμε το πλήκτρο Shift και κάνοντας κλικ πάνω στη φόρμα, εμφανίζεται το εξάρτημα που επιλέξαμε. Για να σταματήσει η λειτουργία επαναλαμβανόμενης προσθήκης, κάνουμε κλικ στον δείκτη βέλους στο αριστερό άκρο της παλέτας εξαρτημάτων.

Η σειρά μετάβασης (tab order) είναι η σειρά με την οποία επιλέγονται τα εξαρτήματα σε μια φόρμα όταν πατάμε το πλήκτρο Tab. Το Delphi ρυθμίζει αυτόματα τη σειρά μετάβασης των εξαρτημάτων σύμφωνα με τη χρονική σειρά που προσθέσαμε τα εξαρτήματα στη φόρμα, όπου το πρώτο εξάρτημα που τοποθετήθηκε έχει την τιμή 0 στην ιδιότητα TabOrder.

 Για να αλλάξουμε τη σειρά μετάβασης ενός εξαρτήματος, μπορούμε να αλλάξουμε την τιμή της ιδιότητας TabOrder στον Object Inspector ή να επιλέξουμε Tab Order... από το μενού Edit ή να κάνουμε δεξί κλικ στη φόρμα και να επιλέξουμε Tab Order... από το μενού συντόμευσης που θα εμφανισθεί. Θα εμφανισθεί το πλαίσιο διαλόγου Edit Tab Order, όπου μπορούμε να μετακινήσουμε τα εξαρτήματα της φόρμας για να αλλάξουμε τη σειρά μετάβασής τους.

Το Delphi αποθηκεύει όλες τις μονάδες, φόρμες και τα υπόλοιπα αρχεία μιας εφαρμογής σαν ένα έργο (project) με επέκταση .DPR (Delphi Project File). Οι φόρμες, που είναι αρχεία με επέκταση .DFM, παίρνουν αυτόματα το ίδιο όνομα με την αντίστοιχη μονάδα (unit), που έχει επέκταση .PAS. Το εκτελέσιμο αρχείο μιας εφαρμογής έχει το ίδιο όνομα με το έργο (project), αλλά επέκταση .EXE.

Το Delphi δημιουργεί μόνο του ένα ειδικό αρχείο που λέγεται μονάδα (unit), κάθε φορά που δημιουργούμε μια νέα φόρμα ή ένα νέο έργο. Ενώ εμείς εργαζόμαστε, το Delphi δημιουργεί τις κατάλληλες συνδέσεις των μονάδων με τις φόρμες. Ο κώδικας που γράφουμε για τα διάφορα συμβάντα, καταχωρείται αυτόματα στην αντίστοιχη μονάδα της φόρμας που ανήκει το εξάρτημα για το οποίο γράφουμε το συμβάν.

Κάπως έτσι είναι αρχικά μια μονάδα που δημιουργεί αυτόματα το Delphi :

unit Unit1;

interface

uses

SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls, Forms, Dialogs;

type

TForm1 = class(TForm)

private

{ Private declarations }

public

{ Public declarations }

end;

var

Form1: TForm1;

implementation

{$R *.DFM}

end.

Η πρώτη γραμμή δηλώνει απλά το όνομα της μονάδας, που είναι εξ ορισμού το Unit1. Η ενότητα interface μιας μονάδας λέει στο Delphi ποια αντικείμενα, μεταβλητές, διαδικασίες κ.ά. είναι προσπελάσιμα από άλλες μονάδες. Ο όρος uses καθορίζει ποιες άλλες μονάδες χρησιμοποιεί η τρέχουσα. Τέλος, στην ενότητα implementation περιέχεται ο κώδικας για τα διάφορα συμβάντα. Η τελευταία γραμμή μιας μονάδας είναι πάντα η end.

Ο παρακάτω πίνακας παρουσιάζει τα εξαρτήματα που υπάρχουν στην καρτέλα Standard της παλέτας εξαρτημάτων του Delphi. 

Το πλαίσιο λίστας (listbox) εμφανίζει μια λίστα από επιλογές και κατά την εκτέλεση μπορούμε να επιλέξουμε κάποιο απ’ αυτά τα στοιχεία με το ποντίκι. Για να προσθέσουμε ένα στοιχείο σ’ ένα πλαίσιο λίστας, μπορούμε να πάρουμε το κείμενο από ένα πλαίσιο κειμένου ή να χρησιμοποιήσουμε ένα σταθερό κείμενο. Για να γίνει αυτό, χρησιμοποιούμε τη μέθοδο Add της ιδιότητας Items ενός πλαισίου λίστας : 

ListBox1.Items.Add (Edit1.Text);

ListBox1.Items.Add (‘Φλώρινα’);

Πολλές φορές θα χρειαστεί να αρχικοποιήσουμε μια λίστα, δηλ. να της δώσουμε αρχικές τιμές κατά το ξεκίνημα μιας εφαρμογής. Προς το σκοπό αυτό κάνουμε διπλό κλικ στη φόρμα κατά τη σχεδίαση και καλείται το συμβάν FormCreate, όπου και γράφουμε τον κώδικα αρχικοποιήσεων που θέλουμε να εκτελείται κατά το ξεκίνημα μιας εφαρμογής.

Αφού δημιουργηθεί μια λίστα, μπορούμε να επιλέξουμε ένα στοιχείο απ’ αυτήν και για να ξέρουμε ποιο στοιχείο επιλέχθηκε, χρησιμοποιούμε την ιδιότητα ItemIndex του πλαισίου λίστας, που επιστρέφει ακέραια τιμή, ξεκινώντας από το 0 :

var

            CurrentItem : Integer;

begin

            CurrentItem := ListBox1.ItemIndex;

end;

Για να δούμε το κείμενο της επιλογής που κάναμε στη λίστα, μπορούμε να χρησιμοποιήσουμε την τιμή της ιδιότητας ItemIndex σαν δείκτη στην ιδιότητα Items :

ShowMessage(ListBox1.Items[ListBox1.ItemIndex]);

Άλλες χρήσιμες ιδιότητες ενός πλαισίου λίστας είναι η Columns, στην οποία αν δώσουμε τιμή διάφορη από το 0, τα στοιχεία στο πλαίσιο λίστας θα εμφανίζονται σε πολλαπλές στήλες, η MultiSelect, η οποία αν είναι True θα μπορούμε να κάνουμε πολλαπλή επιλογή στοιχείων στη λίστα με τα πλήκτρα Shift (συνεχόμενη πολλαπλή επιλογή) και Control (μη συνεχόμενη πολλαπλή επιλογή) και η Sorted, η οποία αν είναι True η λίστα θα εμφανίζεται ταξινομημένη.

Το σύνθετο πλαίσιο ή πλαίσιο συνδυασμού (combobox) εμφανίζει μια λίστα επιλογών όπως και ένα πλαίσιο λίστας, αλλά έχει επιπλέον και ένα πλαίσιο κειμένου, όπου μπορούμε να κάνουμε καταχωρήσεις και είναι πτυσσόμενο, άρα εξοικονομεί χώρο στη φόρμα. 

Τα σύνθετα πλαίσια έχουν κοινές με τα πλαίσια λίστας τις περισσότερες ιδιότητες, μεθόδους και συμβάντα και έχουν επιπλέον την ιδιότητα Text, η οποία μας δίνει την τιμή που πληκτρολογήσαμε στο πλαίσιο κειμένου του σύνθετου πλαισίου ή την τιμή που επιλέξαμε από τη λίστα.

Το πλαίσιο ελέγχου (checkbox) είναι ένα τετράγωνο πλαίσιο, το οποίο όταν είναι επιλεγμένο εμφανίζει ένα σημάδι ελέγχου (Ö) μέσα του, ενώ όταν δεν είναι επιλεγμένο είναι κενό.

Σε μια ομάδα πλαισίων ελέγχου, μπορεί να είναι επιλεγμένα όλα, μερικά ή και κανένα. Το πλαίσιο ελέγχου έχει την ιδιότητα Caption, που καθορίζει το μήνυμα (ετικέτα) που εμφανίζεται δίπλα του

Για να διαπιστώσουμε αν ένα πλαίσιο ελέγχου είναι επιλεγμένο, ελέγχουμε την ιδιότητά του Checked ως εξής :

If CheckBox1.Checked Then

            ShowMessage(‘Είναι επιλεγμένο’)

Else

            ShowMessage(‘Δεν είναι επιλεγμένο’);

Το πλήκτρο επιλογής (radiobutton ή optionbutton) έχει παρόμοια λειτουργία με το πλαίσιο ελέγχου, αλλά με τις διαφορές ότι έχει κυκλικό σχήμα, όταν είναι επιλεγμένο εμφανίζει μια μαύρη βούλα (·) μέσα του και ακόμη ένα και μόνο ένα πλήκτρο επιλογής μπορεί να είναι επιλεγμένο από μια ομάδα πλήκτρων επιλογής. Τα πλήκτρα επιλογής είναι χρήσιμα για την εμφάνιση αμοιβαία αποκλειόμενων επιλογών στους χρήστες.

Το πλήκτρο επιλογής έχει την ιδιότητα Caption, που καθορίζει το μήνυμα (ετικέτα) που εμφανίζεται δίπλα του και την ιδιότητα Checked, που μπορεί να πάρει τιμή True ή False, όπως και στα πλαίσια ελέγχου, και καθορίζει το αν είναι επιλεγμένο ή όχι.

Στον παρακάτω κώδικα προγράμματος υποθέτουμε ότι έχουμε δύο πλήκτρα επιλογής, τα RadioButton1 και RadioButton2, οπότε αν δεν είναι επιλεγμένο το πρώτο, θα είναι το δεύτερο.

If RadioButton1.Checked Then

            ShowMessage(‘Είναι επιλεγμένο το 1^ο πλήκτρο επιλογής’)

Else

            ShowMessage(‘Είναι επιλεγμένο το 2^ο πλήκτρο επιλογής’);

Αν τοποθετήσουμε πλήκτρα επιλογής κατευθείαν σε μια φόρμα, αυτά θα είναι μεταξύ τους αμοιβαία αποκλειόμενα. Για να δημιουργήσουμε ομάδες πλήκτρων επιλογής, που να είναι μεταξύ τους ανεξάρτητες, μπορούμε να χρησιμοποιήσουμε το πλήκτρο GroupBox ή το πλήκτρο Panel της καρτέλας Standard.

Σχεδιάζουμε πρώτα μέσα στη φόρμα ένα πλαίσιο ομάδας μ’ ένα από τα δύο προηγούμενα πλήκτρα και μετά τοποθετούμε μέσα στο πλαίσιο αυτό όσα πλήκτρα επιλογής θέλουμε. Τα πλήκτρα επιλογής είναι «συνδεδεμένα» με το πλαίσιο, καθώς μετακινούνται μαζί του και είναι μεταξύ τους αμοιβαία αποκλειόμενα. Αν δημιουργήσουμε ένα άλλο πλαίσιο ομάδας, τα πλήκτρα επιλογής του δεν θα έχουν καμία σχέση με τα πλήκτρα επιλογής του πρώτου πλαισίου ομάδας.

 Το GroupBox και το Panel μπορούν να χρησιμοποιηθούν και για την ομαδοποίηση πλαισίων ελέγχου ή και συνδυασμού πλαισίων ελέγχου με πλήκτρα επιλογής.

 Υπάρχει, όμως, άλλο ένα εξάρτημα, αποκλειστικά για την ομαδοποίηση πλήκτρων επιλογής, το RadioGroup. Για να εισάγουμε πλήκτρα επιλογής σ’ ένα εξάρτημα RadioGroup, πρώτα σχεδιάζουμε ένα πλαίσιο μ’ αυτό και μετά πάμε στην ιδιότητά του Items στον Object Inspector, όπου κάνουμε διπλό κλικ και στο παράθυρο String list editor που θα εμφανιστεί, γράφουμε τους τίτλους (ετικέτες) των πλήκτρων επιλογής που θέλουμε να δημιουργήσουμε μέσα στο RadioGroup.

Αφού καθορίσουμε τα πλήκτρα επιλογής που θα ανήκουν μέσα σ’ ένα RadioGroup, μπορούμε να ελέγξουμε ποιο πλήκτρο έχει επιλεγεί κατά την εκτέλεση, μέσω της ιδιότητας ItemIndex, ως εξής :

If RadioGroup1.ItemIndex = 0 Then

            ShowMessage(‘Είναι επιλεγμένο το 1^ο πλήκτρο επιλογής’)

Else

            ShowMessage(‘Είναι επιλεγμένο το 2^ο πλήκτρο επιλογής’);

Η γραμμή κύλισης (scrollbar) είναι ένα πολύ χρήσιμο εργαλείο, που χρησιμοποιείται για την κύλιση σε παράθυρα ή για την επιλογή τιμών. Αφού δημιουργήσουμε μια γραμμή κύλισης σε μια φόρμα με το κατάλληλο εξάρτημα, μπορούμε να επιλέξουμε αν θα είναι οριζόντια (sbHorizontal) ή κάθετη (sbVertical) από την ιδιότητά της Kind στον Object Inspector.

 Όταν κάνουμε κλικ σ’ ένα από τα βελάκια μιας γραμμής κύλισης, προκαλείται το συμβάν OnScroll και το Delphi μεταβιβάζει στο συμβάν την ακέραια μεταβλητή ScrollPos, που είναι η τιμή που αντιστοιχεί στη θέση του ορθογωνίου μέσα στη γραμμή κύλισης.

 Οι ιδιότητες Min και Max καθορίζουν τα όρια της περιοχής τιμών που μπορεί να επιστρέψει η γραμμή κύλισης, η ιδιότητα SmallChange καθορίζει το βήμα μεταβολής της τιμής της γραμμής κύλισης όταν κάνουμε κλικ στα βελάκια, ενώ η ιδιότητα LargeChange καθορίζει το βήμα μεταβολής της τιμής της γραμμής κύλισης όταν κάνουμε κλικ στον κενό χώρο ανάμεσα στο ορθογώνιο και στα βελάκια.

 Μπορούμε να εμφανίσουμε την τρέχουσα τιμή μιας γραμμής κύλισης σε μια ετικέτα, ως εξής :

 lblRed.Caption := IntToStr(ScrollPos);

Το συμβάν OnChange μιας γραμμής κύλισης εκτελείται κάθε φορά που αλλάζει η τιμή της γραμμής κύλισης.

Τα εξαρτήματα είναι συνήθως διαθέσιμα (enabled) όταν τα τοποθετούμε σε μια φόρμα. Υπάρχουν, όμως, περιπτώσεις κατά την εκτέλεση μιας εφαρμογής, που θέλουμε ορισμένα εξαρτήματα να εμφανίζονται γκρίζα, ώστε να μην μπορούν να επιλεγούν.

Για να κάνουμε ένα εξάρτημα μη διαθέσιμο, θέτουμε στην ιδιότητά του Enabled την τιμή False : 

Button1.Enabled := False;

και για να το κάνουμε διαθέσιμο, θέτουμε στην ιδιότητά του Enabled την τιμή True :

btnAdd.Enabled := True;

            Παρόμοια, υπάρχουν περιπτώσεις κατά την εκτέλεση μιας εφαρμογής, που θέλουμε ορισμένα εξαρτήματα να μην εμφανίζονται καθόλου, δηλ. να αποκρύπτονται μέχρι να ικανοποιηθεί κάποια συνθήκη.

Για να κρύψουμε ένα εξάρτημα, θέτουμε στην ιδιότητά του Visible την τιμή False :

btnPrint.Visible := False;

και για να το εμφανίσουμε, θέτουμε στην ιδιότητά του Visible την τιμή True :

btnPrint.Visible := True;

Στην καρτέλα Additional της γραμμής εργαλείων υπάρχει το εξάρτημα BitBtn, με το οποίο μπορούμε να δημιουργήσουμε ένα πλήκτρο εντολής που να περιέχει μια μικρή επεξηγηματική εικόνα μέσα του, της μορφής bitmap.

Ένα πλήκτρο BitBtn εμφανίζεται αρχικά χωρίς γραφικό, αλλά από την ιδιότητά του Kind μπορούμε να επιλέξουμε μια από πολλές προκαθορισμένες μορφές, που εκτός από την εικόνα, ρυθμίζουν αυτόματα και άλλες λειτουργίες. Οι προκαθορισμένες αυτές μορφές είναι οι εξής : bkOk, bkYes, bkHelp, bkAbort, bkIgnore, bkCancel, bkNo, bkClose, bkRetry και bkAll.

Από την ιδιότητα Glyph μπορούμε να επιλέξουμε και να ενσωματώσουμε στο πλήκτρο εντολής ένα άλλο γραφικό της μορφής bitmap από τα έτοιμα γραφικά που έχει το Delphi ή ένα γραφικό που το έχουμε δημιουργήσει εμείς. Τα γραφικά αυτά μπορούν να αλλάζουν και κατά την εκτέλεση της εφαρμογής.

Για να εμφανίζονται βοηθητικές επεξηγήσεις (ToolTips) σ’ ένα εξάρτημα, όταν μετακινούμε το ποντίκι πάνω του, πρέπει να θέσουμε την τιμή True στην ιδιότητα ShowHint του εξαρτήματος και μετά να γράψουμε στην ιδιότητα Hint το μήνυμα που θέλουμε να εμφανίζεται.

Οι παραπάνω ενέργειες μπορούν να γίνουν και κατά την εκτέλεση μιας εφαρμογής, γράφοντας τον κατάλληλο κώδικα :

btnOK.ShowHint := True;

btnOK.Hint := ‘Κάντε κλικ εδώ για να αρχίσει η αναζήτηση’;

Θα κάνουμε μια εφαρμογή που θα εμφανίζει εικόνες σε μια φόρμα. Δημιουργούμε μια καινούργια εφαρμογή και ρυθμίζουμε την ιδιότητα Position της φόρμας σε poScreenCenter για να εμφανίζεται κεντραρισμένη κατά την εκτέλεση.

Από την καρτέλα Additional της γραμμής εργαλείων, προσθέτουμε δύο πλήκτρα εντολής BitBtn και ένα πλήκτρο εικόνας (Image). Ρυθμίζουμε την ιδιότητα Stretch του στοιχείου Image σε True, ώστε η εικόνα που θα φορτωθεί να προσαρμοστεί στο μέγεθος του στοιχείου και για το ένα πλήκτρο BitBtn επιλέγουμε την τιμή bkOK στην ιδιότητα Kind και για το άλλο την τιμή bkClose.

Από την καρτέλα System προσθέτουμε ένα εξάρτημα FileListBox στη φόρμα και ρυθμίζουμε την ιδιότητά του Mask στην τιμή *.BMP, ώστε να εμφανίζονται μόνο τα αρχεία με την επέκταση αυτή.

Στο συμβάν OnClick του πλήκτρου εντολής bkOK, γράφουμε τον εξής κώδικα :

image1.Picture.LoadFromFile (FileListBox1.FileName);

ώστε να εμφανιστεί στην εικόνα το αρχείο που έχουμε επιλέξει στο πλαίσιο λίστας αρχείων FileListBox1.

Ύστερα κάνουμε διπλό κλικ σε κάποιο κενό σημείο της φόρμας για να γράψουμε τον εξής κώδικα για το συμβάν OnCreate της φόρμας :

FileListBox1.Directory := ‘C:\Windows’;

ώστε να εμφανίζονται στο πλαίσιο λίστας αρχείων τα αρχεία του καταλόγου C:\Windows που έχουν επέκταση .BMP.

Όταν εκτελέσουμε το πρόγραμμα, κάθε φορά που θα κάνουμε κλικ στο πλήκτρο εντολής bkOK, θα εμφανίζεται η εικόνα, το όνομα της οποίας επιλέξαμε στο πλαίσιο λίστας αρχείων.

Για να προσθέσουμε μια νέα φόρμα σ’ ένα έργο, μπορούμε να επιλέξουμε New Form από το μενού File ή να κάνουμε κλικ στο πλήκτρο New Form της γραμμής εργαλείων. Εξ ορισμού, το Delphi δίνει σ’ αυτή τη δεύτερη φόρμα το όνομα Form2 και τη συνδέει αυτόματα με τη μονάδα Unit2.

Όταν σ’ ένα έργο έχουμε δύο ή περισσότερες φόρμες, πρέπει στην ενότητα implementation της μονάδας μιας απ’ αυτές να αναφερόμαστε και στις άλλες φόρμες του έργου με τη δήλωση uses :

            implementation

                        uses Unit2;

Μια φόρμα στο Delphi μπορεί να εμφανιστεί σαν επιτακτική, οπότε πρέπει να κάνουμε κάποια επιλογή μέσα στη φόρμα ή να την κλείσουμε για να μπορέσουμε να συνεχίσουμε με το πρόγραμμα ή σαν μη επιτακτική, οπότε μπορούμε ταυτόχρονα να δουλεύουμε με πολλές φόρμες ή/και παράθυρα.

Αν και η κάθε μέθοδος έχει τα δικά της πλεονεκτήματα, τα επιτακτικά παράθυρα διαλόγου θα πρέπει να τα χρησιμοποιούμε μόνο όταν είναι πραγματικά απαραίτητα.

Για να εμφανιστεί μια φόρμα σαν επιτακτική, χρησιμοποιούμε τη μέθοδο ShowModal και για να εμφανιστεί σαν μη επιτακτική, χρησιμοποιούμε τη μέθοδο Show :

            Form2.ShowModal;              { επιτακτική φόρμα }

            Form2.Show;                         { μη επιτακτική φόρμα }

Όταν δουλεύουμε σ’ ένα έργο που περιέχει πολλές φόρμες, μπορούμε να εναλλασσόμαστε ανάμεσα στις φόρμες και στις μονάδες του έργου με τα παράθυρα διαλόγου που εμφανίζονται από τις επιλογές Project Manager, Units... και Forms... του μενού View. Ένας άλλος τρόπος προβολής των μονάδων είναι να κάνουμε διπλό κλικ σε μια φόρμα, οπότε θα δούμε τον κώδικα της αντίστοιχης μονάδας και καρτέλες για τις άλλες μονάδες του έργου.

Η ιδιότητα BorderStyle μιας φόρμας μπορεί να πάρει διάφορες τιμές : με την τιμή bsDialog, αποκρύπτονται τα πλήκτρα μεγιστοποίησης και ελαχιστοποίησης, αφαιρείται το μενού ελέγχου και δεν επιτρέπεται η αλλαγή μεγέθους της.

 Η επιλογή bsSizeToolWin εμφανίζει τη φόρμα χωρίς μενού ελέγχου και με μια στενή γραμμή τίτλου, ενώ η επιλογή bsToolWindow ενεργεί παρόμοια, αλλά δεν επιτρέπει την αλλαγή μεγέθους του παραθύρου της φόρμας. Και οι δύο αυτές επιλογές είναι χρήσιμες για τη δημιουργία γραμμών εργαλείων.

Η επιλογή bsNone εμφανίζει τη φόρμα χωρίς γραμμή τίτλου, μενού ελέγχου και ανάγλυφο περίγραμμα και η επιλογή bsSingle κάνει τη φόρμα να εμφανίζεται σύμφωνα με το προκαθορισμένο στυλ του Delphi, χωρίς να δέχεται αλλαγή μεγέθους.

Αν από την ιδιότητα FormStyle μιας φόρμας, επιλέξουμε την τιμή fsStayOnTop, τότε η φόρμα θα εμφανίζεται μπροστά από τις άλλες φόρμες, αλλά δεν θα είναι επιτακτική.

Στην περίπτωση που δεν θέλουμε να κλείσει (ξεφορτωθεί) μια φόρμα, επειδή πρέπει να καταχωρήσουμε κάποια τιμή σ’ ένα πλαίσιο κειμένου ή πρέπει να κάνουμε κάποια άλλη εργασία, δίνουμε την τιμή False στην παράμετρο CanClose για να εμποδίσουμε έτσι το ξεφόρτωμα της φόρμας.

Στον παρακάτω κώδικα, δεν μπορούμε να κλείσουμε τη φόρμα αν το πλαίσιο κειμένου CustNumber δεν έχει καθόλου καταχωρήσεις :

begin

            If CustNumber.Text = ‘ ‘ Then begin

                        ShowMessage(‘Δώστε μια τιμή στο Custom Number’);

                        CanClose := False;

            end;

end;

Όταν μια εφαρμογή περιέχει πολλές φόρμες, μπορεί να υπάρχουν εξαρτήματα (στοιχεία ελέγχου) που να έχουν την ίδια ονομασία αλλά να ανήκουν σε διαφορετικές φόρμες. Σ’ αυτή την περίπτωση, πρέπει να χρησιμοποιούμε σαν πρόθεμα στην αναφορά σ’ ένα εξάρτημα το όνομα της φόρμας στην οποία ανήκει το εξάρτημα.

Για παράδειγμα, αν έχουμε δύο φόρμες (Form1 και Form2) που έχουν ένα πλαίσιο κειμένου με το ίδιο όνομα (Edit1) και πρέπει να μπορούμε να κάνουμε κλικ σ’ ένα πλήκτρο εντολής (Button1) για να μεταφέρονται τα περιεχόμενα του πλαισίου κειμένου της δεύτερης φόρμας στο πλαίσιο κειμένου της πρώτης φόρμας, πρέπει να γράψουμε τον εξής κώδικα :

implementation

uses Unit2;

{$R *.DFM}

procedure TForm1.Button1Click(Sender : TObject);

begin

            Edit1.Text := Form2.Edit1.Text;

end;

Αντί να δημιουργούμε πολλές ανεξάρτητες φόρμες, μπορούμε να δημιουργήσουμε πολλές καρτέλες στην ίδια φόρμα. Έτσι, αν έχουμε πολλά εξαρτήματα σε μια φόρμα και δεν θέλουμε να δημιουργήσουμε άλλες φόρμες, μπορούμε να βάλουμε στη φόρμα ένα εξάρτημα TabbedNotebook αν δουλεύουμε με το Delphi 1.0 ή ένα εξάρτημα PageControl αν δουλεύουμε με το Delphi 3.0.

Αν κάνουμε δεξί κλικ σ’ ένα εξάρτημα PageControl, μπορούμε να επιλέξουμε New Page για να δημιουργήσουμε μια καινούργια καρτέλα ή Next Page ή Previous Page για να πάμε στην επόμενη ή στην προηγούμενη καρτέλα.

Το Object Repository (Αποθήκη Αντικειμένων) είναι μια συλλογή από πρότυπα, που μπορούμε να χρησιμοποιήσουμε για τη δημιουργία εφαρμογών. Για να συμπεριλάβουμε ένα αντικείμενο, επιλέγουμε New... από το μενού File και στο πλαίσιο διαλόγου New Items που θα εμφανισθεί, οι καρτέλες Forms, Dialogs, Data Modules και Projects παρέχουν πρόσβαση στα αντικείμενα του Object Repository.

Για παράδειγμα, αν επιλέξουμε το αντικείμενο About box από την καρτέλα Forms, θα εμφανισθεί ένα παράθυρο διαλόγου About, το οποίο μπορούμε να το προσαρμόσουμε στις δικές μας ανάγκες, αλλάζοντας τις ιδιότητές του από τον Object Inspector, την εικόνα και τα στοιχεία που εμφανίζονται καθώς και τον κώδικα για το συμβάν OnClick του πλήκτρου ΟΚ.

Για να προσθέσουμε μια δική μας φόρμα (παράθυρο διαλόγου) στο Object Repository, ώστε να είναι διαθέσιμη όποτε την χρειαστούμε σαν πρότυπο (υπόδειγμα), κάνουμε δεξί κλικ πάνω στη φόρμα και από το πτυσσόμενο μενού επιλέγουμε Add to Repository.

Στο παράθυρο διαλόγου που θα εμφανισθεί, επιλέγουμε ένα όνομα (Title), που είναι απαραίτητο, μια περιγραφή (Description), την καρτέλα του παραθύρου New Items όπου θα εισαχθεί το νέο αντικείμενο (Page), τον συγγραφέα (Author) και το εικονίδιο (Browse...) που θα εμφανίζεται μαζί με το αντικείμενο.

Το αντικείμενο αυτό θα ανήκει στο Object Repository και θα μπορούμε μετά να το προσθέσουμε σε όποια εφαρμογή θέλουμε.

Αν χρησιμοποιούμε τακτικά συγκεκριμένους συνδυασμούς εξαρτημάτων, όπως τα πλήκτρα εντολών ΟΚ και Cancel ή πλαίσια κειμένου ή σύνθετα πλαίσια με συγκεκριμένη μορφή και κώδικα, μπορούμε να δημιουργήσουμε πρότυπα εξαρτημάτων που να διατηρούν τις ιδιότητες των εξαρτημάτων αλλά και τον κώδικα για τα διάφορα συμβάντα.

Για να δημιουργήσουμε ένα πρότυπο εξαρτημάτων, τοποθετούμε τα εξαρτήματα που θέλουμε σε μια φόρμα, ρυθμίζουμε τις ιδιότητές τους, γράφουμε τις διαδικασίες συμβάντων που θεωρούμε απαραίτητες και επιλέγουμε όλα τα εξαρτήματα που θέλουμε να ανήκουν στο πρότυπο.

Στη συνέχεια, επιλέγουμε Add Component Template... από το μενού Component και στο πλαίσιο διαλόγου Component Template Information που θα εμφανισθεί, γράφουμε το όνομα του νέου προτύπου, επιλέγουμε την καρτέλα της παλέτας εξαρτημάτων όπου θέλουμε να εμφανίζεται και το εικονίδιό του.

Για να προσθέσουμε ένα πρότυπο εξαρτημάτων σε μια φόρμα, απλά επιλέγουμε το εικονίδιό του από την παλέτα και για να αφαιρέσουμε ένα πρότυπο εξαρτημάτων από την παλέτα, επιλέγουμε Configure Palette από το μενού Component και μετά Delete.

Μπορούμε να κάνουμε αλλαγές στις καρτέλες της παλέτας εξαρτημάτων, όπως να αλλάξουμε τα ονόματά τους ή να αλλάξουμε τη θέση των εξαρτημάτων τους ή και να κρύψουμε μερικά απ’ αυτά. Για να επαναφέρουμε τις προκαθορισμένες ρυθμίσεις, κάνουμε κλικ στο πλήκτρο All στο πλαίσιο λίστας Pages και μετά επιλέγουμε Default Page.

Οι εντολές που χρησιμοποιούνται στη γλώσσα προγραμματισμού του Delphi είναι παρόμοιες με τις εντολές της γλώσσας Pascal και εδώ θα κάνουμε απλώς μια υπενθύμισή τους.

            If x > y then

                        ShowMessage(‘Το x είναι μεγαλύτερο από το y’)

            else

                        ShowMessage(‘Το y είναι μεγαλύτερο από το x’);

            end;

            Case ItemPrinted of

                        1 : ShowMessage(‘Τυπώθηκε η 1^η αναφορά’);

                        2 : ShowMessage(‘Τυπώθηκε η 2^η αναφορά’);

else

                        ShowMessage(‘Δεν τυπώθηκε καμία αναφορά’);

            end;

            For i := 1 to 3 do begin

                        Name := InputBox(‘Καταχώρηση Ονόματος’, ’Όνομα : ’, ’’);

                        ShowMessage(Name);

            end;

            While UpperCase(StrMsg) <> ‘QUIT’ do begin

                        StrMsg := InputBox(‘Καταχώρηση Κωδικού’, ‘Κωδικός : ’, ‘’);

                        ShowMessage(‘Γράψατε : ’ + StrMsg);

            end;

            Repeat

                        N := InputBox(‘Καταχώρηση Αριθμού’, ‘Αριθμός : ’, ‘’);

            Until N = ‘7’;

            type

                        Countries = (England, France, Germany, Italy, USA, Russia);

            var

                        Market : Countries;

            ...

            Case Market of

                        England : ItemPrice := 45;

                        France : ItemPrice := 50;

            else

                        ItemPrice := 75;

            end;

Η συνάρτηση Ord(Market) επιστρέφει την τιμή απαρίθμησης της μεταβλητής Market, με τιμές από 0 έως 5, και οι συναρτήσεις Succ(Market) και Pred(Market) επιστρέφουν το επόμενο και το προηγούμενο στοιχείο στη σειρά απαρίθμησης.

            type

                        MySubRange = 1..20;

            var

                        Answer : MySubRange;

Για να ενεργοποιήσουμε τον έλεγχο περιοχών (range checking), πρέπει να συμπεριλάβουμε στο πρόγραμμά μας την οδηγία {$R+}.

            var

                        WeekDays : Array [1..7] of String;

                        MyArray : Array [1..30, 1..30] of Integer;

            ...

            WeekDays[1] := ‘Κυριακή’;

            WeekDays[2] := ‘Δευτέρα’;

            ...

            For Index1 := 1 to 30 do

                        For Index2 :=1 to 30 do

                                    MyArray[Index1, Index2] := 0;

            type

                        TEmployRec = Record

                                    LName : String[15];

                                    FName : String[15];

                                    Salary : LongInt;

                        end;

            var

                        EmployeeInfo : TEmployRec;

            ...

            EmployeeInfo.LName := ‘Αντωνιάδης’;

            EmployeeInfo.FName := ‘Αντώνιος’;

            EmployeeInfo.Salary := 300000;

            ή

            With EmployeeInfo do begin

            LName := ‘Αντωνιάδης’;

                        FName := ‘Αντώνιος’;

Salary := 300000;

            end;

Όπως ξέρουμε και από τις άλλες γλώσσες προγραμματισμού, μια υπορουτίνα (διαδικασία ή συνάρτηση) είναι ένα εκτελέσιμο τμήμα προγράμματος, που μπορεί να κληθεί πολλές φορές μέσα σ’ ένα πρόγραμμα, για να εκτελέσει μια συγκεκριμένη εργασία.

Η βασική διαφορά μιας διαδικασίας από μια συνάρτηση είναι ότι η δεύτερη επιστρέφει μία και μόνο μία τιμή, ενώ η πρώτη όχι. Χαρακτηριστικό παράδειγμα διαδικασίας είναι η ShowMessage() και συνάρτησης είναι η InputBox().

Η σύνταξη της διαδικασίας ShowMessage() είναι η εξής :

procedure ShowMessage(const MessageToShow : String);

Η δεσμευμένη λέξη const υποδεικνύει ότι η παράμετρος MessageToShow θα αντιμετωπιστεί από τη διαδικασία σαν σταθερή τιμή, δηλ. η ShowMessage() δεν θα μπορεί να τροποποιήσει τη συμβολοσειρά.

Η σύνταξη της συνάρτησης InputBox() είναι η εξής :

            function InputBox(const DialogCaption, DialogPrompt, DialogDefault : String) : String;

Η συνάρτηση InputBox() δέχεται τρεις παραμέτρους, που είναι όλες τύπου String, και η επιστρεφόμενη τιμή της είναι επίσης τύπου String.

Όπως είδαμε πρωτύτερα, η κεφαλίδα μιας διαδικασίας αρχίζει με τη δεσμευμένη λέξη procedure και μετά ακολουθεί το όνομα της ρουτίνας και η λίστα των παραμέτρων σε παρενθέσεις. Οι δηλώσεις των παραμέτρων είναι χωρισμένες μεταξύ τους με ελληνικά ερωτηματικά.

Εκτός από τις παραμέτρους, που είναι τοπικές μεταβλητές, μια διαδικασία μπορεί να έχει και τις δικές της τοπικές μεταβλητές, που δηλώνονται μετά από την κεφαλίδα της διαδικασίας.

Δείτε το παρακάτω παράδειγμα με τη δήλωση μιας διαδικασίας :

procedure ShowStr(MessageOption : Integer; lblCtrl : TLabel);

{ η διαδικασία αυτή δημιουργεί και εμφανίζει ένα μήνυμα }

var       { εδώ δηλώνονται οι καθαρά τοπικές μεταβλητές της διαδικασίας }

            Str1, Str2 : String;

begin   { το κυρίως σώμα της διαδικασίας }

            If MessageOption = 1 then begin

                        Str1 := ‘...’;

                        Str2 := ‘...’;

            end

            else begin

                        Str1 := ‘...’;

                        Str2 := ‘...’;

            end; { If }

            lblCtrl.Caption := Str1 + Str2;

end; { ShowStr }

            Μια διαδικασία μπορεί να κληθεί από μια άλλη διαδικασία ως εξής :

procedure TForm1.Button1Click(Sender : TObject);

const

            Show_BackupMessage = 1;

begin

            ShowStr(Show_BackupMessage, Label1);

end;

            Δείτε και το παρακάτω παράδειγμα με τη δήλωση μιας συνάρτησης :

function SquareVal(NumberToSquare : Integer) : Integer;

{ η συνάρτηση αυτή υπολογίζει το τετράγωνο ενός αριθμού }

begin { το κυρίως σώμα της συνάρτησης }

            SquareVal := NumberToSquare * NumberToSquare;

end; { SquareVal }

            Μια συνάρτηση μπορεί να κληθεί από μια διαδικασία ως εξής :

procedure TForm1.btnOKClick(Sender : TObject);

var

            NumberToSquare, ReturnValue : Integer;

begin

            NumberToSquare := 5;

            ReturnValue := SquareVal(NumberToSquare);

            Label1.Caption := IntToStr(ReturnValue);

end;

 Όπως ξέρουμε και από τις άλλες γλώσσες προγραμματισμού, οι παράμετροι μεταβιβάζονται σε μια διαδικασία ή σε μια συνάρτηση κατ’ αξία ή κατ’ αναφορά. Στο Delphi υπάρχει ακόμη και η μεταβίβαση σταθερής τιμής, που σημαίνει ότι ακόμα και η τιμή της παραμέτρου δεν μπορεί να μεταβληθεί μέσα στην υπορουτίνα. Η δήλωση αυτή γίνεται με τη χρήση της δεσμευμένης λέξης const πριν από το όνομα της παραμέτρου.

procedure MyProc(const X : Integer);

Αν δεν καθορίσουμε τον τύπο μιας παραμέτρου στη δήλωση μιας υπορουτίνας, το Delphi τη μεταβιβάζει κατ’ αξία, ενώ αν χρησιμοποιήσουμε τη δεσμευμένη λέξη var πριν από το όνομα της παραμέτρου, το Delphi τη μεταβιβάζει κατ’ αναφορά.

procedure MyProc(var X : Integer);

begin

            X := X + 1;

end;

Ο κώδικας μιας διαδικασίας ή συνάρτησης γράφεται στην ενότητα implementation μιας μονάδας και για να είναι διαθέσιμη μια ρουτίνα και σ’ άλλες μονάδες, πρέπει να προσθέσουμε την κεφαλίδα της και στην ενότητα interface της μονάδας.

Abs(N) : επιστρέφει την απόλυτη τιμή μιας έκφρασης.

Copy(String, Start, Size) : επιστρέφει ένα τμήμα της συμβολοσειράς String από τη θέση Start και για πλήθος χαρακτήρων Size.

Length(String) : υπολογίζει το μήκος μιας συμβολοσειράς.

Pos(Char, String) : υπολογίζει την αριθμητική θέση στην οποία βρίσκεται ο χαρακτήρας Char μέσα στη συμβολοσειρά String.

ExtractFileName(String) : εξάγει το όνομα ενός αρχείου από μια πλήρη διαδρομή αρχείου.

ExtractFilePath(String) : επιστρέφει τη διαδρομή χωρίς το όνομα του αρχείου.

Sleep(N) : καθυστερεί την εκτέλεση του προγράμματος για Ν χιλιοστά του δευτερολέπτου.

UpperCase(String) : επιστρέφει μια συμβολοσειρά μ’ όλα τα γράμματά της κεφαλαία.

LowerCase(String) : επιστρέφει μια συμβολοσειρά μ’ όλα τα γράμματά της πεζά.

TrimLeft(String) : αφαιρεί τα αρχικά κενά διαστήματα μιας συμβολοσειράς.

TrimRight(String) : αφαιρεί τα τελικά κενά διαστήματα μιας συμβολοσειράς.

Trim(String) : αφαιρεί τα αρχικά και τα τελικά κενά διαστήματα μιας συμβολοσειράς.

Το Delphi διαθέτει έναν πολύ εύχρηστο και ισχυρό Menu Designer (σχεδιαστής μενού). Η τοποθέτηση ενός μενού σε μια φόρμα έχει το μεγάλο πλεονέκτημα ότι εξοικονομούμε χώρο, αφού αντί να τοποθετήσουμε κάποια πλήκτρα εντολής σε μια φόρμα, μπορούμε να τα τοποθετήσουμε σ’ ένα μενού, το οποίο θα είναι αναπτυσσόμενο και θα το ανοίγουμε μόνο όταν το χρειαζόμαστε.

Προσθέτουμε στη φόρμα ένα εξάρτημα MainMenu από την καρτέλα Standard και κάνουμε διπλό κλικ πάνω του για να ανοίξει ο Menu Designer. Θα εμφανιστεί ένα άδειο παράθυρο με μια κράτηση θέσης για το πρώτο αντικείμενο μενού με τη μορφή ενός ορθογωνίου με διακεκομμένες γραμμές.

Γράφουμε κάτι, π.χ. File και πατάμε το πλήκτρο <enter>. Το ίδιο όνομα δίνεται και στην ιδιότητα Caption του τρέχοντος αντικειμένου του μενού και η ιδιότητα Name παίρνει αυτόματα ένα ανάλογο όνομα. Εμφανίζονται ακόμα δύο θέσεις για να γράψουμε στοιχεία στο μενού, η μία κάτω από το File και η άλλη δεξιά από το File. Γράφοντας εκεί που έχει κενές θέσεις, δημιουργούμε το μενού όπως ακριβώς το θέλουμε.

Για να τροποποιήσουμε ένα υπάρχον αντικείμενο σ’ ένα μενού, αλλάζουμε την ιδιότητά του Caption ή Name, ενώ για να αφαιρέσουμε ένα αντικείμενο, το επιλέγουμε και πατάμε το πλήκτρο <Del> ή κάνουμε δεξί κλικ πάνω του και από το πτυσσόμενο μενού SpeedMenu επιλέγουμε Delete.

Για να προσθέσουμε ένα νέο αντικείμενο στο μενού, πατάμε το πλήκτρο <Ins> στο στοιχείο του μενού που βρίσκεται κάτω από το νέο στοιχείο ή κάνουμε δεξί κλικ πάνω του και από το πτυσσόμενο μενού SpeedMenu επιλέγουμε Insert. Για να αλλάξουμε τη θέση ενός αντικειμένου στο μενού, το σύρουμε με το ποντίκι και το μετακινούμε εκεί που θέλουμε.

Για να προσθέσουμε μια διαχωριστική γραμμή σ’ ένα μενού γράφουμε τον χαρακτήρα - αντί για όνομα στο στοιχείο του μενού. Για να καθορίσουμε ένα πλήκτρο επιτάχυνσης για ένα στοιχείο ενός μενού, γράφουμε τον χαρακτήρα & στο όνομα του στοιχείου του μενού πριν από το γράμμα που θέλουμε να χρησιμοποιηθεί σαν πλήκτρο επιτάχυνσης. Αφού καθοριστεί, το γράμμα αυτό θα εμφανίζεται υπογραμμισμένο στο μενού.

Για να χρησιμοποιηθούν τα πλήκτρα επιτάχυνσης, πρέπει να είναι ανοικτό το μενού, κάτι που δεν είναι απαραίτητο για τα πλήκτρα συντόμευσης. Για να καθορίσουμε ένα πλήκτρο συντόμευσης για ένα αντικείμενο μενού, ρυθμίζουμε την ιδιότητα ShortCut στον Object Inspector, επιλέγοντας τον συνδυασμό των πλήκτρων που θέλουμε να αντιστοιχίσουμε στο στοιχείο του μενού, π.χ. Ctrl+A, F2, Ctrl+F5, Shift+F3 κ.ά. Αφού καθορίσουμε τη συντόμευση, τα πλήκτρα που επιλέξαμε θα εμφανίζονται στο μενού, δίπλα στο αντικείμενο.

Για να δημιουργήσουμε ένα υπομενού, πατάμε Ctrl+® στο στοιχείο του μενού που θέλουμε να φανεί το υπομενού ή κάνουμε δεξί κλικ και επιλέγουμε Create Submenu από το πτυσσόμενο μενού SpeedMenu.

Για να γράψουμε τον κώδικα που θα εκτελείται όταν επιλέγουμε ένα στοιχείο μενού, μπορούμε να κάνουμε διπλό κλικ στο στοιχείο αυτό κατά τη σχεδίαση ή να επιλέξουμε το συμβάν OnClick από την καρτέλα Events του Object Inspector.

Το Delphi έχει και πρότυπα μενού (υποδείγματα), που μπορούμε να τα χρησιμοποιήσουμε για δική μας ευκολία. Για να τα δούμε, κάνουμε δεξί κλικ στο Menu Designer και από το πτυσσόμενο μενού SpeedMenu επιλέγουμε Insert From Template... Από το παράθυρο διαλόγου Insert Template που θα εμφανισθεί, μπορούμε να επιλέξουμε για να εισάγουμε στο μενού που σχεδιάζουμε ένα από τα πρότυπα (υποδείγματα) μενού, όπως Edit Menu, File Menu, Help Menu, Window Menu κ.ά.

Για να δημιουργήσουμε τα δικά μας πρότυπα μενού, επιλέγουμε Save As Template... από το πτυσσόμενο μενού SpeedMenu και στο πλαίσιο διαλόγου Save Template καταχωρούμε την περιγραφή του νέου πρότυπου μενού στο πλαίσιο κειμένου Template Description.

Για να αποκρύψουμε ένα αντικείμενο μενού, θέτουμε την ιδιότητά του Visible σε False και για να το εμφανίσουμε την θέτουμε σε True, ενώ για να το κάνουμε διαθέσιμο, θέτουμε την ιδιότητά του Enabled σε True και για να το κάνουμε μη διαθέσιμο (γκριζαρισμένο), την θέτουμε σε False. Όταν η ιδιότητα Checked ενός αντικειμένου μενού είναι True, εμφανίζεται αριστερά από το αντικείμενο ένα σημάδι ελέγχου (Ö). Την ιδιότητα αυτή την χρησιμοποιούμε όταν το αντικείμενο μενού χρησιμοποιείται για ρυθμίσεις Ναι/Όχι, όπως π.χ. εμφάνιση/απόκρυψη χάρακα.

Ακολουθούν παραδείγματα για τις ιδιότητες που αναφέρθηκαν στην προηγούμενη παράγραφο :

            mnuUndo.Visible := True;

            mnuCut.Enabled := False;

            mnuQuickSave.Checked := True;

            if mnuQuickSave.Checked then

Ο παρακάτω κώδικας δείχνει πώς μπορούμε να προσθέσουμε αντικείμενα σ’ ένα μενού κατά τη διάρκεια της εκτέλεσης (δυναμικά) :

procedure TForm1.mnuFullMenusClick(Sender : TObject);

var

            NewMenuItem : TMenuItem;         { δήλωση ενός αντικειμένου μενού }

begin

            { δημιουργία ενός νέου αντικειμένου μενού }

            NewMenuItem := TMenuItem.Create(mnuOption);

            { ορισμός της λεζάντας του νέου αντικειμένου μενού }

            NewMenuItem.Caption := ‘Αποθήκευση’;

            { τοποθέτησή του στην 3^η θέση του μενού mnuOption }

            mnuOption.Insert(3, NewMenuItem);

end;

Εκτός από τα αναπτυσσόμενα μενού, ενδιαφέρον έχουν και τα αναδυόμενα (pop-up) μενού, τα οποία μπορούμε να τα εμφανίσουμε οπουδήποτε σε μια φόρμα ή σ’ ένα εξάρτημα που έχει την ιδιότητα PopupMenu, όταν κάνουμε δεξί κλικ πάνω τους, αρκεί να έχουμε δηλώσει το όνομα του αναδυόμενου μενού (PopuMenu1, PopupMenu2 κοκ) στην ιδιότητα PopupMenu της φόρμας ή του εξαρτήματος.

Για να δημιουργήσουμε ένα αναδυόμενου μενού, επιλέγουμε το εικονίδιο PopupMenu στην καρτέλα Standard, το τοποθετούμε στη φόρμα, κάνουμε διπλό κλικ πάνω του και καταχωρούμε τα αντικείμενα του μενού με τον γνωστό τρόπο.

Για την προσπέλαση βάσεων δεδομένων, το Delphi χρησιμοποιεί το BDE (Borland Database Engine), που είναι ένας μηχανισμός που επιτρέπει στα προγράμματά μας να χρησιμοποιούν και να επεξεργάζονται δεδομένα διαφορετικών μορφών, όπως βάσεις δεδομένων σε dBase, Paradox, Access κ.ά.

Για να «συνδέσουμε» μια φόρμα μ’ έναν πίνακα μιας βάσης δεδομένων, τοποθετούμε στη φόρμα τα εξαρτήματα DataSource και Table της καρτέλας Data Access, τα οποία φαίνονται κατά τη σχεδίαση της εφαρμογής, αλλά είναι αόρατα κατά την εκτέλεση. Στην ιδιότητα DatabaseName του εξαρτήματος Table επιλέγουμε τη βάση δεδομένων και στην ιδιότητα TableName του ίδιου εξαρτήματος επιλέγουμε τον πίνακα με τον οποίο θα δουλέψουμε.

Μετά, στην ιδιότητα Dataset του εξαρτήματος DataSource επιλέγουμε το όνομα του εξαρτήματος Table, δηλ. το Table1, ρυθμίζουμε την ιδιότητα Active του εξαρτήματος Table σε True και έτσι έχει επιτευχθεί η σύνδεση της φόρμας με τον πίνακα της βάσης δεδομένων.

Από την καρτέλα DataControls μπορούμε μετά να προσθέσουμε διάφορα εξαρτήματα στη φόρμα, όπως DBText, DBEdit, DBMemo, DBImage, DBListBox, DBComboBox και DBCheckBox. Για κάθε εξάρτημα, πρέπει να ρυθμίσουμε την ιδιότητά του DataSource στο όνομα του εξαρτήματος DataSource1 και την ιδιότητά του DataField στο όνομα του πεδίου του πίνακα με το οποίο θα συνδεθεί.

Έτσι, όταν θα εκτελεστεί η εφαρμογή, το κάθε εξάρτημα θα εμφανίζει τα περιεχόμενα κάποιου πεδίου του πίνακα και ό,τι αλλαγές κάνουμε στα περιεχόμενα των εξαρτημάτων αυτών, θα αποθηκευθούν και στα αντίστοιχα πεδία του πίνακα.

Σ’ όλες τις εκδόσεις του Delphi για να δηλώσουμε και να ανοίξουμε ένα σύνολο δεδομένων, δηλ. πίνακα (table) ή ερώτημα (query), χρησιμοποιούμε τις εξής εντολές :

            Table1.DatabaseName := ‘DBDEMOS’;

            Table1.TableName := ‘ANIMALS.DBF’;

            Table1.Open;

Αφού καθορίσουμε ένα σύνολο δεδομένων, μπορούμε να αναφερόμαστε σε οποιοδήποτε πεδίο του πίνακα ως εξής :

            ShowMessage(Table1[‘Name’]);

Η παραπάνω εντολή θα εμφανίσει την τιμή του πεδίου Name της τρέχουσας εγγραφής του πίνακα ANIMALS.DBF σ’ ένα επιτακτικό παράθυρο διαλόγου. Όταν ανοίγουμε ένα σύνολο δεδομένων, το Delphi τοποθετεί τον δείκτη αρχείου στην πρώτη εγγραφή του συνόλου και για να πάμε στην επόμενη εγγραφή, δίνουμε την εντολή Table1.Next; ενώ για να πάμε στην προηγούμενη εγγραφή, δίνουμε την εντολή Table1.Prior;

Για να πάμε στην πρώτη εγγραφή του συνόλου δεδομένων, δίνουμε την εντολή Table1.First, ενώ για να πάμε στην τελευταία εγγραφή του συνόλου δεδομένων, δίνουμε την εντολή Table1.Last. Με τη μέθοδο MoveBy μπορούμε να πάμε κατευθείαν σε μια εγγραφή ή να πάμε προς τα πίσω μερικές εγγραφές :

            Table1.MoveBy(5);               { πάμε στην 5^η εγγραφή }

            Table1.MoveBy(-2);              { μετακίνηση προς τα πίσω 2 εγγραφές }

Ο παρακάτω κώδικας προγράμματος μάς δείχνει πώς μπορούμε να διατρέξουμε ένα σύνολο δεδομένων μέχρι να φθάσουμε στο τέλος του (EOF) ή μέχρι να ικανοποιηθεί μια συνθήκη :

            Table1.DatabaseName := ‘DBDEMOS’;

            Table1.TableName := ‘ANIMALS.DBF’;

            Table1.Open;

            While Not Table1.EOF do

            begin

                        if TrimRight(Table1[‘Name’]) = ‘Boa’ then

                                    begin

                                                ShowMessage(Table1[‘Name’]);

                                                Exit;    { έξοδος από τον βρόχο }

                                    end; { if }

                        Table1.Next;              { πάμε στην επόμενη εγγραφή }

            end; { while }

Με τις μεθόδους GotoKey και GotoNearest μπορούμε να εντοπίσουμε κάποιες εγγραφές, χρησιμοποιώντας ευρετήρια. Η μέθοδος GotoKey πηγαίνει στην εγγραφή που ταιριάζει ακριβώς με τα κριτήρια αναζήτησης, ενώ η μέθοδος GotoNearest δουλεύει με μερικό ταίριασμα.

            Δείτε τον παρακάτω κώδικα προγράμματος :

tblAnimals.DatabaseName := ‘DBDEMOS’;

            tblAnimals.TableName := ‘ANIMALS.DBF’;

            tblAnimals.IndexName := ‘Name’; { ορισμός του κλειδιού }

            tblAnimals.Open;                  { άνοιγμα του πίνακα }

            tblAnimals.SetKey;               { αρχικοποίηση του νέου κλειδιού }

            tblAnimals[‘Name’] := ‘Par’;

            tblAnimals.GotoNearest;     { αναζήτηση για μερικό ταίριασμα }

            MessageDlg(tblAnimals[‘Name’], mtInformation, [mbOk], 0);

Με τη μέθοδο Insert μπορούμε να προσθέσουμε μια εγγραφή στη θέση της τρέχουσας εγγραφής ενός πίνακα, ενώ με τη μέθοδο AppendRecord μπορούμε να προσθέσουμε μια εγγραφή στο τέλος ενός πίνακα.

Δείτε τον παρακάτω κώδικα προγράμματος :

tblHoldings.DatabaseName := ‘DBDEMOS’;

            tblHoldings.TableName := ‘HOLDINGS.DBF’;

            tblHoldings.Open;

            Application.ProcessMessages;

            tblHoldings.Insert;

            tblHoldings[‘ACC_NBR’] := 123;

            tblHoldings[‘SYMBOL’] := ‘ABC’;

            tblHoldings[‘PUR_DATE’] := Date;

            tblHoldings.Post;                   { καταχώριση της εγγραφής }

            ή

            tblHoldings.Open;

            tblHoldings.AppendRecord([2353, ‘NJ’, Nil, 12, ‘10/11/1998’]);

Τις τιμές μπορούμε να τις πάρουμε και από κατάλληλα πλαίσια κειμένου :

            tblHoldings.Insert;

            tblHoldings[‘ACC_NBR’] := editAccNumber.Text;

            tblHoldings[‘SYMBOL’] := editSymbol.Text;

            tblHoldings[‘PUR_DATE’] := editDate.Text;

            tblHoldings.Post;                   { καταχώριση της εγγραφής }

Το Delphi μετατρέπει αυτόματα τις συμβολοσειρές που διαβάζει από τα πλαίσια κειμένου στους κατάλληλους τύπους των πεδίων.

Τη μέθοδο Edit τη χρησιμοποιούμε για να μπορούμε να κάνουμε αλλαγές στα πεδία μιας εγγραφής και αφού ολοκληρωθούν οι αλλαγές στην εγγραφή, πρέπει να καλέσουμε τη μέθοδο Post για να αποθηκευθούν οι αλλαγές.

Δείτε τον παρακάτω κώδικα προγράμματος :

tblAnimals.Edit;

tblAnimals[‘Name’] := ‘Unicorn’;

tblAnimals.Post;

Με τη μέθοδο Delete μπορούμε να αφαιρέσουμε μια εγγραφή από έναν πίνακα και πρέπει να έχουμε υπόψη μας ότι το Delphi δεν προειδοποιεί για την απώλεια της εγγραφής.

tblAnimals.Delete;

Με τη γεννήτρια εκθέσεων ReportSmith μπορούμε να δημιουργήσουμε επαγγελματικές εκθέσεις διαφόρων τύπων, εύκολα και γρήγορα. Για να καλέσουμε το ReportSmith, επιλέγουμε ReportSmith από το μενού Tools ή από την ομάδα προγραμμάτων Delphi στο μενού Προγράμματα. Πατάμε στο πλήκτρο Cancel για να κλείσει το παράθυρο Open Report και μετά επιλέγουμε New... από το μενού File για να δημιουργήσουμε μια καινούργια έκθεση (report).

Στο πλαίσιο διαλόγου Create a New Report, μπορούμε να επιλέξουμε τον τύπο της έκθεσης που θέλουμε να δημιουργήσουμε, διαλέγοντας έναν από τους Columnar, Crosstab, Form και Label. Αν πατήσουμε στο πλήκτρο Style..., θα μπορούμε να επιλέξουμε το στυλ της έκθεσης. Συνήθως επιλέγουμε τον τύπο Columnar.

Το επόμενο πλαίσιο διαλόγου λέγεται Report Query - Tables, εκεί επιλέγουμε το πλήκτρο Add table... και στο πλαίσιο διαλόγου Select Table To Be Added διαλέγουμε τον υποκατάλογο και το αρχείο βάσης δεδομένων που θέλουμε να προσθέσουμε στην έκθεση που δημιουργούμε. Πατάμε το πλήκτρο ΟΚ για να επιστρέψουμε στο πλαίσιο διαλόγου Report Query - Tables και επιλέγουμε Table columns... για να καθορίσουμε τις στήλες (πεδία) που θα εμφανίζονται στην έκθεση.

Μπορούμε να πατήσουμε στο πλήκτρο Select all για να επιλέξουμε όλες τις στήλες ή να επιλέξουμε ορισμένες στήλες με χρήση του πλήκτρου Shift για συνεχόμενη επιλογή στηλών ή του πλήκτρου Control για μη συνεχόμενη επιλογή στηλών. Όταν τελειώσουμε, πατάμε το πλήκτρο ΟΚ για να επιστρέψουμε στο πλαίσιο διαλόγου Report Query - Tables και εκεί πατάμε το πλήκτρο Done για να δημιουργηθεί η νέα έκθεση.

Στην έκθεση που θα εμφανισθεί, μπορούμε να αλλάξουμε τις επικεφαλίδες των στηλών, τον τίτλο της έκθεσης, τη μορφοποίηση μιας ή περισσοτέρων στηλών, να εισάγουμε κεφαλίδα ή/και υποσέλιδο, να επιλέξουμε αύξουσα ή φθίνουσα ταξινόμηση με βάση κάποιο πεδίο (στήλη) και ακόμη να εμφανίσουμε το άθροισμα, τον μέσο όρο, τη μικρότερη, τη μεγαλύτερη τιμή ή και το πλήθος των τιμών μιας στήλης.

Υπάρχουν ακόμα και τα πτυσσόμενα μενού που εμφανίζονται όταν κάνουμε δεξί κλικ σε κάποιο αντικείμενο της έκθεσης και οι επιλογές τους διαφέρουν ανάλογα με το αντικείμενο. Ενδιαφέρον παρουσιάζει η επιλογή Border..., με την οποία μπορούμε να προσθέσουμε ένα περίγραμμα με ή χωρίς σκιά σ’ ένα αντικείμενο.

Από την επιλογή Field... του μενού Insert μπορούμε να προσθέσουμε νέα πεδία σε μια έκθεση και εκτός από τα πεδία της βάσης δεδομένων, μπορούμε να επιλέξουμε και πεδία του συστήματος, όπως ημερομηνία, ώρα, αριθμό σελίδας κ.ά.

Για να περιορίσουμε τις εγγραφές που φαίνονται σε μια έκθεση, μπορούμε να εφαρμόσουμε ένα φίλτρο, για παράδειγμα μπορεί να θέλουμε να φαίνονται μόνο οι πελάτες που έχουν υπόλοιπο πάνω από 100.000 δρχ. Για να δημιουργήσουμε ένα φίλτρο, κάνουμε δεξί κλικ πάνω στο πεδίο στο οποίο θέλουμε να εφαρμοσθεί το φίλτρο και μετά επιλέγουμε Selection criteria... ή επιλέγουμε το πεδίο και μετά Field Selection Criteria... από το μενού Tools.

Στο πλαίσιο διαλόγου Field Selection Criteria, κάνουμε κλικ στο κείμενο may be any value για να εμφανισθεί η λίστα με τα φίλτρα που μπορούμε να εφαρμόσουμε. Επιλέγουμε το φίλτρο που θέλουμε, για παράδειγμα may be equal to, και δίπλα γράφουμε το κείμενο που θέλουμε να ισχύσει για το φίλτρο.

Όταν είμαστε έτοιμοι, μπορούμε να πατήσουμε το πλήκτρο Apply για να δούμε τα αποτελέσματα του φιλτραρίσματος χωρίς να κλείσει το πλαίσιο διαλόγου ή το πλήκτρο Done για να εφαρμοσθεί το φίλτρο και να κλείσει το πλαίσιο διαλόγου. Το ReportSmith δημιουργεί μια συμβολοσειρά SQL, την οποία μπορούμε να την δούμε από την επιλογή SQL Text... του μενού Tools.

Ένα παραγόμενο (derived) πεδίο είναι ένα πεδίο που υπολογίζεται από τις τιμές άλλων πεδίων της έκθεσης. Για να καθορίσουμε ένα παραγόμενο πεδίο, επιλέγουμε Derived Fields... από το μενού Tools και στο πλαίσιο διαλόγου Report Query - Derived Fields επιλέγουμε ένα από τα πλήκτρα επιλογής Defined by SQL ή Defined by ReportBasic macro. Γράφουμε ένα όνομα για το νέο παραγόμενο πεδίο στο πλαίσιο κειμένου Derived Field Name: και πατάμε το πλήκτρο Add. Συνήθως χρησιμοποιούμε την επιλογή Defined by SQL.

Στο πλαίσιο διαλόγου Edit Derived Field μπορούμε να επιλέξουμε ένα ή περισσότερα πεδία από τη λίστα Data Fields για να μπουν στην έκφραση υπολογισμού του πεδίου. Από τη διπλανή λίστα μπορούμε να επιλέξουμε αριθμητικούς τελεστές (+, -, *, /), τελεστές σύγκρισης, λογικούς τελεστές (NOT, AND, OR) ή τελεστές LIKE και BETWEEN. Από την τελευταία δεξιά λίστα, μπορούμε να επιλέξουμε μια από τις συναρτήσεις LOWER(), UPPER() ή COUNT().

Μπορούμε να σύρουμε την επιλογή μας από το πλαίσιο λίστας στο πλαίσιο κειμένου Derived field formula:, όπου δημιουργείται η έκφραση, ή να κάνουμε την επιλογή μας και μετά να πατήσουμε το πλήκτρο Insert ή να το γράψουμε κατευθείαν, αν πρόκειται για απλούς τελεστές. Το ReportSmith εισάγει αυτόματα το όνομα του πίνακα πριν από κάθε πεδίο στην έκφραση, σε περίπτωση που έχουμε πίνακες που έχουν ίδια ονόματα πεδίων.

Για να δούμε αν το αποτέλεσμα μιας έκφρασης είναι σωστό, μπορούμε να πατήσουμε το πλήκτρο Test και το ReportSmith θα μας πει αν υπάρχει λάθος στην έκφραση ή όχι.

Στην περίπτωση που μια έκθεση χρειάζεται δεδομένα από περισσότερους του ενός πίνακες, πρέπει να δημιουργήσουμε έναν δεσμό (link) μεταξύ των πινάκων που θα μπουν στην έκθεση. Οι πίνακες θα συνδεθούν με βάση ένα κοινό πεδίο τους, το οποίο πρέπει να έχει την ίδια δομή και στους δύο πίνακες, αλλά όχι απαραίτητα και το ίδιο όνομα.

Για να δημιουργήσουμε έναν δεσμό σε μια υπάρχουσα έκθεση, επιλέγουμε Report Query... από το μενού Tools και στο πλαίσιο διαλόγου Report Query - Tables πατάμε το πλήκτρο Add table..., επιλέγουμε τον πίνακα που θέλουμε να προσθέσουμε και πατάμε το πλήκτρο ΟΚ για να επανέλθουμε στο προηγούμενο πλαίσιο διαλόγου. Μπορούμε να επιλέξουμε το πλήκτρο Table columns... για καθορίσουμε τις στήλες που θα εμφανισθούν στην έκθεση^ διαφορετικά θα εμφανισθούν όλες.

Πατάμε το πλήκτρο Add new link... και στο πλαίσιο διαλόγου Create New Table Link βλέπουμε ότι το ReportSmith εντοπίζει αυτόματα τα κοινά πεδία των δύο πινάκων και τα τονίζει. Αν, όμως, το ReportSmith δεν μπόρεσε να εντοπίσει τα κοινά πεδία των πινάκων, τα επιλέγουμε εμείς και μετά πατάμε το πλήκτρο ΟΚ για να επιστρέψουμε στο προηγούμενο πλαίσιο διαλόγου, όπου και επιλέγουμε το πλήκτρο Done για να δημιουργηθεί η έκθεση πολλαπλών πινάκων.

Από το πλαίσιο διαλόγου Report Query - Tables μπορούμε να τροποποιήσουμε μια σύνδεση, επιλέγοντας Edit link... ή να την καταργήσουμε, επιλέγοντας Remove link. Για να αποθηκεύσουμε μια έκθεση, μπορούμε να επιλέξουμε Save ή Save As... από το μενού File και για να την εκτυπώσουμε, μπορούμε να επιλέξουμε Print... από το ίδιο μενού.

Για να μπορεί να εκτελεστεί μια έκθεση μέσα σε μια εφαρμογή του Delphi, πρέπει να βάλουμε σε μια φόρμα ένα εξάρτημα Report από την καρτέλα DataAccess, να προσθέσουμε ένα πλήκτρο εντολής και στο συμβάν OnClick του πλήκτρου εντολής να γράψουμε τον παρακάτω κώδικα :

            Report1.ReportName := ‘C:\myapp\reports\rep1.rpt’;

            Report1.Run;

Με το εξάρτημα MediaPlayer της καρτέλας System μπορούμε να ενσωματώσουμε συσκευές πολυμέσων στις εφαρμογές μας, δηλ. να αναπαράγουμε αρχεία τύπου .WAV ή .AVI. Για να γίνει αυτό, πρέπει να καθορίσουμε μια συσκευή και ένα όνομα αρχείου και να ανοίξουμε τη συσκευή.

Τα πλήκτρα που περιλαμβάνει το εξάρτημα MediaPlayer είναι τα γνωστά μας από τις συσκευές ήχου (Play, Pause, Stop, Next, Prev, Step, Back, Record, Eject). Το ποια από τα πλήκτρα αυτά είναι ορατά, καθορίζεται από την ιδιότητα VisibleButtons ενός εξαρτήματος MediaPlayer. Μπορούμε να την αλλάξουμε και κατά την εκτέλεση μιας εφαρμογής, ως εξής :

    MediaPlayer1.VisibleButtons := [btPlay, btPause, btStop];

Σύμφωνα με την παραπάνω εντολή, θα εμφανιστούν μόνο τα πλήκτρα Play, Pause και Stop. Η ιδιότητα EnabledButtons καθορίζει ποια πλήκτρα είναι ενεργά, δηλ. μπορούν να επιλεγούν, και η ιδιότητα ColoredButtons καθορίζει ποια πλήκτρα εμφανίζονται έγχρωμα. Για να απενεργοποιήσουμε το χρώμα και να εμφανίζονται ασπρόμαυρα τα πλήκτρα, δίνουμε την εξής εντολή :

    MediaPlayer1.ColoredButtons := [ ];

Για να κάνουμε αναπαραγωγή ενός αρχείου ήχου, πρέπει να κάνουμε τις παρακάτω ρυθμίσεις σε μερικές ιδιότητες του εξαρτήματος MediaPlayer :

            DeviceType := dtWaveAudio;        { ορισμός συσκευής ήχου }

            FileName := ‘D:\ENCYC97\MM\T012356A.WAV’;

{ ορισμός αρχείου ήχου }

            AutoOpen := True; 

Οι παραπάνω ρυθμίσεις μπορούν να γίνουν κατά τη σχεδίαση ή κατά την εκτέλεση της εφαρμογής. Για να ακούσουμε το αρχείο ήχου, πρέπει να δώσουμε την εντολή MediaPlayer1.Play ή να πατήσουμε το πλήκτρο Play του εξαρτήματος MediaPlayer. Αν δεν έχει η ιδιότητα AutoOpen την τιμή True, πρέπει να δώσουμε την εντολή MediaPlayer1.Open. Παρόμοια, μπορούμε να χρησιμοποιήσουμε κι άλλες εντολές, όπως MediaPlayer1.Pause ή MediaPlayer1.Stop κλπ.

Για να κάνουμε αναπαραγωγή ενός αρχείου video, η διαδικασία είναι παρόμοια μ’ αυτήν για την αναπαραγωγή ενός αρχείου ήχου, με τη μόνη διαφορά ότι δίνουμε την τιμή dtAVIVideo στην ιδιότητα DeviceType.