Podstawowe komponenty Delphi

Spis treúci

WstÍp ............................................................................................................................................7

årodowisko programistyczne.............................................................................................8
1.1. Komponenty................................................................................................................9
1.2. Formatki ....................................................................................................................10
1.3. Object Inspector ........................................................................................................10
1.4. Edytor kodu...............................................................................................................13

Typy plikÛw uøywanych w Delphi ..................................................................................15

Elementy Pascala..............................................................................................................16
3.1. Komentarze ...............................................................................................................16
3.2. Wybrane typy ............................................................................................................16
3.3. Zmienne ....................................................................................................................18
3.4. Sta≥e...........................................................................................................................19
3.5. Instrukcje warunkowe if...then / if...then...else .........................................................20
3.6. Instrukcja wiπøπca with...do......................................................................................21
3.7. PÍtle for...to/downto...do, while...do, repeatÖuntil..................................................22
3.8. Mechanizmy obs≥ugi wyjπtku ...................................................................................23
3.9. Opis wybranych zdarzeÒ ...........................................................................................24
3.10. Nazwa aplikacji (programu)......................................................................................26
3.11. Lista wybranych zmiennych globalnych...................................................................27
3.12. Operatory logiczne i relacji.......................................................................................28

Pierwszy program .............................................................................................................31

∆wiczenia z rozwiπzaniami..............................................................................................34
∆wiczenie 5.1. ComboBox ................................................................................................34
∆wiczenie 5.2. Edit, BitBtn................................................................................................37
∆wiczenie 5.3. Label..........................................................................................................38
∆wiczenie 5.4. Komponent ListBox ..................................................................................40
∆wiczenie 5.5. CheckListBox............................................................................................52
∆wiczenie 5.6. Memo ........................................................................................................53
∆wiczenie 5.7. Image .........................................................................................................55
∆wiczenie 5.8. ScrollBox...................................................................................................56
∆wiczenie 5.9. ProgressBar ...............................................................................................57
∆wiczenie 5.10. StatusBar .................................................................................................57
∆wiczenie 5.11. Timer .......................................................................................................58
∆wiczenie 5.12. RadioButton, GroupBox i CheckBox......................................................59
∆wiczenie 5.13. TrackBar..................................................................................................61
∆wiczenie 5.14. MediaPlayer ............................................................................................62
∆wiczenie 5.15. Menu........................................................................................................62

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 5.16. PopupMenu .............................................................................................64
∆wiczenie 5.17. StringGrid................................................................................................65
∆wiczenie 5.18. TreeView .................................................................................................69
∆wiczenie 5.19. WewnÍtrzna lista .....................................................................................72
∆wiczenie 5.20. Okna informacyjne ..................................................................................73
∆wiczenie 5.21. Okna s≥uøπce do zadawania pytaÒ...........................................................76
∆wiczenie 5.22. Okna dialogowe.......................................................................................78
∆wiczenie 5.23. Obs≥uga kilku komponentÛw ..................................................................80
∆wiczenie 5.24. UpDown ..................................................................................................83
∆wiczenie 5.25. ScrollBar..................................................................................................84
∆wiczenie 5.26. Splitter .....................................................................................................85
∆wiczenie 5.27. Dynamiczne tworzenie komponentÛw ....................................................86
∆wiczenie 5.28. Wczytanie czcionek do listy ComboBox i ListBox ................................90
∆wiczenie 5.29. Instalacja nowych komponentÛw ............................................................92
∆wiczenie 5.30. Dymki (Podpowiedzi) .............................................................................93
∆wiczenie 5.31. MDI (aplikacja wielodokumentowa) ......................................................94
∆wiczenie 5.32. Wczytanie pliku przez podanie jego nazwy jako parametr.....................98
∆wiczenie 5.33. Uruchomienie innego programu z poziomu aplikacji .............................99
∆wiczenie 5.34. Pozycja kursora myszy............................................................................99
∆wiczenie 5.35. Zamiana znakÛw w tekúcie ...................................................................100
∆wiczenie 5.36. Grafika...................................................................................................102
∆wiczenie 5.37. Funkcja s≥ownie.....................................................................................104
∆wiczenie 5.38. Wprowadzenie do baz danych...............................................................109
∆wiczenie 5.39. Wyúwietlenie tabeli w komponencie StringGrid ..................................119
∆wiczenie 5.40. Sortowanie w komponencie StringGrid ................................................124
∆wiczenie 5.41. Alarm.....................................................................................................128
∆wiczenie 5.42. Standardowe animacje w systemie Windows .......................................130
∆wiczenie 5.43. Dodawanie dni do daty..........................................................................132
∆wiczenie 5.44. Nazwy dni i miesiÍcy ............................................................................137
∆wiczenie 5.45. PageControl (Zak≥adki) .........................................................................140
∆wiczenie 5.46. Rysowanie na ograniczonym obszarze..................................................142
∆wiczenie 5.47. Memo do wyúwietlania krÛtkiej pomocy ..............................................144
∆wiczenie 5.48. Wπtki .....................................................................................................147
∆wiczenie 5.49. Wydruki.................................................................................................151
∆wiczenie 5.50. Wyúwietlenie nazw kolumn z bazy .......................................................164
∆wiczenie 5.51. Wyselekcjonowanie liczb z tekstu ........................................................166
∆wiczenie 5.52. Gauge ....................................................................................................168
∆wiczenie 5.53. Chart ñ wykresy ....................................................................................171
∆wiczenie 5.54. Liczenie plikÛw .....................................................................................175
∆wiczenie 5.55. Okno InputBox ......................................................................................178
∆wiczenie 5.56. Plik rekordowy ......................................................................................179
∆wiczenie 5.57. Odliczanie czasu w ty≥...........................................................................183
∆wiczenie 5.58. Zmiana wielkoúci liter ...........................................................................186
∆wiczenie 5.59. Szukanie danych w komponencie StringGrid .......................................189
∆wiczenie 5.60. Polskie znaki(Ogonki)...........................................................................193

∆wiczenia do samodzielnego wykonania .....................................................................196

KsiπøkÍ tÍ dedykujÍ swojej mamie

∆wiczenia z podstawowych komponentÛw Delphi

WstÍp

Ksiπøka obejmuje Êwiczenia z programu Borland Delphi i jest przeznaczona dla

szerokiego grona uøytkownikÛw znajπcych obs≥ugÍ systemu Windows, ktÛrzy chcie-
liby w szybki i przyjemny sposÛb rozpoczπÊ naukÍ programowania.

Borland Delphi jest 32 bitowym úrodowiskiem programistycznym dajπcym moø-

liwoúÊ obiektowego i wizualnego projektowania aplikacji, przez co zaliczane jest do
narzÍdzi typu RAD (Rapid Application Development) ñ co oznacza szybkie tworzenie
aplikacji.

Te walory przyczyniajπ siÍ do tworzenia programÛw w sposÛb przyjemny

i szybki. Programy zrobione za pomocπ Delphi 3.0 sπ programami 32 bitowymi, przez
co pracujπ szybciej od swoich 16 bitowych odpowiednikÛw utworzonych za pomocπ
Delphi 1.0 lub Pascala.

Wszystkie przedstawione Êwiczenia dotyczπ Delphi w wersji 3.0 lub wyøszej

i znajdujπ siÍ na do≥πczonej do ksiπøki dyskietce. Znajduje siÍ tam rÛwnieø kilka
nowych komponentÛw (miÍdzy innymi obs≥uga rysunkÛw jpeg, wybÛr katalogu),
ktÛre moøna zainstalowaÊ.

Mam nadziejÍ, øe ksiπøka ta przyczyni siÍ do szybkiego poznania Delphi i two-

rzenia programÛw za pomocπ tego jÍzyka.

Autor

årodowisko programistyczne

Po uruchomieniu Delphi zobaczymy zintegrowane úrodowisko przedstawione na

rysunku 1.1.

Rysunek 1.1.

årodowisko to sk≥ada siÍ z nastÍpujπcych elementÛw:
N komponentÛw,
N formatki (Form1),
N inspektora obiektÛw,
N edytora kodu,
N paskÛw narzÍdzi,
N i wielu innych.

årodowisko programistyczne

1.1.

Komponenty

Komponenty w Delphi sπ bardzo duøym u≥atwieniem w czasie tworzenia aplika-

cji. DziÍki nim moøna znaczπco ograniczyÊ pisanie kodu, przez co programy zawie-
rajπ mniej b≥ÍdÛw.

Komponenty umieszczone sπ z prawej strony poniøej paska menu. Rysunek 1.1.1

przedstawia paletÍ komponentÛw.

Rysunek 1.1.1.

W celu umieszczenia komponentu na formatce naleøy wykonaÊ nastÍpujπce

czynnoúci:

Wybierz komponent z palety komponentÛw (np. Edit z karty Standard). Po
wskazaniu komponentu wskaünikiem myszy zostanie on wyrÛøniony (rysunek
1.1.2).

Rysunek 1.1.2.

Wybierz komponent przez naciúniÍcie (klikniÍcie) danego komponentu, co jest
przedstawione na rysunku 1.1.3.

Rysunek 1.1.3.

Po tych czynnoúciach kliknij formatkÍ w miejscu, w ktÛrym ma siÍ znaleüÊ wy-
brany komponent lub kliknij dwukrotnie (szybko) wybrany komponent, co spo-
woduje umieszczenie go na formatce. Takπ sytuacjÍ ilustruje rysunek 1.1.4.

Automatycznie jest zaznaczany tylko jeden komponent, ktÛry zosta≥ umieszczo-

ny na formatce (rysunek 1.1.4). Jeøeli na formatce jest wiÍcej komponentÛw, to zazna-
czenie przechodzi na nastÍpny komponent umieszczany na formatce.

Komponenty znajdujπce siÍ na formatce moøna zaznaczaÊ przez klikniÍcie na

dany komponent, co spowoduje zaznaczenie wybranego komponentu 8 uchwytami
(kwadracikami) ñ rysunek 1.1.4. Komponent oznaczony moøemy przesuwaÊ (przy-
trzymujπc wciúniÍty lewy przycisk myszy), rozciπgaÊ i zmieniaÊ jego w≥aúciwoúci.

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 1.1.4.

1.2.

Formatki

Formatki sπ podstawowym elementem Delphi, na ktÛrym umieszczane sπ kom-

ponenty. W momencie uruchomienia Delphi formatka (ang.

form) jest tworzona auto-

matycznie stajπc siÍ oknem g≥Ûwnym aplikacji o nazwie Form1. Wyglπd formatki
przedstawia rysunek 1.2.1.

Rysunek 1.2.1.

FormatkÍ wywo≥ujemy piszπc Nazwa_formatki.ShowModal;. Przyk≥adowo, je-

úli nazwπ formatki jest Form2, to wywo≥ujemy jπ piszπc ÑForm2.ShowModal;î.

1.3.

Object Inspector

Object Inspector (Inspektor obiektÛw) umoøliwia zmianÍ w≥aúciwoúci kompo-

nentÛw umieszczanych na formatce. W≥aúciwoúci te rÛwnieø moøna zmieniaÊ w ko-
dzie programu.

Wyglπd okna Object Inspector ilustruje rysunek 1.3.1.

årodowisko programistyczne

Rysunek 1.3.1.

Po umieszczeniu komponentÛw na formatce moøemy zmieniaÊ ich w≥aúciwoúci

za pomocπ okna Object Inspector lub programowo. SposÛb umieszczenia kompo-
nentÛw na formatce jest opisany w podrozdziale 1.1.

W celu wybrania zdarzenia (np. OnCreate) naleøy wykonaÊ nastÍpujπce czynnoúci:

Kliknij dwukrotnie formatkÍ (ang.

form), co spowoduje wygenerowanie zdarze-

nia (np. OnCreate). Rysunek 1.3.2 przedstawia takπ sytuacjÍ:

Rysunek 1.3.2.

Moøna teø skorzystaÊ z pomocy okna Object Inspector, w ktÛrym moøemy rÛw-

nieø wygenerowaÊ zdarzenie (np. OnCreate). Robimy to w nastÍpujπcy sposÛb:

Wybierz okno Object Inspector lub naciúnij klawisz funkcyjny F11.

NastÍpnie przejdü do karty Events (Zdarzenia) ñ rysunek 1.3.3.

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 1.3.3.

Obok okienka o nazwie (np. OnCreate) kliknij dwukrotnie, co spowoduje wyge-
nerowanie zdarzenia (rysunek 1.3.4).

Rysunek 1.3.4.

Przy wyborze innych zdarzeÒ wykonujemy takie same czynnoúci jak opisane wyøej.

Zmiany w≥aúciwoúci (np. Caption) dokonujemy w nastÍpujπcy sposÛb:

Programowo, przez wpisanie w tym przypadku linii w kodzie programu (rysunek
1.3.5).

Rysunek 1.3.5.

Albo za pomocπ okna Object Inspector ñ w tym przypadku komponent Label
musi byÊ zaznaczony, przez wybranie w≥aúciwoúci (np. Caption) na karcie Pro-
perties (W≥aúciwoúci) i wpisanie dowolnego tekstu (rysunek 1.3.6).

årodowisko programistyczne

Rysunek 1.3.6.

Przy wyborze innych w≥aúciwoúci postÍpujemy tak samo.

Uwaga:
N W≥aúciwoúci i zdarzenia moøemy zmieniaÊ tylko komponentom znajdujπcym siÍ

na formatce za pomocπ Object Inspector.

N ZawartoúÊ okna Object Inspector zmienia siÍ w zaleønoúci od wybranego kom-

ponentu.

1.4.

Edytor kodu

Edytor kodu jest edytorem tekstowym, w ktÛrym piszemy kod programu, ktÛry

jest kolorowany dla wiÍkszej przejrzystoúci. Kolory te moøemy zmieniaÊ w opcjach
programu.

Wyglπd tego edytora przedstawia rysunek 1.4.1.

Rysunek 1.4.1.

Edytor ten ma jeszcze trzy udogodnienia warte wspomnienia. Pierwsze z nich polega

na uzupe≥nianiu wpisywanych funkcji, przez co programista jest zwolniony od pamiÍtania
w≥aúciwoúci poszczegÛlnych komponentÛw. Takπ sytuacjÍ przestawia rysunek 1.4.2.

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 1.4.2.

Drugim udogodnieniem jest moøliwoúÊ wprowadzania fragmentu kodu do pisa-

nej aplikacji za pomocπ kombinacji klawiszy Ctrl+J, co powoduje wyúwietlenie listy
dostÍpnych fragmentÛw kodu (wzorce kodu) ñ rysunek 1.4.3. Kody te naleøy wcze-
úniej napisaÊ i zapisaÊ do pliku tekstowego DELPHI32.DCI, ktÛry znajduje siÍ
w g≥Ûwnym katalogu Delphi.

Rysunek 1.4.3.

Trzecim udogodnieniem wartym wspomnienia jest moøliwoúÊ podpowiadania

jaki rodzaj zmiennej naleøy wpisaÊ (np. tekst w celu dodania do listy ListBox). Rysu-
nek 1.4.4 przedstawia takπ sytuacjÍ.

Rysunek 1.4.4.

Typy plikÛw uøywanych w Delphi

Delphi rozrÛønia nastÍpujπce typy plikÛw:
N DPR ñ plik projektu (zawiera dane na temat modu≥Ûw i formatek, ktÛre wchodzπ

w sk≥ad projektu);

N DFM ñ plik formatki (zawiera informacje o po≥oøeniu komponentÛw). Do kaø-

dego pliku jest tworzony plik modu≥u o tej samej nazwie;

N PAS ñ plik modu≥u (pliki te zawierajπ kody ürÛd≥owe wygenerowane przez

Delphi oraz kody napisane przez programistÍ);

N DCU ñ plik skompilowany, ktÛry jest tworzony w momencie kompilacji;
N RES ñ plik zasobÛw (zawiera informacje na temat ikon, kursorÛw itp.);
N DSK ñ pliki te zawierajπ informacjÍ o wyglπdzie úrodowiska i kompilacji;
N EXE ñ jest to plik skompilowany, ktÛry moøe byÊ uruchomiony poza úrodowi-

skiem Delphi;

N DLL ñ sπ to biblioteki do≥πczane do programu dynamicznie w momencie pracy

aplikacji;

N Pliki zapasowe o rozszerzeniu rozpoczynajπcym siÍ znakiem tyldy (~) sπ two-

rzone w momencie zapisywania projektu na dysk.

Elementy Pascala

3.1.

Komentarze

Komentarze umoøliwiajπ opisanie fragmentÛw kodu. Komentarze te zwiÍkszajπ

czytelnoúÊ kodu, co ma duøe znaczenie dla programisty. W czasie kompilacji tekst
komentarza jest pomijany. Delphi dysponuje nastÍpujπcymi rodzajami komentarzy:
N { komentarz } ñ nawiasy klamrowe, ktÛre umoøliwiajπ zaznaczenie znacznej

czÍúci opisu znajdujπcego siÍ w kilku wierszach;

przyk≥ad:

{
To jest komentarz.
Taki sam by≥ w Turbo Pascalu
}

N // komentarz ñ umoøliwia wstawienie komentarza tylko w jednym wierszu;

przyk≥ad:

// To jest komentarz, ktÛry moøna umieúciÊ w jednym wierszu

N (* to teø jest komentarz *) ñ nawiasy po≥πczone z gwiazdkπ rÛwnieø umoøliwiajπ

zaznaczenie znacznej czÍúci opisu znajdujπcego siÍ w kilku wierszach;

przyk≥ad:

(*
To jest komentarz.
Taki sam by≥ w Turbo Pascalu
*)

3.2.

Wybrane typy

W czasie deklaracji zmiennej naleøy okreúliÊ jej typ. Typ jest zbiorem okreúlajπ-

cym wartoúci jakie moøe przyjmowaÊ zmienna.

Typ ca≥kowity:
N Shortint ñ przyjmuje liczby z zakresu od ñ128 do 127 i ma rozmiar 1 bajta;

Elementy Pascala

N Smallint ñ przyjmuje liczby z zakresu od ñ32768 do 32767 i ma rozmiar 2 baj-

tÛw;

N Longint ñ przyjmuje liczby z zakresu od ñ2147483648 do 2147483647 i ma

rozmiar 4 bajtÛw;

N Byte ñ przyjmuje liczby z zakresu od 0 do 255 i ma rozmiar 1 bajta;
N Word ñ przyjmuje liczby z zakresu od 0 do 65535 i ma rozmiar 2 bajtÛw;
N Integer ñ przyjmuje liczby z zakresu od ñ2147483648 do 2147483647 i ma

rozmiar 4 bajtÛw;

N Cardinal ñ przyjmuje liczby z zakresu od 0 do 2147483647 i ma rozmiar 4 baj-

tÛw.

Typy rzeczywiste:
N Real ñ przyjmuje liczby z zakresu od 2.9 x 10-39 do 1.7 x 1038 i ma rozmiar

6 bajtÛw (uwaga: typ ten zosta≥ zachowany w celu zgodnoúci z poprzednimi wer-
sjami Pascala);

N Single ñ przyjmuje liczby z zakresu od 1.5 x 10-45 do 3.4 x 1038 i ma rozmiar

4 bajtÛw;

N Double ñ przyjmuje liczby z zakresu od 5.0 x 10-324 od 1.7 x 10308 i ma roz-

miar 8 bajtÛw;

N Extended ñ przyjmuje liczby z zakresu od 3.4 x 10-4932 do 1.1 x 104932 i ma

rozmiar 10 bajtÛw;

N Comp ñ przyjmuje liczby z zakresu od -263+1 do 263 -1 i ma rozmiar 8 bajtÛw;
N Currency ñ przyjmuje liczby z zakresu od -922337203685477.5808 do

922337203685477.5807 i ma rozmiar 8 bajtÛw. Typ ten zosta≥ utworzony na po-
trzeby obliczeÒ finansowych.

Typ Variant:

Jest to doúÊ niezwyk≥e rozwiπzanie pozwalajπce na dynamicznπ zmianÍ typu

zmiennej, tzn. zmienna moøe przyjπÊ typ ca≥kowity, rzeczywisty, itp.

Przyk≥ad:

var

V: Variant;

begin

V:= ‘To jest tekst’;

// Jest typem ≥aÒcuchowym

V:= 1256;

// Jest typem ca≥kowitym

end;

∆wiczenia z podstawowych komponentÛw Delphi

3.3.

Zmienne

Zmienne umoøliwiajπ przechowywanie wartoúci lub napisÛw (≥aÒcuchÛw teksto-

wych). Zmienne umieszcza siÍ za s≥owem var (ang. variables), a przed blokiem in-
strukcji begin i end lub w sekcji private albo public.

Przyk≥ad:

var

Hour, Min, Sec, MSec :Word;

// Deklaracja zmiennych

Poniøej jest przedstawiony przyk≥ad prawid≥owego umiejscowienia zmiennych

w kodzie:

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Forms;

type

TForm1 = class(TForm)

procedure FormCreate(Sender: TObject);

private

{ Private declarations }

// Deklaracja zmiennej liczbowej typu ca≥kowitego.

// Zmienna globalna dla danego modu≥u

numLiczba: Integer;

public

{ Public declarations }

// Deklaracja zmiennej tekstowej

// zmienna globalna dla ca≥ego projektu

txtString: String;

end;

var

Form1: TForm1;

// Zadeklarowanie zmiennej typu znakowego

// Zmienna globalna widoczna w ca≥ym programie

chrChar: Char;

implementation

{$R *.DFM}

procedure TForm1.FormCreate(Sender: TObject);

var

okSwitch: Boolean;

// Deklaracja zmiennej logicznej

Elementy Pascala

// zmienna lokalna widoczna tylko w

// funkcji, w ktÛrej zosta≥a zadeklarowana

begin

// FormCreate

end;

end.

Zmiennej tekstowej o nazwie ÑtxtStringî (zadeklarowanej w formie nr 1, tj. Unit1

w sekcji public) moøemy przypisaÊ dowolny tekst z innej formy (np. nr 2, tj. Unit2).
Oto przyk≥ad:

procedure TForm2.FormShow(Sender: TObject);

begin

// FormShow

Form1.txtString:= 'Tester';

end;

3.4.

Sta≥e

Sta≥e wprowadza siÍ do programu w celu u≥atwienia pÛüniejszej modyfikacji

programu, ktÛrπ moøemy wykonaÊ w jednym miejscu programu. W przeciwnym
przypadku musielibyúmy wprowadzaÊ zmiany w kilku miejscach, co moøe przyczyniÊ
siÍ do powstawania b≥ÍdÛw. Sta≥π deklarujemy po s≥owie const (ang. constants). Oto
przyk≥ady:

const

Miesiące = 12;

// Deklaracja iloúci miesiÍcy w roku

Doba = 24;

// Deklaracja iloúci godzin w ciπgu doby

Poniøej jest przedstawiony przyk≥ad umiejscowienia sta≥ych w kodzie:

unit Unit1;

interface

uses

Windows, Messages, SysUtils, Classes, Graphics, Forms;

const

// Deklaracja sta≥ej liczbowej

// Sta≥a globalna widoczna w ca≥ym programie

numLiczba = 23;

type

TForm1 = class(TForm)

procedure FormCreate(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

∆wiczenia z podstawowych komponentÛw Delphi

end;

var

Form1: TForm1;

implementation

{$R *.DFM}

procedure TForm1.FormCreate(Sender: TObject);

const

// Deklaracja sta≥ej tekstowej

// Sta≥a lokalna widoczna tylko w funkcji, w

// ktÛrej zosta≥a zadeklarowana

txtString = 'Jan Biernat';

begin

// FormCreate

end;

end.

3.5.

Instrukcje warunkowe if...then / if...then...else

Instrukcje warunkowe if...then / if...then...else pozwalajπ na sterowanie progra-

mem. Polega ono na spe≥nieniu okreúlonego warunku, ktÛry pozwala na wykonanie
odpowiedniej czÍúci programu (kodu). Jeøeli chcemy wywo≥aÊ wiÍkszπ liczbÍ funkcji,
procedur lub wpisaÊ wiÍkszπ liczbÍ instrukcji, trzeba je wpisaÊ miÍdzy s≥owami begin
i end. W przypadku wywo≥ania jednej funkcji, procedury lub wpisania jednej instruk-
cji, s≥owa begin i end moøna pominπÊ.

Oto konstrukcja instrukcji warunkowych:

if (warunek) then

// Wykonanie funkcji w momencie spe≥nienia warunku

funkcja;

lub:

if (warunek) then

// Wykonanie funkcji i procedury w momencie spe≥nienia warunku

begin

funkcja;

procedura;

instrukcje;

end;

lub:

if (warunek) then

// Wykonanie funkcji w momencie spe≥nienia warunku

funkcja

else

// Wykonanie funkcji w momencie spe≥nienia drugiego warunku

funkcja2;

Elementy Pascala

lub:

if (warunek) then

begin

funkcja;

procedura;

instrukcje;

end

else

begin

funkcja;

procedura;

instrukcje;

end;

Przyk≥ad 1:

if (okSave = TRUE) then savZapisz(‘nazwa’);

Warunek ten powoduje zapisanie pliku, gdy zmienna ëokSaveí bÍdzie prawdziwa
(czyli bÍdzie mia≥a wartoúÊ True).

Przyk≥ad 2:

if (okSave = TRUE) then

savZapisz(‘nazwa’)

// NastÍpuje zapisanie w momencie spe≥nienia warunku

else

Close;

// NastÍpuje zamkniÍcie w przypadku spe≥nienia drugiego warunku

3.6.

Instrukcja wiπøπca with...do

Instrukcja wiπøπca jest przydatna w momencie wywo≥ywania kilku w≥aúciwoúci

komponentu. Ta konstrukcja zwalnia programistÍ z ciπg≥ego wypisywania nazwy
komponentu w momencie wywo≥ania w≥aúciwoúci danego komponentu.

Przyk≥ad bez uøycia instrukcji wiπøπcej with:

Memo1.ReadOnly:= TRUE;

Memo1.TabStop:= FALSE;

Memo1.ScrollBars:= ssNone;

Memo1.Color:= clBtnFace;

Memo1.Lines.Clear;

Przyk≥ad z uøyciem instrukcji wiπøπcej with:

with Memo1 do

begin

ReadOnly:= TRUE;

TabStop:= FALSE;

ScrollBars:= ssNone;

∆wiczenia z podstawowych komponentÛw Delphi

Color:= clBtnFace;

Lines.Clear;L

Lines.Add('');

end;

Z powyøszych przyk≥adÛw widaÊ, øe bardziej efektywnym rozwiπzaniem jest

uøycie konstrukcji wiπøπcej with...do.

3.7.

PÍtle for...to/downto...do, while...do, repeatÖuntil

Instrukcje for..to/downto...do, while...do, repeat...until umoøliwiajπ wykonanie

instrukcji w sposÛb cykliczny, tzn. z gÛry okreúlonπ liczbÍ razy.

Do zatrzymania wykonywanej pÍtli s≥uøy instrukcja break powodujπca zakoÒ-

czenie wykonywanej pÍtli, w ktÛrej zosta≥a wywo≥ana.
N for...to...do ñ wykonuje blok instrukcji okreúlonπ liczbÍ razy np. zwiÍkszajπc

zmiennπ TT z wartoúci 0 do wartoúci 10.

for TT:= 0 to 10 do

Sum:= Sum+1;

lub:

for TT:= 0 to 10 do

begin

Instrukcja 1;

Instrukcja 2;

……………;

Instrukcja N;

end;

N forÖdowntoÖdo ñ wykonuje blok instrukcji okreúlonπ liczbÍ razy np. zmniej-

szajπc zmiennπ TT z wartoúci 10 do wartoúci 0.

for TT:= 10 downto 0 do

Sum:= Sum+1;

lub:

for TT:= 10 downto 0 do

begin

Instrukcja 1;

Instrukcja 2;

……………;

Instrukcja N;

end;

N while...do ñ wykonuje blok instrukcji tak d≥ugo, jak d≥ugo pozostaje spe≥niony

warunek. Warunek ten jest sprawdzany na poczπtku pÍtli przy kaødym cyklu.
W przypadku nie spe≥nienia warunku, wykonywanie pÍtli jest zatrzymane. Moøe

Elementy Pascala

siÍ zdarzyÊ, øe pÍtla nie zostanie wykonana ani razu, poniewaø warunek, ktÛry
jest sprawdzany na poczπtku przed wykonaniem pÍtli nie zosta≥ spe≥niony.

while (warunek) do

instrukcja;

lub:

while (warunek) do

begin

Instrukcja 1;

Instrukcja 2;

……………;

Instrukcja N;

end;

N repeat...until ñ wykonuje blok instrukcji do czasu, gdy zostanie spe≥niony waru-

nek. Warunek ten jest sprawdzany na koÒcu kaødego cyklu. Sprawdzenie warun-
ku na koÒcu cyklu powoduje wykonanie pÍtli przynajmniej jeden raz.

repeat

Instrukcja 1;

Instrukcja 2;

……………;

Instrukcja N;

until(warunek);

Przyk≥ad znajduje siÍ na dyskietce w katalogu

Delphi\Inne\Petle

3.8.

Mechanizmy obs≥ugi wyjπtku

N try...except...end ñ mechanizm obs≥ugi wyjπtku jest bardzo wygodnym narzÍ-

dziem, poniewaø pozwala na wychwycenie sytuacji wyjπtkowych (np. dzielenia
przez zero). DziÍki niemu program jest bardziej stabilny. Mechanizm wyjπtku
dzia≥a tylko w przypadkach wystπpienia b≥Ídu.

UWAGA: Program z mechanizmem obs≥ugi b≥ÍdÛw naleøy uruchomiÊ poza úro-
dowiskiem Delphi, w przeciwnym razie obs≥uga b≥Ídu bÍdzie przechwycona
przez Delphi.

Konstrukcja:

try

...

instrukcje mogące spowodować błąd

...

except

...

instrukcje wykonywane po wystąpieniu błędu

...

end;

∆wiczenia z podstawowych komponentÛw Delphi

Przyk≥ad znajduje siÍ na dyskietce w katalogu

Delphi\Inne\Try_ex

N try...finally...end ñ mechanizm zwalniania zasobÛw gwarantuje zwolnienie zaso-

bÛw (np. plik, pamiÍÊ dynamiczna, zasoby systemowe i obiekty) w przypadku
wystπpienia b≥Ídu. Instrukcje zawarte w bloku zwalniania zasobÛw sπ wykony-
wane zawsze.

Konstrukcja:

try

...

instrukcje korzystające z zasobów, mogące spowodować błąd

...

finally

...

zwalnianie zasobów (instrukcje tu zawarte wykonywane są zawsze).

...

end;

Przyk≥ad znajduje siÍ na dyskietce w katalogu

Delphi\Inne\Try_fi

3.9. Opis wybranych zdarzeÒ

Opisane niøej zdarzenia dotyczπ formatki, mimo øe niektÛre z nich wystÍpujπ

w rÛønych komponentach. Zdarzenia te powodujπ wykonanie pewnych instrukcji po
zajúciu okreúlonego zdarzenia wykonanego w tym przypadku na formatce. Opis
zdarzeÒ we w≥aúciwoúciach jest trochÍ inny niø wewnπtrz kodu, np. OnCreate (na liú-
cie w oknie Object Inspector) jest rÛwnoznaczne z nazwπ FormCreate (wewnπtrz
kodu) ñ odnosi siÍ to do nazw wszystkich zdarzeÒ. SposÛb generowania zdarzeÒ
opisany jest w podrozdziale 1.3.

procedure TForm1.FormActivate(Sender: TObject);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie gdy formatka jest aktywna.

end;

procedure TForm1.FormClick(Sender: TObject);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie gdy kliknie siÍ na formatce.

end;

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie zamykania formatki.

end;

Elementy Pascala

procedure TForm1.FormCloseQuery(Sender: TObject; var CanClose: Boolean);

begin

{

Tu wpisujemy instrukcje, ktÛre majπ na celu zapytanie uøytkownika

momencie zamykania formatki np. wywo≥anie dialogu z pytaniem.

}

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane przed utworzeniem okna formatki.

end;

procedure TForm1.FormDblClick(Sender: TObject);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie

// dwukrotnego klikniÍcia na formatce.

end;

procedure TForm1.FormDeactivate(Sender: TObject);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie,

// gdy formatka przestaje byÊ aktywna.

end;

procedure TForm1.FormDestroy(Sender: TObject);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie likwidacji formatki.

end;

procedure TForm1.FormKeyDown(Sender: TObject; var Key: Word;

Shift: TShiftState);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie

// naciúniÍcia klawiszy funkcyjnych np. Enter, F1..F12, PageUp itp.

end;

procedure TForm1.FormKeyPress(Sender: TObject; var Key: Char);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie naciúniÍcia

// dowolnego lub wybranego klawisza alfanumerycznego np. a, b, <, > itp.

end;

procedure TForm1.FormResize(Sender: TObject);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie

// zwiÍkszania lub zmniejszania rozmiarÛw formatki.

end;

procedure TForm1.FormShow(Sender: TObject);

begin

// Tu wpisujemy instrukcje, ktÛre sπ wykonywane w momencie ukazania siÍ formatki.

end;

∆wiczenia z podstawowych komponentÛw Delphi

procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X,

Y: Integer);

begin

// Tu wpisujemy instrukcje, ktÛre wykonywane sπ w momencie poruszania kursorem myszy.

end;

procedure TForm1.FormPaint(Sender: TObject);

begin

{

Tu wpisujemy instrukcje odpowiedzialne za odúwieøenie zawartoúci

formatki w przypadku zas≥oniÍcia tej formatki przez innπ formatkÍ.

}

end;

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Opis

3.10. Nazwa aplikacji (programu)

Nazwa aplikacji wyúwietlana na pasku zadaÒ jest pobierana z nazwy pliku. W ce-

lu jej zmiany naleøy napisaÊ Application.Title:= 'MÛj pierwszy program'; pomiÍdzy
s≥owami kluczowymi begin i end, w zdarzeniu OnCreate lub OnShow. Aby zdarze-
nie to zosta≥o wygenerowane przez Delphi naleøy dwukrotnie kliknπÊ formatkÍ lub
wybraÊ np. zdarzenie OnCreate przez dwukrotne szybkie klikniÍcie karty Events
w oknie Object Inspector. W wygenerowanej procedurze, ktÛra jest wywo≥ywana
w momencie uruchamiania programu wpisujemy Application.Title:= 'MÛj pierwszy
program';. Poniøej jest zamieszczony przyk≥ad.

procedure TForm1.FormCreate(Sender: TObject);

begin

Application.Title:= 'Mój pierwszy program';

end;

Od tej chwili na pasku zdaÒ bÍdzie siÍ ukazywa≥a nazwa ÑMÛj pierwszy programî.

W celu zamiany ikony programu naleøy wykonaÊ nastÍpujπce czynnoúci:

Wybierz polecenie Options (Opcje) z menu Project (Projekt).

W oknie Project options (Opcje projektu) wybierz kartÍ Application (Aplika-
cja) ñ rysunek 3.10.1.

Wybierz przycisk z napisem Load Icon (Za≥aduj ikonÍ) i w ukazanym oknie
wybierz ikonÍ.

Ostatni krok polega na zatwierdzeniu wyboru przez wybranie przycisku OK.

Elementy Pascala

Rysunek 3.10.1.

3.11. Lista wybranych zmiennych globalnych

Poniøej znajduje siÍ opis wybranych zmiennych globalnych, ktÛre sπ dostÍpne

w ca≥ym programie utworzonym w úrodowisku Delphi.

Do tych zmiennych wpisywane sπ wartoúci, pobrane z systemu w momencie uru-

chomienia programu. Wartoúci te moøna zmieniaÊ, bez wp≥ywu na zmiany ustawieÒ
w systemie. Zmienne te u≥atwiajπ bardzo prace programisty, zwalniajπc go ze ømud-
nego dostosowywania programu do rÛønych ustawieÒ systemu.
N DateSeparator ñ umoøliwia przypisanie lub odczyt znaku uøywanego w zapisie

daty do oddzielenia roku, miesiπca, dnia (np. DateSeparator:= ë-ë ñ od tego mo-
mentu znakiem rozdzielajπcym datÍ jest znak minus);

N TimeSeparator ñ umoøliwia przypisanie lub odczyt znaku uøywanego w zapisie

czasu do oddzielenia godzin, minut, sekund (np. TimeSeparator:= ë:ë ñ od tego
momentu znakiem rozdzielajπcym czas jest znak dwukropka);

N DecimalSeparator ñ umoøliwia przypisanie lub odczyt znaku uøywanego

w zapisie liczbowym do oddzielenia liczby ca≥kowitej i jej czÍúci dziesiÍtnej (np.
DecimalSeparator:= ë.ë ñ od tego momentu znakiem rozdzielajπcym liczbÍ ca≥-
kowitπ od jej dziesiÍtnej czÍúci jest kropka).

UWAGA: W jÍzykach programowania m.in. w Delphi uøywa siÍ kropki zamiast
przecinka w celu oddzielenia w liczbie rzeczywistej czÍúci ca≥kowitej od czÍúci

∆wiczenia z podstawowych komponentÛw Delphi

dziesiÍtnej. Gdy uøyjemy przecinka, program ze wzglÍdu na b≥πd nie zostanie
prawid≥owo uruchomiony (np. 12,34 ñ jest zapisem b≥Ídnym, 12.34 to zapis po-
prawny);

N ShortMonthNames ñ Tablica znakÛw zawierajπca skrÛcone nazwy miesiπca

(np. Caption:= ShortMonthNames[1]; ñ zwrÛci nam skrÛconπ nazwÍ pierwszego
miesiπca);

N LongMonthNames ñ Tablica znakÛw zawierajπca pe≥ne nazwy miesiπca (np.

Caption:= LongMonthNames[2]; ñ zwrÛci nam pe≥nπ nazwÍ drugiego miesiπca);

N ShortDayNames ñ Tablica znakÛw zawierajπca skrÛcone nazwy dnia (np. Cap-

tion:= ShortDayNames[1]; ñ zwrÛci nam skrÛconπ nazwÍ pierwszego dnia);

N LongDayNames ñ Tablica znakÛw zawierajπca pe≥ne nazwy dnia (np. Caption:=

LongDayNames[2]; ñ zwrÛci nam pe≥nπ nazwÍ drugiego dnia).

Przyk≥ad zastosowania wyøej wymienionych zmiennych:

procedure TForm1.FormCreate(Sender: TObject);

begin

// FormCreate

// Znak uøywany do oddzielenia roku, miesiπca, dnia.

DateSeparator:= '-';

// Znak uøywany do oddzielenia liczby ca≥kowitej od jej czÍúci dziesiÍtnej.

DecimalSeparator:= '.';

// Zwraca skrÛconπ nazwÍ pierwszego miesiπca.

Label1.Caption:= ShortMonthNames[1];

// Zwraca pe≥nπ nazwÍ drugiego miesiπca.

Label2.Caption:= LongMonthNames[2];

// Zwraca skrÛconπ nazwÍ pierwszego dnia.

Label3.Caption:= ShortDayNames[1];

// Zwraca pe≥nπ nazwÍ drugiego dnia.

Label4.Caption:= LongDayNames[2];

end;

3.12. Operatory logiczne i relacji

Poniøej przedstawione sπ operatory wraz z przyk≥adem ilustrujπcym zastosowanie
kaødego z nich.

Elementy Pascala

Operator

Wyglπd

RÛwnoúÊ

NierÛwnoúÊ

Mniejsze

WiÍksze

WiÍksze lub rÛwne

Mniejsze lub rÛwne

Koniunkcja (i logiczne)

and

Alternatywa (lub logiczne )

Negacja

not

Przyk≥ad rÛwnoúci:

if (Numer = 5) then WykonajZadanie

Jeøeli zmienna o nazwie ÑNumerî jest rÛwna liczbie 5 to wykonaj funkcjÍ/instrukcjÍ
po s≥owie THEN.

Przyk≥ad nierÛwnoúci:

if (Numer <> 5) then WykonajZadanie

Jeøeli zmienna o nazwie ÑNumerî jest rÛøna od liczby 5 to wykonaj funkcjÍ/instrukcjÍ
po s≥owie THEN.

Przyk≥ad wiÍksze lub rÛwne:

if (Numer >= 5) then WykonajZadanie

Jeøeli zmienna o nazwie ÑNumerî jest wiÍksza od liczby 5 lub rÛwna liczbie 5 to
wykonaj funkcjÍ/instrukcjÍ po s≥owie THEN.

Przyk≥ad zastosowania operatora AND:

if (warunek1) and (warunek2) then WykonajZadanie

Jeøeli bÍdzie spe≥niony Warunek1 i Warunek2 to wykonaj funkcjÍ/instrukcjÍ po s≥o-
wie THEN.

Przyk≥ad zastosowania operatora OR:

if (warunek1) or (warunek2) then WykonajZadanie

Jeøeli bÍdzie spe≥niony Warunek1 lub Warunek2 to wykonaj funkcjÍ/instrukcjÍ po
s≥owie THEN.

∆wiczenia z podstawowych komponentÛw Delphi

Przyk≥ad zastosowania operatora NOT:

while not Warunek do
begin

WykonajZadanie;

end;

Instrukcja pomiÍdzy s≥owem Begin i End jest wykonana w momencie spe≥nienia
Warunku postawionego na samym poczπtku pÍtli.

Pierwszy program

Pierwszy program jaki napiszemy bÍdzie wyúwietla≥ s≥owa ÑDzieÒ dobryî oraz

s≥owa ÑDo widzeniaî w momencie klikniÍcia na napis ÑDzieÒ dobryî.

W celu napisania pierwszego programu naleøy uruchomiÊ Delphi i wykonaÊ na-

stÍpujπce czynnoúci:

Wybierz komponent Label

z palety komponentÛw Standard (rysunek 4.1).

Rysunek 4.1.

NastÍpnie umieúÊ ten komponent na formatce (rysunek 4.2).

Rysunek 4.2.

W oknie Object Inspector wybierz w≥aúciwoúÊ Caption na karcie Properties,
w ktÛrej wpisz s≥owa ÑDzieÒ dobryî (rysunek 4.3).

NastÍpnie kliknij dwukrotnie komponent Label znajdujπcy siÍ na formatce lub
wybierz kartÍ Events i kliknij zdarzenie OnClick (rysunek 4.4).

W ostatnim kroku wpisz wiersz

Label1.Caption:= 'Do widzenia';

w wyge-

nerowanej przez program procedurze Label1Click (rysunek 4.5).

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 4.3.

Rysunek 4.4.

Rysunek 4.5.

Po tych krokach naciúnij klawisz F9 lub wybierz opcjÍ Run z menu Run w celu
skompilowania i uruchomienia programu (rysunek 4.6).

Rysunek 4.6.

Pierwszy program

Jeøeli chcesz uruchomiÊ program poza úrodowiskiem Delphi to wystarczy go

skompilowaÊ za pomocπ opcji Compile (Kompiluj) lub Build All (Kompiluj wszyst-
ko) z menu Project (Projekt) ñ rysunek 4.7.

Rysunek 4.7.

Opisany przyk≥ad znajduje siÍ w katalogu

Delphi\Pierwszy

∆wiczenia z rozwiπzaniami

∆wiczenie 5.1. ComboBox

UtwÛrz listÍ za pomocπ komponentu ComboBox z moøliwoúciπ dodania (bez moøliwo-
úci dodania dwÛch takich samych elementÛw) i usuniÍcia elementu z listy. Wyglπd
programu ilustruje rysunek 5.1.1.

Rysunek 5.1.1.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\ComboBox

Opis komponentu:

ComboBox znajduje siÍ na karcie Standard palety komponentÛw. Jest to lista
rozwijana, po≥πczona z edytorem. RozwiniÍcie tej listy nastÍpuje po klikniÍciu

na strza≥kÍ skierowanπ w dÛ≥ (znajduje siÍ ona z prawej strony edytora) lub naciúniÍ-
ciu kombinacji klawiszy Alt+Strza≥ka w dÛ≥. Wybranie elementu z listy powoduje
umieszczenie tego elementu w oknie edycyjnym przy jednoczesnym zamkniÍciu listy.

SposÛb wykonania:

Wybierz komponent Label

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

NastÍpnie wybierz okno Object Inspector po zaznaczeniu komponentu Label
lub naciúnij klawisz funkcyjny F11. Na karcie Properties wybierz w≥aúciwoúÊ
Caption i wpisz ÑLista z edytoremî.

Wybierz komponent ComboBox

z palety komponentÛw (karta Standard).

Wybierz komponent SpeedButton

z palety komponentÛw (karta Additional)

i umieúÊ go tuø z prawej strony komponentu ComboBox.

Wybierz komponent SpeedButton

i umieúÊ go tuø z prawej strony kompo-

nentu SpeedButton.

∆wiczenia z rozwiπzaniami

NastÍpnie majπc zaznaczony komponent SpeedButton (ten bliøej komponentu
ComboBox) wybierz okno Object Inspector i we w≥aúciwoúci Caption wpisz
Ñ+î. Potem wybierz w≥aúciwoúÊ Hint i wpisz ÑDodaj do listyî i na koniec wy-
bierz w≥aúciwoúÊ ShowHint i nadaj jej wartoúÊ True (True ñ pokazuje podpo-
wiedzi).

Z drugim komponentem SpeedButton postÍpuj tak samo jak z pierwszym, z tπ
rÛønicπ, øe we w≥aúciwoúci Caption wpisz Ñ-î, a we w≥aúciwoúci Hint wpisz
ÑUsuÒ z listyî.

Kliknij dwukrotnie formatkÍ, co spowoduje wygenerowanie zdarzenia OnCreate.
W tym zdarzeniu wpisz nastÍpujπcy fragment kodu:

procedure TForm1.FormCreate(Sender: TObject);

begin

ComboBox1.Items.Clear;

// Czyszczenie zawartoúci listy.

ComboBox1.Text:= '';

// Wyczyszczenie zawartoúci edytora.

// Wczytanie listy z pliku.

if (FileExists('Lista.txt') = TRUE) then

// Sprawdzenie czy istnieje plik na dysku.

ComboBox1.Items.LoadFromFile('Lista.txt');

// Odczytanie listy z pliku.

end;

NastÍpnie napisz funkcjÍ, ktÛra sprawdzi czy nie prÛbujesz dodaÊ dwÛch takich
samych elementÛw:

function TForm1.ComboBoxVerify: Boolean;

var

TT :Integer;

// Deklaracja zmiennej

begin

{

Funkcja sprawdza, czy wpisany napis w edytorze znajduje siÍ w liúcie.

Jeøeli wpisany napis jest w liúcie to funkcja zwrÛci wartoúÊ TRUE (Prawda),

w innym przypadku funkcja zwrÛci FALSE (Fa≥sz).

}

ComboBoxVerify:= FALSE;

for TT:= 0 to ComboBox1.Items.Count-1 do

if (AnsiUpperCase(Trim(ComboBox1.Text)) =

AnsiUpperCase(Trim(ComboBox1.Items[TT]))) then ComboBoxVerify:= TRUE;

// AnsiUpperCase() ñ Zamiana znakÛw dowolnej wielkoúci na duøe, bez

// wzglÍdu na jÍzyk.

// Trim() ñ Likwiduje spacje po lewej i prawej stronie ciπgu znakÛw.

end;

W kolejnym kroku umieúÊ deklaracjÍ tej funkcji (metody) w typie obiektowym.

type

TForm1 = class(TForm)

function ComboBoxVerify: Boolean;

// Deklaracja funkcji sprawdzajπcej

procedure FormCreate(Sender: TObject);

private

end;

∆wiczenia z podstawowych komponentÛw Delphi

Kliknij dwukrotnie przycisk + co spowoduje wygenerowanie procedury, a miÍ-
dzy s≥owami begin i end wpisz kod obs≥ugujπcy dodanie elementu do listy:

procedure TForm1.sbDodajClick(Sender: TObject);

begin

// Dodaj do listy

if (ComboBoxVerify = FALSE) and (Trim(ComboBox1.Text)<>'') then

begin

{

Dodanie do listy nastπpi w momencie, gdy edytor listy nie

bÍdzie pusty i napisany ciπg znakÛw nie bÍdzie wystÍpowa≥ w liúcie.

Jest to warunek, ktÛry jest sprawdzany za pomocπ instrukcji If...Then.

}

ComboBox1.Items.Add(ComboBox1.Text);

// Dodanie nowego elementu do listy.

ComboBox1.Sorted:= TRUE;

// W≥πczenie sortowania listy.

ComboBox1.Items.SaveToFile('Lista.txt');

// Zapisanie listy do pliku.

end;

ComboBox1.SelectAll;

// Zaznaczenie ciπgu znakÛw w edytorze.

ComboBox1.SetFocus;

// Ustawienie listy z edytorem jako aktywny.

end;

Majπc zaznaczony komponent ComboBox wybierz okno Object Inspector, a na
karcie Events wybierz zdarzenie OnKeyDown, co spowoduje wygenerowanie
procedury. MiÍdzy s≥owami begin i end wygenerowanej procedury wpisz kod
obs≥ugi klawisza Enter:

procedure TForm1.ComboBox1KeyDown(Sender: TObject; var Key: Word;

Shift: TShiftState);

begin

// Wprowadzenie nowego ciπgu znakÛw do listy przez naciúniÍcie klawisza ENTER.

if (Key = VK_RETURN) then

begin

// Wywo≥anie funkcji umoøliwiajπcej dodanie nowego ciπgu

znaków.

sbDodajClick(Sender);

end;

Kaøde naciúniÍcie klawisza Enter lub przycisku z + spowoduje dodanie elementu
do listy.

Wybierz przycisk z napisem Ñ-î i kliknij go dwukrotnie, co spowoduje wygene-
rowanie procedury usuwania. MiÍdzy s≥owami begin i end umieúÊ kod odpowie-
dzialny za usuwanie elementÛw z listy:

procedure TForm1.sbUsunClick(Sender: TObject);

var

numBtn: Integer;

begin

// UsuniÍcie wybranego elementu z listy.

// Application.MessageBox ñ wywo≥anie okna dialogowego.

numBtn:= Application.MessageBox('Czy usunąć ten element z listy ?',

∆wiczenia z rozwiπzaniami

PChar(Label1.Caption), MB_ICONQUESTION or MB_YESNO);

if (numBtn = IDYES) then

begin

// UsuniÍcie zaznaczonego elementu z listy.

ComboBox1.Items.Delete(ComboBox1.ItemIndex);

ComboBox1.Items.SaveToFile('Lista.txt');

// Zapisanie listy do pliku.

ComboBox1.Text:= '';

// Wyczyszczenie zawartoúci edytora.

ComboBox1.SetFocus;

// Ustawienie listy z edytorem jako aktywny.

end;

∆wiczenie 5.2. Edit, BitBtn

Napisz program, ktÛrego zadaniem bÍdzie uaktywnienie przycisku w momencie wpro-
wadzenia tekstu. W innym przypadku przycisk ma byÊ nieaktywny. Rysunek 5.2.1
przedstawia wyglπd takiego programu.

Rysunek 5.2.1.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Edit

Opis komponentÛw:

Edit to komponent, ktÛry znajduje siÍ na karcie Standard palety komponen-
tÛw. Umoøliwia on wprowadzanie tekstu w utworzonej przez nas aplikacji.

BitBtn jest komponentem, ktÛry znajduje siÍ na karcie Additional palety kom-
ponentÛw. S≥uøy on do uruchomienia jakiegoú zadania w wyniku naciúniÍcia

tego przycisku. Komponent ten ma w≥aúciwoúci komponentu Button.

SposÛb wykonania:

Wybierz komponent Label

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Po zaznaczeniu tego komponentu w oknie Object Inspector we w≥aúciwoúci
Caption wpisz ÑWprowadü tekstî.

Wybierz komponent Edit

z palety komponentÛw (karta Standard).

Wybierz komponent BitBtn

(karta Additional) i umieúÊ go na formatce obok

komponentu Edit z prawej strony.

∆wiczenia z podstawowych komponentÛw Delphi

Kliknij dwukrotnie formatkÍ w celu wygenerowania zdarzenia OnCreate. Na-
stÍpnie miÍdzy s≥owami begin i end wpisz kod, ktÛry czyúci zawartoúÊ kompo-
nentu Edit:

procedure TForm1.FormCreate(Sender: TObject);

begin

// FormCreate

Edit1.Text:= '';

// Wyczyszczenie zawartoúci komponentu Edit

Edit1Change(Sender);

// Ponowne wykorzystanie zdarzenia Edit1Change

end;

Wybierz komponent Edit znajdujπcy siÍ na formatce i kliknij go dwukrotnie, co
spowoduje wygenerowanie zdarzenia OnChange. MiÍdzy s≥owami begin i end
umieúÊ kod kontrolujπcy aktywnoúÊ przycisku BitBtn:

procedure TForm1.Edit1Change(Sender: TObject);

begin

// Aktywacja i dezaktywacja przycisku

BitBtn1.Enabled:= FALSE;

// Wy≥πczenie moøliwoúci naciúniÍcia przycisku.

if (Length(Trim(Edit1.Text)) > 0) then

begin

{

W≥πczenie moøliwoúci naciúniÍcia

przycisku, jeøeli jest wpisany przynajmniej jeden znak.

}

BitBtn1.Enabled:= TRUE;

end;

Wybierz komponent BitBtn znajdujπcy siÍ na formatce i kliknij go dwukrotnie,
co spowoduje wygenerowanie zdarzenia OnClick. W wygenerowanym zdarze-
niu wpisz kod odpowiedzialny za wyúwietlenie wprowadzonego tekstu kompo-
nentu Edit na pasku tytu≥owym:

procedure TForm1.BitBtn1Click(Sender: TObject);

begin

Caption:= Edit1.Text;

// Wyúwietlenie w pasku tytu≥owym zawartoúci komponentu Edit.

end;

∆wiczenie 5.3. Label

Napisz program wykorzystujπc komponent Label do uruchomienia przeglπdarki inter-
netowej i poczty elektronicznej. Rysunek 5.3.1 przedstawia wyglπd programu.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Label

∆wiczenia z rozwiπzaniami

Rysunek 5.3.1.

Opis komponentu:

Label jest komponentem s≥uøπcym do wyúwietlania tekstu. Znajduje siÍ on na
karcie Standard palety komponentÛw.

SposÛb wykonania:

Wpisz nazwÍ biblioteki ShellApi w deklaracji Uses, np. Ñuses ShellApiî (bez tej
deklaracji funkcja ShellExecute nie bÍdzie dzia≥aÊ).

Wybierz komponenty Label

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Standard) i umieúÊ je na formatce jeden pod drugim.

Kliknij dwukrotnie formatkÍ w celu wygenerowania zdarzenia OnCreate. MiÍ-
dzy s≥owami begin i end wpisz kod odpowiedzialny za ustawienie w≥asnoúci
komponentÛw Label:

procedure TfrmForm1.FormCreate(Sender: TObject);

begin

// Ustawienie w≥asnoúci komponentu Label1 i Label2

//-- Strona WWW --

// Zamiana kursora myszki na rπczkÍ w momencie najechania myszπ

// na komponent LABEL

Label1.Cursor:= crHandPoint;

Label1.Font.Color:= clBlue;

// Ustawienie koloru czcionki na kolor niebieski.

Label1.Font.Style:= [fsUnderline];

// Ustawienie podkreúlenia pod napisem.

Label1.Caption:= 'http://www.pan.pl';

// Wpisanie adresu strony WWW.

//-- Poczta --

// Zamiana kursora myszki na rπczkÍ w momencie najechania

// myszπ na komponent LABEL

Label2.Cursor:= crHandPoint;

Label2.Font.Color:= clBlue;

// Ustawienie koloru czcionek na kolor niebieski.

Label2.Font.Style:= [fsUnderline];

// Ustawienie podkreúlenia pod napisem.

Label2.Caption:= 'uzytkownik@serwer.domena';

// Wpisanie adresu poczty.

end;

NastÍpnie kliknij dwukrotnie komponent Label1 w celu wygenerowania zdarze-
nia OnClick i wpisz kod odpowiedzialny za uruchomienie przeglπdarki interne-
towej:

∆wiczenia z podstawowych komponentÛw Delphi

procedure TfrmForm1.Label1Click(Sender: TObject);

begin

// Uruchomienie przeglπdarki WWW.

ShellExecute(GetDesktopWindow, 'open', PChar(Label1.Caption),

nil, nil, SW_SHOWNORMAL);

end;

Tak samo postÍpuj w przypadku komponentu Label2 i wpisz kod odpowiedzial-
ny za uruchomienie programu do obs≥ugi poczty elektronicznej:

procedure TfrmForm1.Label2Click(Sender: TObject);

begin

// Uruchomienie programu do obs≥ugi poczty elektronicznej.

ShellExecute(GetDesktopWindow, 'open', PChar('mailto:'+Label2.Caption),

nil, nil, SW_SHOWNORMAL);

end;

∆wiczenie 5.4. Komponent ListBox

∆wiczenie 5.4.1.

Napisz program, ktÛry bÍdzie wczytywa≥ i zapisywa≥ listÍ, zaznacza≥ i odznacza≥ ele-
menty listy oraz dodawa≥ elementy do listy. Rysunek 5.4.1 przedstawia wyglπd progra-
mu.

Rysunek 5.4.1.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\ListBox\LBox1

Opis komponentu:

ListBox jest komponentem s≥uøπcym do wyúwietlania listy elementÛw. Ele-
menty listy mogπ byÊ posortowane. Niestety elementÛw listy nie moøna edyto-

waÊ. WybÛr wiÍkszej iloúci elementÛw dokonuje siÍ trzymajπc klawisz Shift lub Ctrl,

∆wiczenia z rozwiπzaniami

co umoøliwia zaznaczenie kilku elementÛw oddzielonych od siebie. Znajduje siÍ on na
karcie Standard palety komponentÛw.

SposÛb wykonania:

Wybierz komponent ListBox

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Standard).

Wybierz komponent Edit

(karta Standard).

Wybierz kilka przyciskÛw Button

(karta Standard) i opisz je zgodnie z ry-

sunkiem 5.4.1.

Kliknij dwukrotnie formatkÍ i wpisz w wygenerowanym zdarzeniu OnCreate
kod programu, ktÛry czyúci zawartoúÊ listy i komponent Edit:

procedure TfrmMain.FormCreate(Sender: TObject);

begin

ListBox1.Items.Clear;

// Wyczyszczenie zawartoúci komponentu ListBox

Edit1.Text:= '';

// Czyúci zawartoúÊ komponentu Edit.

end;

Wybierz przycisk Dodaj i kliknij go dwukrotnie w celu wygenerowania zdarzenia
OnClick, w ktÛrym wpiszesz kod odpowiedzialny za dodanie elementu do listy:

procedure TfrmMain.bDodajClick(Sender: TObject);

begin

// Dodaj

ListBox1.Items.Clear;

// Czyúci zawartoúÊ komponentu ListBox

ListBox1.Items.Add('Spectrum');

// Dodaje pozycjÍ do komponentu ListBox

ListBox1.Items.Add('Amiga');

ListBox1.Items.Add('IBM');

ListBox1.Items.Add('Atari');

ListBox1.Items.Add('Żyrafa');

ListBox1.Items.Add('Cry');

ListBox1.Items.Add('CPU');

ListBox1.Items.Add('Komputer');

ListBox1.Sorted:= TRUE;

// Sortuje pozycje w komponencie ListBox

end;

Kliknij dwukrotnie przycisk Wczytaj z pliku i w zdarzeniu OnClick wpisz kod
odpowiedzialny za wczytanie listy z pliku:

procedure TfrmMain.bWczytajPlikClick(Sender: TObject);

begin

// Wczytaj z pliku

ListBox1.Items.Clear;

// Czyúci zawartoúÊ komponentu ListBox

if (FileExists(Trim('Lista.txt'))=TRUE) then

∆wiczenia z podstawowych komponentÛw Delphi

begin

ListBox1.Items.LoadFromFile(Trim('Lista.txt'));

// Wczytuje listÍ z pliku.

ListBox1.Sorted:= TRUE;

// Sortuje pozycje w komponencie ListBox

end;

{

if (FileExists(Trim('Lista.txt'))=TRUE) then

begin

end;

Funkcja ta sprawdza, czy na dysku istnieje plik

o nazwie "Lista.txt", jeøeli istnieje, to go wczytuje,

w przeciwnym przypadku nie wykonuje nic.

}

end;

Kliknij dwukrotnie przycisk Zaznacz/Odznacz wszystko i w wygenerowanej
procedurze wpisz kod:

procedure TfrmMain.bZaznaczOdznaczWszystkoClick(Sender: TObject);

var

TT: Integer;

begin

// Zaznacza/Odznacza wszystko

ListBox1.MultiSelect:= TRUE;

// W≥πcza moøliwoúÊ zaznaczania wiÍcej niø jednej pozycji.

for TT:= 0 to ListBox1.Items.Count-1 do

if (ListBox1.Selected[TT] = TRUE) then

begin

ListBox1.Selected[TT]:= FALSE;

{

ListBox1.Selected[TT]:= FALSE;

Odznacza pozycjÍ o podanym numerze, ktÛry znajduje siÍ pod zmiennπ "TT",

jeøeli by≥ zaznaczony.

}

end

else

begin

ListBox1.Selected[TT]:= TRUE;

{

ListBox1.Selected[TT]:= FALSE;

Zaznacza pozycjÍ o podanym numerze, ktÛry znajduje siÍ pod zmiennπ "TT",

jeøeli by≥ odznaczony.

}

end;

Kliknij dwukrotnie przycisk Zapisz do pliku i w wygenerowanej procedurze
wpisz kod:

procedure TfrmMain.bZapiszDoPlikuClick(Sender: TObject);

begin

// Zapisz do pliku

ListBox1.Items.SaveToFile('Lista2.txt');

end;

∆wiczenia z rozwiπzaniami

Kliknij dwukrotnie przycisk Zapisz do pliku i w wygenerowanej procedurze
wpisz kod:

procedure TfrmMain.bDodajZawartoscEditaClick(Sender: TObject);

begin

// Dodaj zawartoúÊ Edit'a do ListBox'u

{

W momencie spe≥nienia warunku, tzn. gdy komponent Edit bÍdzie

zawiera≥ chociaø jeden znak, nastπpi dodanie tego znaku do ListBox'u.

}

if (Trim(Edit1.Text)<>'') then

begin

ListBox1.Items.Add(Trim(Edit1.Text));

// Dodaje pozycjÍ do komponentu ListBox.

ListBox1.Sorted:= TRUE;

// Sortuje pozycje w komponencie ListBox

Edit1.Text:= '';

// Czyúci zawartoúÊ komponentu Edit

end;

Kliknij dwukrotnie przycisk Odznacz wszystko i w wygenerowanej procedurze
wpisz kod:

procedure TfrmMain.bOdznaczWszystkoClick(Sender: TObject);

var

TT: Integer;

begin

// Odznacza wszystko

// W≥πcza moøliwoúÊ zaznaczania wiÍcej niø jednej pozycji w komponencie ListBox

ListBox1.MultiSelect:= TRUE;

// Odznaczenie wszystkich elementÛw

for TT:= 0 to ListBox1.Items.Count-1 do

ListBox1.Selected[TT]:= FALSE;

{

ListBox1.Selected[TT]:= FALSE;

Odznacza pozycjÍ o podanym numerze, ktÛry znajduje siÍ pod zmiennπ "TT".

}

end;

Kliknij dwukrotnie przycisk Zaznacz wszystko i w wygenerowanej procedurze
wpisz kod:

procedure TfrmMain.bZaznaczWszystkoClick(Sender: TObject);

var

TT: Integer;

begin

// Zaznacza wszystko

// W≥πcza moøliwoúÊ zaznaczania wiÍcej niø jednej pozycji w komponencie ListBox

ListBox1.MultiSelect:= TRUE;

// Zaznaczenie wszystkich elementÛw

for TT:= 0 to ListBox1.Items.Count-1 do

ListBox1.Selected[TT]:= TRUE;

// ListBox1.Selected[TT]:= TRUE; ñ Zaznacza pozycjÍ o podanym numerze

end;

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 5.4.2.

Wykonaj program, ktÛrego zadaniem jest znalezienie i zaznaczenie elementu w liúcie
na podstawie pierwszych wprowadzonych liter w komponencie Edit. Wyglπd tego
programu przedstawiony jest na rysunku 5.4.2.

Rysunek 5.4.2.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\ListBox\LBox2

SposÛb wykonania:

Wybierz komponent ListBox

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Standard).

Wybierz komponent Edit

(karta Standard).

Napisz funkcjÍ wyszukujπcπ elementy w liúcie. Przyk≥adowa funkcja ma nastÍ-
pujπcπ postaÊ:

function TfrmMain.AutomatyczneWyszukiwanie(txtSzukaj: String): Shortint;

var

AA, TT, nL: Integer;

txtFind: String;

begin

// Automatyczne wyszukiwanie w ListBox'ie

{

W≥πcza moøliwoúÊ zaznaczania wiÍcej

niø jednej pozycji w komponencie ListBox

}

ListBox1.MultiSelect:= TRUE;

{

W≥πcza sta≥π wielkoúÊ okna,

∆wiczenia z rozwiπzaniami

co przyczynia siÍ do widocznoúci w

dolnej czÍúci okna ca≥ego elementu.

}

ListBox1.IntegralHeight:= TRUE;

// Odznacza wszystkie elementy

for AA:= 0 to ListBox1.Items.Count-1 do

ListBox1.Selected[AA]:= FALSE;

// Odznacza element o wybranym numerze, ktÛry znajduje siÍ w zmiennej TT.

{

Trim(' Jan ') ñ Likwiduje spacje po lewej i prawej stronie znaku.

AnsiUpperCase('Frydek') ñ Zamienia ca≥y wyraz na duøe litery bez wzglÍdu na jÍzyk.

}

txtFind:= '';

txtFind:= AnsiUpperCase(Trim(txtSzukaj));

// Zwraca d≥ugoúÊ tekstu tzn. z ilu liter sk≥ada siÍ wyraz lub zdanie.

nL:= 0;

nL:= Length(txtFind);

{

Jeøeli zmienna 'txtFind' jest pusta to spe≥niony

jest warunek po s≥owie ELSE, w przeciwnym wypadku

spe≥niony jest warunek po s≥owie IF...THEN.

}

if (txtFind<>'') then

begin

{

Jeøeli pierwsze litery zgadzajπ siÍ z

literami zapisanymi w komponencie Edit, to

zaznacz ten element w komponencie ListBox, w

przeciwnym razie zaznacz pierwszy element na liúcie.

}

for TT:= 0 to ListBox1.Items.Count-1 do

begin

if (txtFind = Copy(AnsiUpperCase(Trim(ListBox1.Items[TT])), 1, nL))
then
begin

ListBox1.Selected[TT]:= TRUE;

// zaznacza znaleziony element, ktÛrego numer znajduje siÍ w zmiennej TT.

Break;

// Powoduje zakoÒczenie dzia≥ania i wyjúcie z pÍtli FOR.

end

else

begin

{

Zaznacza pierwszy element na liúcie,

jeøeli nie znaleziono øadnego wyrazu.

}

ListBox1.Selected[0]:= TRUE;

end;

end

else

begin

{

∆wiczenia z podstawowych komponentÛw Delphi

Zaznacza pierwszy element na liúcie,

jeøeli zmienna 'txtFind' jest pusta

}

ListBox1.Selected[0]:= TRUE;

end;

{

Wy≥πcza moøliwoúÊ zaznaczania wiÍcej

niø jednej pozycji w komponencie ListBox

}

ListBox1.MultiSelect:= FALSE;

AutomatyczneWyszukiwanie:= 1;

// ZwrÛcenie wyniku funkcji (1 ñ zadzia≥a≥a).

end;

W kolejnym krokiem umieúÊ deklaracjÍ tej funkcji (metody) w typie obiekto-
wym.

type

TfrmMain = class(TForm)

function AutomatyczneWyszukiwanie(txtSzukaj: String): Shortint;

procedure FormCreate(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

Kliknij dwukrotnie formatkÍ i w wygenerowanej procedurze wpisz kod:

procedure TfrmMain.FormCreate(Sender: TObject);

begin

Edit1.Text:= 'Tu wpisz szukane słowo';

// Wyúwietlenie domyúlnego tekstu.

ListBox1.Items.Clear;

// Czyúci zawartoúÊ komponentu ListBox

ListBox1.Items.Add('Spectrum');

// Dodaje pozycjÍ do komponentu ListBox

ListBox1.Items.Add('Amiga');

ListBox1.Items.Add('IBM');

ListBox1.Items.Add('Atari');

ListBox1.Items.Add('Żyrafa');

ListBox1.Items.Add(' Star Wars');

ListBox1.Items.Add('Cry');

ListBox1.Items.Add('CPU');

ListBox1.Items.Add('Komputer');

end;

Jeøeli chcesz szybko przejúÊ z komponentu Edit do komponentu ListBox za
pomocπ strza≥ek gÛra/dÛ≥ wybierz okno Object Inspector zaznaczajπc uprzednio
komponent Edit. Na karcie Events wybierz zdarzenie OnKeyDown i w wygene-
rowanej procedurze wpisz kod:

procedure TfrmMain.Edit1KeyDown(Sender: TObject; var Key: Word;

Shift: TShiftState);

begin

{

Zdarzenie "onKeyDown" obs≥uguje naciúniÍcie

∆wiczenia z rozwiπzaniami

klawisza funkcyjnego, ktÛry powoduje przejúcie do ListBox'a.

Tym klawiszem funkcyjnym jest "Strza≥ka w DÛ≥".

}

if (Key = VK_DOWN) or (Key = VK_UP) then

begin

// Powoduje uaktywnienie komponentu ListBox.

ListBox1.SetFocus;

end;

Kliknij dwukrotnie komponent Edit i w wygenerowanej procedurze wpisz kod,
ktÛry wywo≥a funkcjÍ do przeszukiwania listy:

procedure TfrmMain.Edit1Change(Sender: TObject);

begin

{

Zdarzenie onChange powoduje automatyczne

wykonywanie instrukcji(rozkazÛw) zawartych

miÍdzy s≥owami Begin...End.

W tym przypadku jest to wywo≥anie funkcji przeszukujπcej listÍ.

}

AutomatyczneWyszukiwanie(Edit1.Text);

// Wywo≥anie funkcji wyszukujπcej.

end;

Aby by≥o moøliwe przejúcie z komponentu ListBox do komponentu Edit przy
naciúniÍciu dowolnego klawisza alfanumerycznego musisz wpisaÊ kod w wyge-
nerowanym zdarzeniu OnKeyPress. Zdarzenie to moøesz wygenerowaÊ wybie-
rajπc ñ przy zaznaczonym komponencie ListBox ñ okno Object Inspector. Wy-
bierz kartÍ Events i kliknij zdarzenie OnKeyPress, co spowoduje wygenerowa-
nie procedury. W procedurze tej wpisz kod::

procedure TfrmMain.ListBox1KeyPress(Sender: TObject; var Key: Char);

begin

{

Zdarzenie onKeyPress kontroluje naciúniÍcie

dowolnego klawisza. Jeøeli nastπpi naciúniÍcie

dowolnego klawisza, to zostanπ wykonane instrukcje

zawarte miÍdzy s≥owami Begin...End.

}

// Powoduje odznaczenie wypisanych znakÛw w komponencie Edit

Edit1.SetFocus;

// Edit jest teraz aktywny.

Edit1.SelectAll;

// Zaznaczenie tekstu.

Edit1.CopyToClipboard;

// Skopiowanie do schowka.

Edit1.PasteFromClipboard;

// Pobranie danych ze schowka.

end;

∆wiczenie 5.4.3.

Napisz program, w ktÛrym bÍdzie moøliwa zamiana zaznaczonych elementÛw miÍdzy
dwiema listami. Wyglπd programu przedstawia rysunek 5.4.3.

∆wiczenia z podstawowych komponentÛw Delphi

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\ListBox\LBox3

Rysunek 5.4.3.

SposÛb wykonania:

Wybierz 2 komponenty ListBox

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Standard) i umieúÊ je obok siebie.

Wybierz 2 przyciski Button

(karta Standard) i opisz je zgodnie z rysunkiem

5.4.3.

Kliknij dwukrotnie formatkÍ i w wygenerowanej procedurze wpisz kod:

procedure TfrmMain.FormCreate(Sender: TObject);

begin

// Lista 1

ListBox1.Items.Clear;

// Czyúci zawartoúÊ komponentu ListBox

ListBox1.Items.Add('Spectrum');

// Dodaje pozycjÍ do komponentu ListBox

ListBox1.Items.Add('Amiga');

ListBox1.Items.Add('IBM');

ListBox1.Items.Add('Atari');

ListBox1.Items.Add('Żyrafa');

ListBox1.Items.Add('Star Wars');

ListBox1.Items.Add('Cry');

ListBox1.Items.Add('CPU');

ListBox1.Items.Add('Komputer');

// Lista 2

ListBox2.Items.Clear;

// Czyúci zawartoúÊ komponentu ListBox

ListBox2.Items.Add('Mama');

// Dodaje pozycjÍ do komponentu ListBox

ListBox2.Items.Add('Tata');

ListBox2.Items.Add('Brat');

ListBox2.Items.Add('Córka');

ListBox2.Items.Add('Dziewczyna');

∆wiczenia z rozwiπzaniami

ListBox2.Items.Add('Chłopak');

{

W≥πcza moøliwoúÊ zaznaczania wiÍcej

niø jednej pozycji w komponencie ListBox

}

ListBox1.MultiSelect:= TRUE;

ListBox2.MultiSelect:= TRUE;

end;

Kliknij dwukrotnie przycisk >> i w wygenerowanej procedurze wpisz kod:

procedure TfrmMain.bDoListy2Click(Sender: TObject);

var

TT: Integer;

begin

// Przenosi elementy z listy 1 do listy 2

for TT:= ListBox1.Items.Count-1 downto 0 do

if (ListBox1.Selected[TT] =TRUE) then

begin

ListBox2.Items.Add(Trim(ListBox1.Items[TT]));

ListBox1.Items.Delete(TT);

end;

{

for TT:= ListBox1.Items.Count-1 downto 0 do

Przy usuwaniu elementu z listy naleøy tÍ listÍ przeglπdaÊ od elementu

najwyøszym numerze do elementu o najniøszym numerze.

Przeglπdanie od elementu o najniøszym numerze do elementu o najwyøszym numerze

spowoduje b≥πd przez wyjúcie poza zakres tablicy w wyniku prÛby usuniÍcia elementu

o numerze nie istniejπcym.

}

end;

Kliknij dwukrotnie przycisk << i w wygenerowanej procedurze wpisz kod:

procedure TfrmMain.bDoList1Click(Sender: TObject);

var

TT: Integer;

begin

// Przenosi elementy z listy 2 do listy 1

for TT:= ListBox2.Items.Count-1 downto 0 do

if (ListBox2.Selected[TT] =TRUE) then

begin

ListBox1.Items.Add(Trim(ListBox2.Items[TT]));

ListBox2.Items.Delete(TT);

end;

∆wiczenie 5.4.4.

Napisz program, ktÛry bÍdzie zaznacza≥ dodany element do listy oraz nie bÍdzie do-
puszcza≥ do dodania dwÛch takich samych elementÛw. Rysunek 5.4.4 przedstawia
wyglπd programu.

∆wiczenia z podstawowych komponentÛw Delphi

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\ListBox\LBox4

Rysunek 5.4.4.

SposÛb wykonania:

Wybierz komponent ListBox

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Standard).

Wybierz komponent Edit

(karta Standard).

Wybierz przycisk Button

(karta Standard).

Napisz funkcjÍ zapobiegajπcπ dodaniu dwÛch takich samych elementÛw:

function TForm1.ListBoxVerify(txtTextVerify: String): Boolean;

var

TT :Integer;

begin

{

Sprawdza, czy w liúcie istnieje ciπg znakÛw wpisanych w komponencie Edit.

Jeøeli wpisany ciπg znakÛw istnieje, to funkcja zwrÛci

wartoúÊ TRUE (Prawda), w innym przypadku zwrÛci FALSE.

AnsiUpperCase ñ zmienia ca≥y ciπg znakÛw na duøe litery bez wzglÍdu na jÍzyk.

Trim ñ likwiduje spacje po obu stronach ciπgu znakÛw.

}

ListBoxVerify:= FALSE;

for TT:= ListBox1.Items.Count-1 downto 0 do

if (AnsiUpperCase(Trim(txtTextVerify)) =

AnsiUpperCase(Trim(ListBox1.Items[TT]))) then ListBoxVerify:= TRUE;

end;

Napisz funkcjÍ zaznaczajπcπ element dodany do listy:

function TForm1.ListBoxSelectAdd(txtAddText: String): String;

var

∆wiczenia z rozwiπzaniami

TT: Integer;

begin

{

Dodanie nowego ciπgu znakÛw z zaznaczeniem dodawanego ciπgu znakÛw.

Jeøeli nastπpi≥o dodanie ciπgu znakÛw to funkcja zwrÛci dodany ciπg

znakÛw, w przeciwnym przypadku nastπpi zwrÛcenie znaku pustego.

}

ListBoxSelectAdd:= '';

ListBox1.MultiSelect:= TRUE;

// Ustawienie moøliwoúci zaznaczania kilku pozycji.

{

Ustawienie wysokoúci, ktÛra umoøliwia widocznoúÊ ostatniego elementu listy.

}

ListBox1.IntegralHeight:= TRUE;

ListBox1.Sorted:= FALSE;

// Wy≥πczenie sortowania.

// Dodanie ciπgu znakÛw, jeøeli zmienna "txtAddText" nie jest pusta.

if (Trim(txtAddText)<>'') then

begin

ListBox1.Items.Add(Trim(txtAddText));

// Dodanie ciπgu znakÛw.

for TT:= 0 to ListBox1.Items.Count-1 do

ListBox1.Selected[TT]:= FALSE;

// Odznaczenie wszystkich pozycji w liúcie.

// Zaznaczenie dodanej pozycji (ciπgu znakÛw).

ListBox1.Selected[ListBox1.Items.Count-1]:= TRUE;

ListBoxSelectAdd:= Trim(txtAddText);

// ZwrÛcenie dodanego ciπgu znakÛw.

end;

W nastÍpnum kroku zadeklaruj napisane funkcje:

type

TForm1 = class(TForm)

function ListBoxVerify(txtTextVerify: String): Boolean;

function ListBoxSelectAdd(txtAddText: String): String;

procedure FormCreate(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

Kliknij dwukrotnie formatkÍ i w wygenerowanym zdarzeniu wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

Edit1.Text:= '';

// Wyczyszczenie komponentu Edit.

ListBox1.Items.Clear;

// Wyczyszczenie listy.

end;

Kliknij dwukrotnie komponent Edit i w wygenerowanym zdarzeniu wpisz kod:

procedure TForm1.Edit1Change(Sender: TObject);

begin

{

Edit1Change ñ w tej procedurze wpisujemy rozkazy, ktÛre

∆wiczenia z podstawowych komponentÛw Delphi

bÍdπ wykonywane w momencie zmiany zawartoúci komponentu Edit.

}

bAdd.Enabled:= FALSE;

// Wy≥πczenie przycisku DODAJ.

{

if...then

Sprawdza, czy jest wpisany chociaø jeden znak.

Jeøeli tak to zostanie uaktywniony przycisk DODAJ.

}

if (Length(Trim(Edit1.Text)) > 0) then

bAdd.Enabled:= TRUE;

// W≥πczenie przycisku DODAJ.

end;

Kliknij dwukrotnie przycisk Dodaj i w wygenerowanym zdarzeniu wpisz kod:

procedure TForm1.bAddClick(Sender: TObject);

begin

// Dodanie ciπgu znakÛw do listy.

if (ListBoxVerify(Edit1.Text) = FALSE) and

(Trim(Edit1.Text)<>'') then

begin

{

Dodanie nowego ciπgu znakÛw nastπpi w momencie, gdy

tego znaku nie ma w liúcie i zawartoúÊ komponentu Edit

nie jest pusta. W przeciwnym przypadku nie nastπpi

dodanie do listy ciπgu znakÛw.

}

ListBoxSelectAdd(Edit1.Text);

Edit1.Text:= '';

// Wyczyszczenie komponentu Edit.

end;

∆wiczenie 5.5. CheckListBox

Napisz program, ktÛry bÍdzie wczytywa≥ listÍ, zaznacza≥ i odznacza≥ elementy listy oraz
dodawa≥ elementy do listy. Rysunek 5.5.1 przedstawia wyglπd programu.

Rysunek 5.5.1.

∆wiczenia z rozwiπzaniami

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\ListBox\LCBox

Opis komponentu:

CheckListBox jest komponentem s≥uøπcym do wyúwietlania listy elementÛw
z moøliwoúciπ zaznaczania dowolnego elementu. Zaznaczanie elementu polega

na postawieniu obok niego znaczka

. Znajduje siÍ on na karcie Additional palety

komponentÛw.

SposÛb wykonania:

Rozwiπzanie tego przyk≥adu jest takie same jak w Êwiczeniu 5.4.A z wyjπtkiem nazwy
komponentu, ktÛrπ naleøy zmieniÊ z nazwy ListBox1 na nazwÍ CheckListBox1.

∆wiczenie 5.6. Memo

Napisz program, ktÛrego zadaniem bÍdzie wczytanie i zapisanie pliku, wyczyszczenie
oraz w≥πczenie i wy≥πczenie edycji. Rysunek 5.6.1 przedstawia wyglπd programu.

Rysunek 5.6.1.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Memo

Opis komponentu:

Memo jest polem edycyjnym s≥uøπcym do edycji wielowierszowego tekstu bez
formatowania. Moøna teø je zastosowaÊ do wyúwietlania duøego tekstu, ktÛry nie

mÛg≥by byÊ wyúwietlany za pomocπ komponentu Label. Memo znajduje siÍ na karcie
Standard palety komponentÛw.

SposÛb wykonania:

Wybierz komponent Memo

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Wybierz komponent Edit

(karta Standard).

∆wiczenia z podstawowych komponentÛw Delphi

Wybierz kilka przyciskÛw Button

(karta Standard) i opisz je zgodnie z ry-

sunkiem 5.6.1.

Wybierz przycisk CzyúÊ i kliknij dwukrotnie oraz wpisz kod do wygenerowanej
procedury:

procedure TForm1.bCzyscClick(Sender: TObject);

begin

Memo1.Lines.Clear;

// Wyczyszczenie zawartoúci komponentu Memo

end;

Wybierz przycisk Wczytaj plik i kliknij dwukrotnie oraz wpisz kod do wygene-
rowanej procedury:

procedure TForm1.bWczytajPlikClick(Sender: TObject);

begin

Memo1.Lines.Clear;

// Wyczyszczenie zawartoúci komponentu Memo.

if (FileExists('Memo.txt') = TRUE) then

// Jeøeli plik istnieje to odczytaj go.

begin

Memo1.Lines.LoadFromFile('Memo.txt');

// Odczytanie pliku tekstowego "Memo.txt".

end;

Wybierz przycisk Zapisz plik i kliknij dwukrotnie oraz wpisz kod do wygene-
rowanej procedury:

procedure TForm1.bZapiszPlikClick(Sender: TObject);

begin

Memo1.Lines.SaveToFile('Memo.txt');

// Zapisanie do pliku tekstowego.

end;

Wybierz przycisk W≥πcz/Wy≥πcz edycjÍ i kliknij dwukrotnie oraz wpisz kod do
wygenerowanej procedury:

procedure TForm1.bWlaczWylaczEdycjeClick(Sender: TObject);

begin

// W≥πcz/Wy≥πcz edycjÍ

if (Memo1.ReadOnly = FALSE) then

begin

Memo1.ReadOnly:= TRUE;

// Wy≥πcza moøliwoúÊ edytowania.

Memo1.TabStop:= FALSE;

// Umoøliwia przechodzenie za pomocπ klawisza TAB.

Memo1.Color:= clBtnFace;

// Ustawia na kolor szary.

end

else

begin

Memo1.ReadOnly:= FALSE;

// W≥πcza moøliwoúÊ edytowania.

Memo1.TabStop:= TRUE;

// W≥πcza moøliwoúÊ uaktywnienia za pomocπ klawisza TAB.

Memo1.Color:= clWindow;

// Ustawia na kolor bia≥y.

end;

Obs≥uga komponentu RichEdit

jest podobna do komponentu Memo

∆wiczenia z rozwiπzaniami

∆wiczenie 5.7. Image

Napisz program, ktÛry bÍdzie umoøliwia≥ wczytanie dowolnego obrazka (bitmapy).
Rysunek 5.7.1 przedstawia wyglπd programu.

Rysunek 5.7.1.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Obraz

Opis komponentu:

Image jest komponentem, ktÛry s≥uøy do wyúwietlania grafiki na ekranie.
Image znajduje siÍ na karcie Additional palety komponentÛw.

SposÛb wykonania:

Wybierz komponent Image

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Additional).

W oknie Object Inspector wybierz w≥asnoúÊ Align (na karcie Properties) i na-
daj jej wartoúÊ alClient, co spowoduje wykorzystanie przez komponent Image
ca≥ej dostÍpnej przestrzeni formatki.

Wybierz przycisk Button

(karta Standard) i opisz go zgodnie z rysunkiem

5.7.1.

Wybierz przycisk i kliknij dwukrotnie oraz wpisz kod do wygenerowanej proce-
dury:

∆wiczenia z podstawowych komponentÛw Delphi

procedure TForm1.bOtworzPlikGraficznyClick(Sender: TObject);

begin

// Otwiera okno w celu wybrania pliku graficznego.

OpenPictureDialog1.FileName:='';

// Brak nazwy pliku.

OpenPictureDialog1.Execute;

// Uruchomienie okna dialogowego.

if (Trim(OpenPictureDialog1.FileName)<>'') then

begin

// Wczytanie pliku graficznego.

Image1.Picture.LoadFromFile(Trim(OpenPictureDialog1.FileName));

end;

∆wiczenie 5.8. ScrollBox

Napisz program demonstrujπcy dzia≥anie komponentu ScrollBox. Rysunek 5.8.1 przed-
stawia wyglπd takiego programu.

Rysunek 5.8.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\ScrllBox

Opis komponentu:

ScrollBox jest komponentem, ktÛry umoøliwia przewijanie duøej liczby kom-
ponentÛw. Przydatne jest to w momencie, gdy liczba komponentÛw nie po-
zwala na umieszczenie ich na formatce. Komponent ten znajduje siÍ na karcie

Additional palety komponentÛw.

SposÛb wykonania:

Wybierz komponent ScrollBox

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Additional).

NastÍpnie wybierz kilkanaúcie dowolnych komponentÛw (np. ComboBox

CheckBox

itp.) i uk≥adaj je na komponencie ScrollBox tak, aby przesuwajπc

komponent ScrollBox, inne komponenty przesuwa≥y siÍ razem z nim. Uk≥adaj je
tak d≥ugo, aø ca≥e miejsce bÍdzie zajÍte i gdy zobaczysz pasek przewijania.

∆wiczenia z rozwiπzaniami

PrzewiÒ obszar zajÍty przez komponenty i na wolnym obszarze wstaw kilka
nowych komponentÛw.

Uruchom program i zobacz efekt.

∆wiczenie 5.9. ProgressBar

Napisz program, ktÛry bÍdzie wykonywa≥ pÍtle for..to..do i pokazywa≥ postÍp wykony-
wanej pracy.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\StBar

Opis komponentu:

ProgressBar jest komponentem, ktÛry umoøliwia prezentacjÍ postÍpu wykony-
wanego zadania (np. zapisywania danych do pliku). Znajduje siÍ on na karcie

Win32 palety komponentÛw.

SposÛb wykonania:

Wybierz komponent ProgressBar

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Win32).

NastÍpnie wybierz przycisk

(karta Standard) i kliknij go dwukrotnie oraz

w wygenerowanej procedurze wpisz kod:

procedure TForm1.bDrugaInformacjaClick(Sender: TObject);

var

TT: Integer;

begin

ProgressBar1.Position:= 0;

// Ustawienie poczπtkowej wartoúci.

ProgressBar1.Max:= 9999;

// Okreúlenie maksymalnej dopuszczalnej wartoúci.

for TT:= 0 to 9999 do

ProgressBar1.Position:= TT;

// Wskazanie postÍpu pracy pÍtli For..To..Do.

end;

∆wiczenie 5.10. StatusBar

Napisz program taki jak w Êwiczeniu 5.9, ktÛry bÍdzie informowa≥ o rozpoczÍciu i za-
koÒczeniu dzia≥ania pÍtli for..to..do wykorzystujπc do tego komponent StatusBar.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\StBar

Opis komponentu:

StatusBar jest komponentem, ktÛry umoøliwia wyúwietlanie komunikatÛw i jest
umieszczany na formatce w dolnej czÍúci, na karcie Win32 palety komponen-

tÛw. W celu wyúwietlenia tekstu informacyjnego w jednym panelu naleøy we w≥aúci-
woúci SimplePanel wybraÊ wartoúÊ True w oknie Object Inspector. W innym przy-
padku jest moøliwoúÊ podawania kilku informacji w jednym panelu rÛwnoczeúnie.

∆wiczenia z podstawowych komponentÛw Delphi

SposÛb wykonania:

Wybierz komponent ProgressBar

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Win32).

Wybierz komponent ProgressBar

z palety komponentÛw (karta Win32).

NastÍpnie wybierz przycisk

(karta Standard) i kliknij go dwukrotnie. W wy-

generowanej procedurze wpisz kod:

procedure TForm1.bDrugaInformacjaClick(Sender: TObject);

var

TT: Integer;

begin

// Wyúwietla informacje

StatusBar1.SimpleText:=
'Teraz widzisz komponent "ProgressBar" w działaniu...';
ProgressBar1.Position:= 0;

// Ustawienie poczπtkowej wartoúci

ProgressBar1.Max:= 9999;

// Okreúlenie maksymalnej dopuszczalnej wartoúci

for TT:= 0 to 9999 do

ProgressBar1.Position:= TT;

// Wskazanie postÍpu pracy pÍtli For...To...Do

// Wyúwietla informacje

StatusBar1.SimpleText:=
'ProgressBar jest bardzo przydatnym komponentem !!!!';
end;

∆wiczenie 5.11. Timer

Napisz program, ktÛry bÍdzie pokazywa≥ bieøπcy czas.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Timer

Opis komponentu:

Timer jest komponentem, ktÛry s≥uøy do generowania zdarzeÒ w regularnych
odstÍpach czasu. Moøna go wykorzystaÊ np. do wyúwietlania czasu. Znajduje siÍ
on na karcie System palety komponentÛw.

SposÛb wykonania:

Wybierz komponent Timer

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Sys-
tem).

Kliknij go dwukrotnie i w wygenerowanej procedurze wpisz kod:

procedure TForm1.Timer1Timer(Sender: TObject);

begin

// Wyúwietlenie godziny

∆wiczenia z rozwiπzaniami

Label1.Caption:= TimeToStr(Time);

// TimeToStr() ñ Dokonuje konwersji czasu na tekst

end;

∆wiczenie 5.12. RadioButton, GroupBox i CheckBox

Napisz program, ktÛry bÍdzie zmienia≥ kolor formatki, napis na pasku tytu≥owym oraz
bÍdzie mia≥ moøliwoúÊ maksymalizacji ca≥ego okna. Rysunek 5.12.1 przedstawia
wyglπd programu.

Rysunek 5.12.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\RadioBut

Opis komponentÛw:

RadioButton (prze≥πcznik) jest komponentem s≥uøπcym do wyboru jednej opcji
z kilku dostÍpnych. Prze≥πczniki te sπ reprezentowane przez bia≥e kÛ≥eczka,

ktÛre moøna grupowaÊ za pomocπ komponentu GroupBox. Gdy prze≥πcznik jest
w≥πczony, bia≥e kÛ≥eczko jest zape≥nione mniejszym czarnym kÛ≥eczkiem, w innym
przypadku jest nie zape≥nione.

GroupBox jest komponentem s≥uøπcym do grupowania np. komponentÛw Ra-
dioButton.

CheckBox (w≥πcznik) jest komponentem s≥uøπcym do wyboru jednej opcji
niezaleønie od innych opcji. W≥πcznik jest reprezentowany przez bia≥y kwadra-

cik. Gdy w≥πcznik jest w≥πczony, to w bia≥ym kwadraciku ukazuje siÍ znaczek

w innym przypadku kwadracik jest pusty. W≥πcznik moøe przyjmowaÊ trzy stany:
N w≥πczony ñ wartoúÊ True (znaczek , w úrodku bia≥ego kwadracika);
N wy≥πczony ñ wartoúÊ False (kwadracik pusty);
N neutralny (kwadracik jest koloru szarego ze znaczkiem ,).
Standardowo w≥πcznik moøe przyjmowaÊ dwa stany. W≥aúciwoúÊ AllowGrayed jest
ustawiona na wartoúÊ False (domyúlnie). W celu umoøliwienia przyjmowania trzech
stanÛw w≥πcznika naleøy ustawiÊ w≥aúciwoúÊ AllowGrayed na wartoúÊ True.

Wyøej opisane komponenty znajdujπ siÍ na karcie Standard palety komponentÛw.

∆wiczenia z podstawowych komponentÛw Delphi

SposÛb wykonania:

Wybierz dwa komponenty GroupBox

(sposÛb wybrania i umieszczenia

komponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety kompo-
nentÛw (karta Standard).

Wybierz kilka komponentÛw RadioButton

(karta Standard).

Wybierz CheckBox

(karta Standard).

Rozstaw i opisz wszystkie komponenty zgodnie z rysunkiem 5.12.1.

Zaznacz pierwszy RadioButton w pierwszej ramce i kliknij go dwukrotnie. W wy-
generowanej procedurze wpisz kod:

procedure TForm1.RadioButton1Click(Sender: TObject);

begin

// Daje kolor czerwony

Form1.Color:= clRed;

end;

Zaznacz pierwszy RadioButton w drugiej ramce i kliknij go dwukrotnie. W wy-
generowanej procedurze wpisz kod:

procedure TForm1.RadioButton4Click(Sender: TObject);

begin

// Obs≥uga RadioButton'Ûw

if (RadioButton4.Checked = TRUE) then Caption:= 'Delphi';

// Wyúwietlenie napisu

if (RadioButton5.Checked = TRUE) then Caption:= 'Atari';

if (RadioButton6.Checked = TRUE) then Caption:= 'Komputer';

if (RadioButton7.Checked = TRUE) then Caption:= ‘Komponent RadioButton’;

end;

Zaznacz drugi RadioButton (ramka 2) i majπc go zaznaczony w oknie Object
Inspector wybierz kartÍ Events. Na karcie tej wybierz zdarzenie OnClick i w li-
úcie rozwijanej wybierz procedurÍ RadioButton4Click. Tak postÍpuj z nastÍp-
nymi przyciskami RadioButton w ramce 2.

Wybierz CheckBox i kliknij go dwukrotnie, a w wygenerowanej procedurze
wpisz kod:

procedure TForm1.CheckBox1Click(Sender: TObject);

begin

if (CheckBox1.Checked = FALSE) then

begin

Form1.WindowState:= wsNormal;

// Przywraca poprzedni stan okna.

end

else

begin

Form1.WindowState:= wsMaximized;

// Daje okno na ca≥y ekran.

end;

∆wiczenia z rozwiπzaniami

∆wiczenie 5.13. TrackBar

Wykonaj program pokazujπcy zmieniajπcπ siÍ wartoúÊ pod wp≥ywem poruszania
wskaünikiem komponentu TrackBar. Rysunek 5.13.1 przedstawia program.

Rysunek 5.13.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\TrackBar

Opis komponentu:

TrackBar (suwak) jest komponentem s≥uøπcym do zmiany wartoúci (np. zmia-
ny zakresu losowanych liczb). TrackBar znajduje siÍ na karcie Win32 palety

komponentÛw.

SposÛb wykonania:

Wybierz komponent Label

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Wybierz komponent TrackBar

(karta Win32).

Zaznacz komponent TrackBar i w oknie Object Inspector we w≥aúciwoúci Max
wpisz wartoúÊ 100.

Majπc zaznaczony komponent TrackBar kliknij go dwukrotnie i w wygenero-
wanej procedurze wpisz kod:

procedure TForm1.TrackBar1Change(Sender: TObject);

begin

// Wykonuje poniøsze instrukcje w momencie ruszania wskaünikiem.

// Label1.Caption ñ Wyúwietla wybranπ wartoúÊ.

Label1.Caption:= 'Wyświetl wybraną wartość:
'+IntToStr(TrackBar1.Position);

{

Label1.Caption ñ ten komponent s≥uøy do wyúwietlania tekstu

IntToStr('123') ñ ta funkcja wykonuje konwersjÍ liczby na tekst

}

end;

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 5.14. MediaPlayer

Napisz program do odtwarzania plikÛw düwiÍkowych.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Media

Opis komponentu:

MediaPlayer jest komponentem s≥uøπcym do odtwarzania plikÛw muzycznych,
muzyki z p≥yt CD, filmÛw i wiele innych. MediaPlayer znajduje siÍ na karcie
System palety komponentÛw.

SposÛb wykonania:

Wybierz komponent MediaPlayer

(sposÛb wybrania i umieszczenia kom-

ponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta System).

Wybierz komponent Button

(karta Standard) i kliknij go dwukrotnie. W wy-

generowanej procedurze wpisz kod:

procedure TForm1.Button1Click(Sender: TObject);

begin

// OtwÛrz plik muzyczny

OpenDialog1.FileName:= '';

OpenDialog1.Execute;

if (Trim(OpenDialog1.FileName)<>'') then

begin

// Procedura otwierania i odtwarzania muzyki za pomocπ komponentu MediaPlayer

MediaPlayer1.Close;

MediaPlayer1.FileName:= Trim(OpenDialog1.FileName);

MediaPlayer1.Open;

MediaPlayer1.Play;

end;

∆wiczenie 5.15. Menu

Napisz program, w ktÛrym bÍdzie moøliwoúÊ prze≥πczania miÍdzy dwoma Menu. Rysu-
nek 5.15.1 przedstawia taki program.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Menu

Rysunek 5.15.1.

∆wiczenia z rozwiπzaniami

Opis komponentu:

Menu jest komponentem s≥uøπcym do wywo≥ywania funkcji programu uprzed-
nio umieszczonych w menu. Na jednej formatce moøe byÊ wiÍcej niø jedno

menu. Wybranie menu nas interesujπcego odbywa siÍ za pomocπ w≥asnoúci Menu
obiektu formatki. Wyboru tego dokonujemy piszπc w programie wiersze Menu:=
MainMenu1 lub Menu:= MainMenu2 w zaleønoúci od tego, ktÛre menu ma byÊ
aktywne. W danej chwili jest widoczne tylko jedno menu. Komponent ten znajduje siÍ
na karcie Standard palety komponentÛw.

Menu moøe byÊ rozwijane do podmenu. Tworzenie podmenu polega na wywo≥aniu
funkcji Create SubMenu. Aby element posiada≥ podmenu musimy go wybraÊ i pra-
wym przyciskiem myszy wywo≥aÊ menu podrÍczne, z ktÛrego naleøy wybraÊ funkcjÍ
Create SubMenu (rysunek 5.15.2).

Rysunek 5.15.2.

Po wybraniu opcji Create SubMenu ukaøe siÍ puste podmenu (rysunek 5.15.3).

Rysunek 5.15.3.

SposÛb wykonania:

Wybierz dwa komponenty MainMenu

(sposÛb wybrania i umieszczenia

komponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety kompo-
nentÛw (karta Standard).

Pierwsze menu opisz zgodnie z rysunkiem 5.15.1.

W drugim menu umieúÊ funkcjÍ Menu pierwsze inne elementy menu sπ dowolne.

∆wiczenia z podstawowych komponentÛw Delphi

Wybierz pierwszy element menu i kliknij go. W wygenerowanej procedurze
wpisz kod:

procedure TForm1.PlikElementpierwszyClick(Sender: TObject);

begin

// Wywo≥anie elementu pierwszego z menu g≥Ûwnego

ShowMessage(PlikElementpierwszy.Caption);

end;

Z innymi elementami menu postÍpuj tak samo, prÛcz pozycji ÑDrugie menuî
i pozycji ÑWyjúcieî.

Wybierz pozycjÍ menu Drugie menu i kliknij jπ. W wygenerowanej procedurze
wpisz kod:

procedure TForm1.PlikDrugiemenuClick(Sender: TObject);

begin

// Prze≥πcza siÍ na drugie menu

Menu:= MainMenu2;

end;

Wybierz pozycjÍ menu Wyjúcie i kliknij jπ. W wygenerowanej procedurze wpisz
kod:

procedure TForm1.PlikWyjcieClick(Sender: TObject);

begin

// Wyjúcie z programu

Close;

end;

Wybierz w menu drugim pozycjÍ Menu pierwsze i kliknij jπ. W wygenerowanej
procedurze wpisz kod:

procedure TForm1.Menupierwsze1Click(Sender: TObject);

begin

// Prze≥πcza siÍ na pierwsze menu

Menu:= MainMenu1;

end;

∆wiczenie 5.16. PopupMenu

Wykonaj program, w ktÛrym opcje bÍdπ wybierane za pomocπ menu podrÍcznego.
Rysunek 5.16.1 przedstawia taki program.

Rysunek 5.16.1.

∆wiczenia z rozwiπzaniami

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\popmenu

Opis komponentu:

PopupMenu jest komponentem takim samym jak menu z tπ rÛønicπ, øe moøna
go wywo≥aÊ za pomocπ prawego przycisku myszy. PopupMenu moøna pod≥π-

czyÊ do komponentÛw znajdujπcych siÍ na formatce. Ponad to jest on niewidoczny
w czasie dzia≥ania programu jak np. menu g≥Ûwne. Dopiero uøytkownik wywo≥ujπc go
powoduje ukazanie siÍ tegoø menu podrÍcznego. Komponent ten znajduje siÍ na
karcie Standard palety komponentÛw.

SposÛb wykonania:

Wybierz dwa komponenty PopupMenu

(sposÛb wybrania i umieszczenia

komponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety kompo-
nentÛw (karta Standard).

Opis elementÛw PopupMenu jest dowolny.

Rozwiπzanie i obs≥uga PopupMenu jest taka sama jak MainMenu.

Wybierz przycisk Button

(karta Standard) i opisz go zgodnie z rysunkiem

5.16.1.

Kliknij dwukrotnie formatkÍ i w wygenerowanej procedurze wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

// Programowe pod≥πczenie menu podrÍcznego do formatki.

PopupMenu:= PopupMenu1;

end;

Kliknij dwukrotnie przycisk i w wygenerowanej procedurze wpisz kod:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Uruchomienie menu podrÍcznego

PopupMenu2.Popup(Left+Button1.Left+2, Top+Button1.Top-35);

end;

∆wiczenie 5.17. StringGrid

Napisz program, ktÛry wype≥ni arkusz i bÍdzie mia≥ moøliwoúÊ dodania wiersza lub
kolumny oraz bÍdzie mia≥ moøliwoúÊ wstawienia ca≥ego wiersza lub ca≥ej kolumny.
Rysunek 5.17.1 przedstawia wyglπd tego programu.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\StrGrid

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.17.1.

Opis komponentu:

StringGrid (arkusz pÛl edycyjnych) jest komponentem, ktÛry umoøliwia wy-
úwietlenie informacji w sposÛb tabelaryczny lub zrobienie prostego programu

kalkulacyjnego. Komponent ten znajduje siÍ na karcie Standard palety komponen-
tÛw.

SposÛb wykonania:

Wybierz komponent StringGrid

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Additional).

Wybierz kilka przyciskÛw Button

(karta Standard) i opisz je zgodnie z ry-

sunkiem 5.17.1.

Wybierz przycisk Dodaj wiersz i dwukrotnie go kliknij. W wygenerowanej pro-
cedurze wpisz kod:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Dodanie nowego wiersza

StringGrid1.RowCount:= StringGrid1.RowCount+1;

end;

Wybierz przycisk Wstaw nowy wiersz i dwukrotnie go kliknij. W wygenerowa-
nej procedurze wpisz kod:

procedure TForm1.Button2Click(Sender: TObject);

var

AA, BB: Integer;

begin

// Wstawia nowy wiersz

// PrzesuniÍcie (przez przekopiowanie) wierszy o jeden wiersz w dÛ≥

for AA:= StringGrid1.RowCount-1 downto StringGrid1.Row do

∆wiczenia z rozwiπzaniami

for BB:= 0 to StringGrid1.ColCount-1 do

StringGrid1.Cells[BB, 1+AA]:= Trim(StringGrid1.Cells[BB, AA]);

// Wyczyszczenie ca≥ego wiersza, przez co powstaje nowy pusty wiersz

for AA:= 0 to StringGrid1.ColCount-1 do

StringGrid1.Cells[AA, StringGrid1.Row]:= '';

// Dodanie nowego wiersza

StringGrid1.RowCount:= StringGrid1.RowCount+1;

end;

Wybierz przycisk UsuÒ wiersz i dwukrotnie go kliknij. W wygenerowanej pro-
cedurze wpisz kod:

procedure TForm1.Button3Click(Sender: TObject);

var

AA, BB: Integer;

begin

// Usuwa wiersz

// Czyúci ca≥y wiersz

for AA:= 0 to StringGrid1.ColCount-1 do

StringGrid1.Cells[AA, StringGrid1.Row]:= '';

// PrzesuniÍcie (przez przekopiowanie) wierszy o jeden wiersz wyøej

for AA:= 0 to StringGrid1.RowCount-1 do

for BB:= 0 to StringGrid1.ColCount-1 do

begin

StringGrid1.Cells[BB, StringGrid1.Row+AA]:= Trim(

StringGrid1.Cells[BB, StringGrid1.Row+1+AA]);

end;

// UsuniÍcie wiersza

StringGrid1.RowCount:= StringGrid1.RowCount-1;

end;

Wybierz przycisk Dodaj kolumnÍ i dwukrotnie go kliknij. W wygenerowanej
procedurze wpisz kod:

procedure TForm1.Button4Click(Sender: TObject);

begin

// Dodanie nowej kolumny

StringGrid1.ColCount:= StringGrid1.ColCount+1;

end;

Wybierz przycisk Wstaw nowπ kolumnÍ i dwukrotnie go kliknij. W wygenero-
wanej procedurze wpisz kod:

procedure TForm1.Button5Click(Sender: TObject);

var

AA, BB: Integer;

begin

// Wstawia nowπ kolumnÍ

// PrzesuniÍcie (przez przekopiowanie) kolumny o jednπ kolumnÍ w prawπ stronÍ

for AA:= StringGrid1.ColCount-1 downto StringGrid1.Col do

for BB:= 0 to StringGrid1.RowCount-1 do

StringGrid1.Cells[1+AA, BB]:= Trim(StringGrid1.Cells[AA, BB]);

// Wyczyszczenie ca≥ej kolumny

∆wiczenia z podstawowych komponentÛw Delphi

for AA:= 0 to StringGrid1.RowCount-1 do

StringGrid1.Cells[StringGrid1.Col, AA]:= '';

// Dodanie nowej kolumny

StringGrid1.ColCount:= StringGrid1.ColCount+1;

end;

Wybierz przycisk UsuÒ kolumnÍ i dwukrotnie go kliknij. W wygenerowanej
procedurze wpisz kod:

procedure TForm1.Button6Click(Sender: TObject);

var

AA, BB: Integer;

begin

// Usuwa kolumnÍ

// Wyczyszczenie ca≥ej kolumny

for AA:= 0 to StringGrid1.RowCount-1 do

StringGrid1.Cells[StringGrid1.Col, AA]:= '';

// PrzesuniÍcie (przez przekopiowanie) kolumny o jednπ kolumnÍ w lewπ stronÍ

for AA:= 0 to StringGrid1.ColCount-1 do

for BB:= 0 to StringGrid1.RowCount-1 do

begin

StringGrid1.Cells[StringGrid1.Col+AA, BB]:= Trim(

StringGrid1.Cells[StringGrid1.Col+1+AA, BB]);

end;

// UsuniÍcie kolumny

StringGrid1.ColCount:= StringGrid1.ColCount-1;

end;

Wybierz przycisk Wype≥nij ca≥π tabelÍ i dwukrotnie go kliknij. W wygenero-
wanej procedurze wpisz kod:

procedure TForm1.Button7Click(Sender: TObject);

begin

// Wype≥nia jeden wiersz w tabeli

// Tytu≥y kolumn

StringGrid1.Cells[0, 0]:= 'Nazwisko';

StringGrid1.Cells[1, 0]:= 'Imię';

StringGrid1.Cells[2, 0]:= 'Miasto';

StringGrid1.Cells[3, 0]:= 'Adres';

StringGrid1.Cells[4, 0]:= 'Telefon';

// Dane

StringGrid1.Cells[0, 1]:= 'Kowalski';

StringGrid1.Cells[1, 1]:= 'Jan';

StringGrid1.Cells[2, 1]:= 'Gdańsk';

StringGrid1.Cells[3, 1]:= 'Błotna 22';

StringGrid1.Cells[4, 1]:= '811-56-12';

// Wyúwietlenie iloúci wierszy i kolumn

Label1.Caption:= 'Ilość wierszy:'+CHR(32)+IntToStr(StringGrid1.RowCount-1);

Label2.Caption:= 'Ilość kolumn:'+CHR(32)+IntToStr(StringGrid1.ColCount);

end;

∆wiczenia z rozwiπzaniami

Wstaw dodatkowy przycisk i nazwij go Zapisanie tabeli i kliknij go dwukrotnie.
W wygenerowanej procedurze wpisz kod:

function TForm1.StringGridZapisz(txtFileName: String; numCol: Integer):
Shortint;
var

aCol, aRow: Integer;

// Deklaracja zmiennych

FT: TextFile;

// Deklaracja zmiennej plikowej

begin

// Zapisanie tabeli do pliku tekstowego

StringGridZapisz:= -1;

{

if (Trim(txtFileName)<>'') then

Sprawdzenie, czy zosta≥a podana nazwa pliku. Jeøeli tak to zapisz

(funkcja zwrÛci wartoúÊ 1), w innym przypadku nie rÛb nic (funkcja zwrÛci wartoúÊ ñ1).

}

if (Trim(txtFileName)<>'') then

begin

AssignFile(FT, Trim(txtFileName));

// Powiπzanie nazwy pliku z plikiem na dysku

// Zmiana atrybutÛw pliku

FileSetAttr(Trim(txtFileName), faArchive);

Rewrite(FT);

// Tworzenie i otwieranie pliku do zapisu

// Zapisanie wype≥nionych wierszy

for aRow:= 0 to StringGrid1.RowCount-1 do

for aCol:= 0 to StringGrid1.ColCount-1 do

if (Trim(StringGrid1.Cells[numCol, aRow])<>'') then

Writeln(FT, StringGrid1.Cells[aCol, aRow]);

CloseFile(FT);

// ZamkniÍcie pliku

StringGridZapisz:= 1;

end;

∆wiczenie 5.18. TreeView

Napisz program, ktÛry bÍdzie przedstawia≥ drzewo hierarchiczne pokazujπce miejsce
poszczegÛlnych elementÛw. Rysunek 5.18.1 pokazuje wyglπd takiego programu.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\TreeView

Opis komponentu:

TreeView jest komponentem, ktÛry umoøliwia wyúwietlenie informacji w po-
staci drzewa, ktÛre jest uporzπdkowane hierarchicznie. Komponent ten znajduje
siÍ na karcie Win32 palety komponentÛw.

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.18.1.

Przyk≥ad drzewa uporzπdkowanego hierarchicznie:

Król

-- Królowa

| |

| -- Służba

Rycerz

-- Giermek

-- itd.

SposÛb wykonania:

Wybierz komponent TreeView

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Win32).

Wybierz kilka przyciskÛw Button

(karta Standard) i opisz je zgodnie z ry-

sunkiem 5.18.1.

Wybierz komponent Label

(karta Standard) i umieúÊ go pod komponentem

TreeView.

Wybierz przycisk Dodaj i kliknij go dwukrotnie. W wygenerowanej procedurze
wpisz kod:

procedure TForm1.bDodajClick(Sender: TObject);

begin

// Dodanie do listy tekstu

TreeView1.Items.AddFirst(TreeView1.Selected,

InputBox('Dodaj', 'Tekst:', 'Pozycja'));

end;

∆wiczenia z rozwiπzaniami

Wybierz przycisk Dodaj element szczegÛ≥owy i kliknij go dwukrotnie. W wy-
generowanej procedurze wpisz kod:

procedure TForm1.bDodajElementSzczegowyClick(Sender: TObject);

begin

// Dodaje element szczegÛ≥owy

TreeView1.Items.AddChildFirst(TreeView1.Selected,

InputBox('Dodaj', 'Tekst:', 'Pozycja'));

{

TreeView1.Items.AddChildFirst ñ dodanie pozycji do listy lub

dodanie 'Elementu2' do 'Elementu1'

uprzednio zaznaczajπc 'Elememt1'.

Przez co tworzy siÍ hierarchia.

}

// InputBox('Dodaj', 'Tekst:', 'Pozycja') ñ otwiera okno edycyjne

end;

Wybierz przycisk Popraw i kliknij go dwukrotnie. W wygenerowanej procedu-
rze wpisz kod:

procedure TForm1.bPoprawClick(Sender: TObject);

begin

// Poprawia zaznaczony tekst

TreeView1.Items.Insert(TreeView1.Selected,

InputBox('Dodaj', 'Tekst:', Tre-
eView1.Selected.Text));

// TreeView1.Items.Insert ñ Wstawia nowy tekst na pozycjÍ elementu zaznaczonego

TreeView1.Items.Delete(TreeView1.Selected);

// Usuwa zaznaczony tekst

end;

Wybierz przycisk UsuÒ i kliknij go dwukrotnie. W wygenerowanej procedurze
wpisz kod:

procedure TForm1.bUsunClick(Sender: TObject);

begin

// Usuwa zaznaczony tekst

TreeView1.Items.Delete(TreeView1.Selected);

end;

Wybierz przycisk WyczyúÊ listÍ i kliknij go dwukrotnie. W wygenerowanej
procedurze wpisz kod:

procedure TForm1.bWyczyscClick(Sender: TObject);

begin

// Wyczyszczenie zawartoúci listy

TreeView1.Items.Clear;

end;

Wybierz przycisk Liczba elementÛw i kliknij go dwukrotnie. W wygenerowanej
procedurze wpisz kod:

∆wiczenia z podstawowych komponentÛw Delphi

procedure TForm1.bLiczbaElementwClick(Sender: TObject);

begin

// Podaje liczbÍ elementÛw

bLiczbaElementw.Caption:= 'Liczba elementów:
'+IntToStr(TreeView1.Items.Count);
end;

Jeúli chcesz wyúwietliÊ w komponencie Label nazwÍ zaznaczonego elementu
podczas poruszania siÍ po liúcie, wybierz komponent TreeView, gdy bÍdzie na
formatce i kliknij go dwukrotnie. W wygenerowanej procedurze wpisz nastÍpu-
jπcy kod:

procedure TForm1.TreeView1Change(Sender: TObject; Node: TTreeNode);

begin

// Wyúwietla zaznaczony tekst

{

Zmiana koloru wyúwietlanego napisu w zaleønoúci od

spe≥nionego warunku, w innym przypadku kolor bÍdzie czarny.

}

if (TreeView1.Selected.Text = 'Atari 65XE') then

Label2.Font.Color:= clBlue

else

if (TreeView1.Selected.Text = 'IBM') then

Label2.Font.Color:= clGreen

else

if (TreeView1.Selected.Text = 'Lalki') then

Label2.Font.Color:= clRed

else

Label2.Font.Color:= clBlack;

// Wyúwietla zaznaczony tekst

Label2.Caption:= TreeView1.Selected.Text;

end;

∆wiczenie 5.19. WewnÍtrzna lista

Napisz program, ktÛry utworzy wewnÍtrznπ listÍ, doda do niej elementy i na koniec
zapisze listÍ do pliku.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Lista

Opis wewnÍtrznej listy:

Lista wewnÍtrzna umoøliwia przechowywanie elementÛw listy bez korzystania z kom-
ponentÛw takich jak ComboBox, ListBox czy CheckListBox. W czasie dzia≥ania
aplikacji jest ona niewidoczna dla uøytkownika.

SposÛb wykonania:

Jeúli chcesz utworzyÊ listÍ, zadeklaruj jπ najpierw. Moøesz to zrobiÊ przez wsta-
wienie do pola Private (Prywatne) deklaracji

List: TStringList;

. Przyk≥ad

wstawienia deklaracji jest przedstawiony poniøej.

∆wiczenia z rozwiπzaniami

private

{ Private declarations }

List: TStringList;

// Obiekt reprezentujπcy naszπ listÍ.

NastÍpnie kliknij dwukrotnie formatkÍ, co spowoduje wygenerowanie zdarzenia
OnCreate. W wygenerowanej procedurze utwÛrz listÍ przez wpisanie wiersza

List:= TStringList.Create;

. Przyk≥ad jest zamieszczony poniøej.

procedure TForm1.FormCreate(Sender: TObject);

begin

List:= TStringList.Create;

// Dynamiczne tworzenie listy

end;

Wybierz przycisk Button

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Kliknij dwukrotnie ten przycisk i w wygenerowanej procedurze wpisz kod:

procedure TForm1.bDodajDoListyElementyZapisujacDoPlikuClick(Sender: TObject);

begin

// Dodaje elementy do listy i zapisuje jπ do pliku

List.Clear;

// Czyszczenie listy

List.Add('Spectrum');

// Dodanie do listy

List.Add('Amiga');

List.Add('IBM');

List.Add('Atari');

List.Add('Żyrafa');

List.Add('Star Wars');

List.Add('Cry');

List.Add('CPU');

List.Add('Komputer');

List.Sort;

// W≥πcza sortowanie listy

Label1.Caption:= Trim(List.Strings[0]);

// Odczytanie elementu z listy o podanym numerze.

List.SaveToFile('Lista.txt');

// Zapisanie w≥asnej listy do pliku.

end;

UmieúÊ wiersz

List.Destroy;

w metodzie obs≥ugujπcej zdarzenie OnClose, aby

usunπÊ listÍ z pamiÍci. Wstawienie tego wiersza ilustruje poniøszy przyk≥ad.

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);

begin

List.Destroy;

// UsuniÍcie listy z pamiÍci

end;

∆wiczenie 5.20. Okna informacyjne

Napisz program, ktÛry bÍdzie prezentowa≥ rodzaje okien informacyjnych. Rysunek
5.20.1 przedstawia taki program.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\OknaInf

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.20.1.

Opis okien informacyjnych:

Informacja wyúwietlana jest za pomocπ okien informacyjnych, ktÛre dzielπ siÍ na:
N informujπce o b≥Ídzie (rysunek 5.20.2);

Rysunek 5.20.2.

N informacyjne (rysunek 5.20.3);

Rysunek 5.20.3.

N ostrzegawcze (rysunek 5.20.4).

Rysunek 5.20.4.

∆wiczenia z rozwiπzaniami

SposÛb wykonania:

Wybierz kilka przyciskÛw Button

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Standard) i opisz je zgodnie z rysunkiem 5.20.1.

Wybierz przycisk Pokaø okno mÛwiπce o b≥Ídzie i kliknij go dwukrotnie. W wy-
generowanej procedurze wpisz kod:

procedure TForm1.bErrorClick(Sender: TObject);

begin

// Okno informujπce o b≥Ídzie

Application.MessageBox('Okno informujące o błędzie',

'Błąd', MB_ICONERROR or MB_OK);

{

Application.MessageBox(Informacja,

Tytu≥_Okna, Rodzaj_Rysunku or Jaki_Klawisz);

}

end;

Wybierz przycisk Pokaø okno informacyjne i kliknij go dwukrotnie. W wyge-
nerowanej procedurze wpisz kod:

procedure TForm1.bInformationClick(Sender: TObject);

begin

// Okno informujπce np. o skoÒczeniu kopiowania

Application.MessageBox('Okno informujące o skończeniu kopiowania',

'Informacja', MB_ICONINFORMATION or MB_OK);

end;

Wybierz przycisk Pokaø okno ostrzegawcze i kliknij go dwukrotnie. W wygene-
rowanej procedurze wpisz kod:

procedure TForm1.bWarningClick(Sender: TObject);

begin

// Okienko ostrzegawcze np. o wystπpieniu jakiegoú b≥Ídu

Application.MessageBox('Pokazuje okno ostrzegawcze',

'Ostrzeżenie', MB_ICONWARNING or MB_OK);

end;

Wybierz przycisk Pokaø okno informacyjne 2 i kliknij go dwukrotnie. W wy-
generowanej procedurze wpisz kod:

procedure TForm1.bInfoClick(Sender: TObject);

begin

// Pokaø okno informacyjne

ShowMessage('Okno ostrzegawcze !!');

end;

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 5.21. Okna s≥uøπce do zadawania pytaÒ

Napisz program, ktÛry bÍdzie prezentowa≥ okna s≥uøπce do zadawania pytaÒ. Rysunek
5.21.1 przedstawia taki program.

Rysunek 5.21.1.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\OknaPyt

Opis okien s≥uøπcych do zadawania pytaÒ:

Okna s≥uøπce do zadawania pytaÒ w trakcie dzia≥ania aplikacji. RozrÛønia siÍ nastÍ-
pujπce rodzaje okien Ñpytajπcychî:
N z dwiema moøliwymi odpowiedziami (rysunek 5.21.2);

Rysunek 5.21.2.

N z trzema moøliwymi odpowiedziami (rysunek 5.21.3).

Rysunek 5.21.3.

∆wiczenia z rozwiπzaniami

SposÛb wykonania:

Wybierz dwa przyciski Button

(sposÛb wybrania i umieszczenia komponen-

tu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Standard) i opisz je zgodnie z rysunkiem 5.21.1.

Wybierz przycisk Dwie moøliwoúci do wyboru i kliknij go dwukrotnie. W wy-
generowanej procedurze wpisz kod:

procedure TForm1.Button1Click(Sender: TObject);

var

numBtn: Integer;

begin

// Dwie moøliwoúci do wyboru

numBtn:= 0;

numBtn:= Application.MessageBox('Którą wybierasz ?',
'Dwie możliwości do wyboru',
MB_ICONQUESTION or MB_YESNO);

if (numBtn = IDYES) then

begin

ShowMessage('To jest PIERWSZA możliwość');

end;

if (numBtn = IDNO) then

begin

ShowMessage('To jest DRUGA możliwość');

end;

Wybierz przycisk Trzy moøliwoúci do wyboru i kliknij go dwukrotnie. W wyge-
nerowanej procedurze wpisz kod:

procedure TForm1.Button2Click(Sender: TObject);

var

numBtn: Integer;

begin

// Trzy moøliwoúci do wyboru

numBtn:= 0;

numBtn:= Application.MessageBox('Którą wybierasz ?',
'Trzy możliwości do wyboru',
MB_ICONQUESTION or MB_YESNOCANCEL);

if (numBtn = IDYES) then

begin

ShowMessage('To jest PIERWSZA możliwość');

end;

if (numBtn = IDNO) then

begin

ShowMessage('To jest DRUGA możliwość');

end;

if (numBtn = IDCancel) then

begin

ShowMessage('To jest TRZECIA możliwość');

end;

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 5.22. Okna dialogowe

Napisz program, ktÛry bÍdzie prezentowa≥ okna dialogowe (np. okno s≥uøπce do zapi-
sywania plikÛw). Rysunek 5.22.1 przedstawia wyglπd programu.

Rysunek 5.22.1.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Dialogi

Opis okien dialogowych:

Okna dialogowe majπ na celu u≥atwiÊ programiúcie tworzenie podstawowych funkcji
aplikacji, takich jak otwarcie pliku, zmiana kolorÛw itp. Okna dialogowe znajdujπ siÍ
na karcie Dialogs palety komponentÛw.

Tekst widoczny w oknach dialogowych zaleøy od zainstalowanej wersji jÍzykowej
Windows.

SposÛb wykonania:

Wybierz kilka przyciskÛw Button

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Standard) i opisz je zgodnie z rysunkiem 5.22.1.

Wybierz nastÍpujπce komponenty z karty Dialogs:

N Open Dialog (otwÛrz plik),

N Save Dialog (zapisz plik),

N Open Picture Dialog (otwÛrz plik graficzny),

N Save Picture Dialog (zapisz plik graficzny),

N Color Dialog (okno kolorÛw),

∆wiczenia z rozwiπzaniami

N Printer Setup Dialog (ustawienia wydruku).

Wybierz przycisk OtwÛrz plik i kliknij go dwukrotnie. W wygenerowanej pro-
cedurze wpisz kod:

procedure TForm1.bOtworzPlikClick(Sender: TObject);

begin

// Otwiera okno dialogowe, ktÛre umoøliwia nam wczytanie pliku

{

Nazwa "OpenDialog1" jest nazwπ komponentu, ktÛrπ moøna

zmieniÊ we w≥aúciwoúciach okna "Object Inspector".

}

OpenDialog1.FileName:= '';

OpenDialog1.Execute;

if (Trim(OpenDialog1.FileName)<>'') then

begin

// (W tym miejscu wpisujemy w≥asny kod programu)

Label1.Caption:= Trim(OpenDialog1.FileName);

{

Funkcja Trim() ñ likwiduje spacje po prawej

jak i po lewej stronie napisu

lub zmiennej

}

end;

Wybierz przycisk Zapisz plik i kliknij go dwukrotnie. W wygenerowanej proce-
durze wpisz kod:

procedure TForm1.bZapiszPlikClick(Sender: TObject);

begin

// Zapisuje plik

SaveDialog1.FileName:= '';

SaveDialog1.Execute;

if (Trim(SaveDialog1.FileName)<>'') then

begin

// (W tym miejscu wpisujemy w≥asny kod programu)

Label1.Caption:= Trim(SaveDialog1.FileName);

end;

N Wybierz przycisk OtwÛrz plik graficzny i kliknij go dwukrotnie. W wygenero-

wanej procedurze wpisz kod:

procedure TForm1.bOtworzPlikGraficznyClick(Sender: TObject);

begin

// Otwiera okienko do wybrania pliku graficznego

OpenPictureDialog1.FileName:='';

OpenPictureDialog1.Execute;

if (Trim(OpenPictureDialog1.FileName)<>'') then

∆wiczenia z podstawowych komponentÛw Delphi

begin

// (W tym miejscu wpisujemy w≥asny kod programu)

Label1.Caption:= Trim(OpenPictureDialog1.FileName);

end;

Wybierz przycisk Zapisz plik graficzny i kliknij go dwukrotnie. W wygenero-
wanej procedurze wpisz kod:

procedure TForm1.bZapiszPlikGraficznyClick(Sender: TObject);

begin

// Zapisz plik graficzny

SavePictureDialog1.FileName:='';

SavePictureDialog1.Execute;

if (Trim(SavePictureDialog1.FileName)<>'') then

begin

// (W tym miejscu wpisujemy w≥asny kod programu)

Label1.Caption:= Trim(SavePictureDialog1.FileName);

end;

Wybierz przycisk Ustaw kolor formatki i kliknij go dwukrotnie. W wygenero-
wanej procedurze wpisz kod:

procedure TForm1.bUstawKolorFormatkiClick(Sender: TObject);

begin

// Ustawia kolor formatki

if ColorDialog1.Execute then

begin

Form1.Color:= ColorDialog1.Color;

// Ustawia kolor formatki

Label1.Caption:= IntToStr(ColorDialog1.Color);

// Podaje wartoúÊ koloru

end;

Wybierz przycisk Ustawienia wydruku i kliknij go dwukrotnie. W wygenero-
wanej procedurze wpisz kod:

procedure TForm1.bUstawieniaWydrukuClick(Sender: TObject);

begin

// Otwiera okienko z ustawieniami wydruku

PrinterSetupDialog1.Execute;

end;

∆wiczenie 5.23. Obs≥uga kilku komponentÛw

Wykonaj program, ktÛry bÍdzie obs≥ugiwa≥ kilka komponentÛw za pomocπ jednej
funkcji. Rysunek 5.23.1 przedstawia wyglπd tego programu.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\KilKom

∆wiczenia z rozwiπzaniami

Rysunek 5.23.1.

Opis:

Obs≥uga kilku komponentÛw jest bardzo dogodnym rozwiπzaniem w przypadku, gdy
chcemy obs≥uøyÊ np. 20 przyciskÛw za pomocπ jednego zdarzenia. Ten sposÛb obs≥u-
gi przyczynia siÍ do zmniejszenia kodu programu oraz do zwiÍkszenia jego czytel-
noúci. Metodπ tπ moøemy obs≥uøyÊ kilka komponentÛw jednego typu, tzn. tylko
ComboBox lub ListBox. Gdyby takiej moøliwoúci nie by≥o, to 20 zdarzeÒ trzeba
by≥oby wykonywaÊ oddzielnie.

SposÛb wykonania:

Wybierz kilka komponentÛw GroupBox

(sposÛb wybrania i umieszczenia

komponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety kompo-
nentÛw (karta Standard) i rozmieúÊ je zgodnie z rysunkiem 5.23.1.

Wybierz kilka komponentÛw Edit

(karta Standard) oraz jeden komponent

Button

(karta Standard) i umieúÊ je w pierwszym komponencie GroupBox

wed≥ug rysunku 5.23.1.

Wybierz ten przycisk i kliknij go dwukrotnie i w wygenerowanej procedurze
wpisz kod:

procedure TForm1.bEditClick(Sender: TObject);

var

TT: Byte;

// Deklaracja zmiennej

TC: TEdit;

// Utworzenie obiektu TC

begin

// WyczyúÊ wszystkie komponenty Edit i wpisz s≥owo "Bond"

for TT:= 1 to 4 do

// Okreúlenie iloúci komponentÛw na formatce (np. 4).

begin

// Wyszukuje komponenty o podanej nazwie.

TC:= TEdit(FindComponent('Edit'+IntToStr(TT)));

∆wiczenia z podstawowych komponentÛw Delphi

// Pozwala na zmianÍ w≥aúciwoúci kilku takim samym komponentom.

TC.Font.Color:= clBlue;

// Zmiana koloru na niebieski we wszystkich Editíach.

TC.Text:= 'Bond';

// Wpisanie s≥owa "Bond" we wszystkich komponentach Edit.

end;

Wybierz kilka komponentÛw SpeedButton

(karta Additional) i umieúÊ je

w drugim komponencie GroupBox zgodnie z rysunkiem 5.23.1.

Kliknij dwukrotnie pierwszy przycisk SpeedButton i w wygenerowanej proce-
durze wpisz kod:

procedure TForm1.SpeedButton1Click(Sender: TObject);

begin

// Obs≥uga kilku przyciskÛw za pomocπ jednej funkcji.

{

Sender ñ jest referencjπ do obiektu, ktÛrego dotyczy dane zdarzenie

(np. klikniÍcie myszkπ)

(Sender as TSpeedButton).Caption ñ konstrukcja ta umoøliwia

przekazanie w≥asnoúci, ktÛre sπ wspÛlne dla wszystkich

komponentÛw SpeedButton. W tym przyk≥adzie chodzi o

przekazanie napisÛw na przyciskach.

}

ShowMessage('Wybrałeś:'+CHR(32)+(Sender as TSpeedButton).Caption);

if ((Sender as TSpeedButton).Caption = '1') then ShowMessage('Jeden');

if ((Sender as TSpeedButton).Caption = '2') then ShowMessage('Dwa');

if ((Sender as TSpeedButton).Caption = '3') then ShowMessage('Trzy');

if ((Sender as TSpeedButton).Caption = '4') then ShowMessage('Cztery');

if ((Sender as TSpeedButton).Caption = '5') then ShowMessage('Pięć');

if ((Sender as TSpeedButton).Caption = '6') then ShowMessage('Sześć');

end;

Wybierz drugi przycisk i we w≥aúciwoúci OnClick karty Events w okno Object
Inspector w liúcie rozwijanej, wybierz nazwÍ procedury obs≥ugujπcej pierwszy
przycisk (w naszym przyk≥adzie jest to procedura SpeedButton1Click). PostÍpuj
tak z resztπ przyciskÛw SpeedButton.

Wybierz dwa przyciski Button

(karta Standard) i umieúÊ je w trzecim kom-

ponencie GroupBox tak jak na rysunku 5.23.1.

Wybierz pierwszy przycisk Button i kliknij go dwukrotnie. W wygenerowanej
procedurze wpisz kod:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Obs≥uga kilku przyciskÛw za pomocπ jednej funkcji.

if ((Sender as TButton).Tag = 1) then
ShowMessage((Sender as TButton).Caption);
if ((Sender as TButton).Tag = 2) then
ShowMessage((Sender as TButton).Caption);

∆wiczenia z rozwiπzaniami

{

Tag ñ jest to numer kolejnego komponentu, ktÛry ustawia siÍ we w≥aúciwoúciach.

Za pomocπ tego numeru moøna ≥atwo zidentyfikowaÊ komponent.

}

end;

Wybierz drugi przycisk i we w≥aúciwoúci OnClick karty Events okna Object
Inspector w liúcie rozwijanej wybierz nazwÍ procedury obs≥ugujπcej pierwszy
przycisk (w naszym przyk≥adzie jest to procedura Button1Click).

∆wiczenie 5.24. UpDown

Wykonaj program, ktÛry bÍdzie zwiÍksza≥ lub zmniejsza≥ liczbÍ wyúwietlanπ w kompo-
nencie Edit. Rysunek 5.24.1 przedstawia wyglπd takiego programu.

Rysunek 5.24.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\UpDown

Opis komponentu:

UpDown umoøliwia zwiÍkszanie lub zmniejszanie liczby wyúwietlanej za po-
mocπ komponentu np. Edit. We w≥aúciwoúci Associate komponentu UpDown

znajdujπ siÍ listy komponentÛw, ktÛre mogπ byÊ z nim powiπzane.

Wybrane w≥aúciwoúci komponentu UpDown:
N Increment ñ w tej w≥aúciwoúci podajemy wartoúÊ o jakπ bÍdziemy zmniejszaÊ

lub zwiÍkszaÊ liczbÍ (np. 2 oznacza, øe liczba bÍdzie zwiÍkszana co 2 punkty.
domyúlnie wpisana jest wartoúÊ 1),

N ArrowKeys ñ umoøliwia zwiÍkszanie i zmniejszanie za pomocπ klawiatury

(True ñ w≥πczona klawiatura; False ñ wy≥πczona klawiatura),

N Max ñ okreúla maksymalnπ wartoúÊ,
N Min ñ okreúla minimalnπ wartoúÊ.

SposÛb wykonania:

Wybierz komponent UpDown

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Win32).

Wybierz komponent Edit

(karta Standard).

∆wiczenia z podstawowych komponentÛw Delphi

Wybierz w≥aúciwoúÊ Associate komponentu UpDown bÍdπc w oknie Object
Inspector i z listy rozwijanej wybierz Edit1. WybÛr ten spowoduje po≥πczenie
komponentu Edit z komponentem UpDown, ktÛry zostanie przysuniÍty do kom-
ponentu Edit.

∆wiczenie 5.25. ScrollBar

Wykonaj program, ktÛry bÍdzie przewija≥ rysunek w ograniczonym polu. Rysunek
5.25.1 przedstawia wyglπd programu.

Rysunek 5.25.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\ScrBar

Opis komponentu:

ScrollBar (Belka przewijania) jest komponentem, ktÛry s≥uøy do prze-
wijania np. obrazu wyúwietlanego na ograniczonym obszarze.

SposÛb wykonania:

Wybierz komponent Panel1

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Standard).

Wybierz komponent Image

(karta Additional) i ustaw go na komponencie

Panel1 tak, aby przesuwajπc komponent Panel1, komponent Image1 przesuwa≥
siÍ razem z nim.

Wybierz komponent ScrollBar

(karta Standard) i ustaw go pionowo (W≥a-

úciwoúÊ Kind = sbVertical) obok komponentu Panel1.

Wybierz komponent ScrollBar

(karta Standard) i ustaw go poziomo (W≥a-

úciwoúÊ Kind = sbHorizontal) obok komponentu Panel1.

Kliknij dwukrotnie formatkÍ i w wygenerowanej procedurze wpisz kod:

∆wiczenia z rozwiπzaniami

procedure TForm1.FormCreate(Sender: TObject);

begin

// Wczytanie obrazu do komponentu Image.

Image1.Picture.LoadFromFile('las.bmp');

// Przypisanie do w≥aúciwoúci Max komponentu ScrollBar faktycznej wielkoúci obrazka.

ScrollBar1.Max:= Image1.Picture.Bitmap.Height-Panel1.Height;

ScrollBar2.Max:= Image1.Picture.Bitmap.Width-Panel1.Width;

end;

Wybierz komponent ScrollBar po≥oøony pionowo i kliknij go dwukrotnie. W wy-
generowanej procedurze wpisz kod:

procedure TForm1.ScrollBar1Change(Sender: TObject);

begin

// Przewijanie obrazka w dÛ≥ i do gÛry.

Image1.Top:= (ScrollBar1.Position*-1);

end;

Wybierz komponent ScrollBar po≥oøony poziomo i kliknij go dwukrotnie. W wy-
generowanej procedurze wpisz kod:

procedure TForm1.ScrollBar2Change(Sender: TObject);

begin

// Przewijanie obrazka w prawo i w lewo.

Image1.Left:= (ScrollBar2.Position*-1);

end;

∆wiczenie 5.26. Splitter

Wykonaj program, ktÛry bÍdzie umoøliwia≥ zmianÍ dwÛch obszarÛw znajdujπcych siÍ
na jednej formatce. Na rysunku 5.26.1 przedstawiony jest taki program.

Rysunek 5.26.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Splitter

Opis komponentu:

Splitter jest to komponent, ktÛry umoøliwia zmianÍ obszaru prostokπtnego pod-
czas wykonywania programu. Przyk≥adem wykorzystania takiego komponentu

∆wiczenia z podstawowych komponentÛw Delphi

jest np. Eksplorator Windows, ktÛry jest podzielony na dwa panele. Granica tych
dwÛch paneli jest regulowana.

SposÛb wykonania:

Wybierz komponent ListBox1

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Standard) i we w≥aúciwoúci Align wybierz wartoúÊ alLeft.

Wybierz komponent Splitter

(karta Additional) i we w≥aúciwoúci Align wy-

bierz wartoúÊ alLeft.

Wybierz komponent Memo

(karta Standard) i we w≥aúciwoúci Align wy-

bierz wartoúÊ alClient.

∆wiczenie 5.27. Dynamiczne tworzenie komponentÛw

Wykonaj program, ktÛry wczyta 10 ikon do komponentÛw Image. Komponenty te majπ
byÊ tworzone w momencie wczytywania ikon oraz ma byÊ moøliwoúÊ zapisania na dysk
wczytanych rysunkÛw. Rysunek 5.27.1 przedstawia ten program.

Rysunek 5.27.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\dtwkom

Opis:

MoøliwoúÊ dynamicznego tworzenia obiektÛw skraca czas pisania programu przez
zastosowanie np. jednej funkcji do tworzenia kilku lub kilkunastu komponentÛw np.
Image w celu wczytania kilku lub kilkunastu obrazkÛw. Gdyby takiej moøliwoúci nie
by≥o, programista musia≥by na sztywno uk≥adaÊ kilkadziesiπt komponentÛw, co wy-
d≥uøy≥oby czas pisania programu, jak rÛwnieø zwiÍkszy≥oby moøliwoúÊ pope≥nienia
wiÍkszej liczby b≥ÍdÛw.

∆wiczenia z rozwiπzaniami

SposÛb wykonania:

Wybierz komponent ScrollBox

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Additional).

Wybierz komponent ListBox

(karta Standard).

U≥Ûø wyøej wybrane komponenty zgodnie z rysunkiem 5.27.1.

Napisz funkcjÍ wczytujπcπ nazwy plikÛw o rozszerzeniu Ñicoî do komponentu
ListBox. PostaÊ takiego kodu moøe wyglπdaÊ nastÍpujπco:

function TForm1.ListBoxSzukajPlikow(txtPath, txtExt: String): Shortint;

var

SR :TSearchRec;

begin

{

Wczytanie do listy nazwy plikÛw.

Jeøeli funkcja nie znajdzie plikÛw o odpowiednim

rozszerzeniu to zwrÛci wartoúÊ -1.

W przeciwnym przypadku zwrÛci wartoúÊ 1.

}

ListBoxSzukajPlikow:= -1;

ListBox1.Items.Clear;

// Wyczyszczenie zawartoúci listy.

{

W≥πczenie automatycznego dopasowania wysokoúci.

Umoøliwia widocznoúÊ ostatniego elementu listy.

}

ListBox1.IntegralHeight:= FALSE;

ListBox1.Sorted:= TRUE;

// W≥πczenie sortowania.

{

Sprawdzenie czy w katalogu istniejπ pliki o podanym rozszerzeniu.

FunkcjÍ wykonuje siÍ tak d≥ugo, aø wszystkie pliki spe≥niajπce

warunek zostanπ wczytane do ListBox'a.

}

if (FindFirst(Trim(txtPath+txtExt), faAnyFile, SR) = 0) then

begin

repeat

if (SR.Attr<>faDirectory) then

begin

ListBox1.Items.Add(Trim(SR.Name));

// Dodanie elementu

ListBoxSzukajPlikow:= 1;

// Funkcja zwraca 1, gdy dodany bÍdzie element

end;

until(FindNext(SR)<>0);

FindClose(SR);

end;

Zadeklaruj funkcjÍ przez wpisanie jej w sekcji opisowej (interface);

∆wiczenia z podstawowych komponentÛw Delphi

type

TForm1 = class(TForm)

function ListBoxSzukajPlikow(txtPath, txtExt: String): Shortint;

procedure FormCreate(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

Zadeklaruj obiekty Panel i Image jako tablice. PostaÊ deklaracji wyglπda nastÍ-
pujπco:

type

TForm1 = class(TForm)

procedure FormCreate(Sender: TObject);

private

{ Private declarations }

dccPanel: array[1..100] of TPanel;

// Deklaracja obiektu typu TPanel

dccImage: array[1..100] of TImage;

// Deklaracja obiektu typu TImage

public

{ Public declarations }

end;

Napisz funkcjÍ zapisujπcπ rysunki na dysk:

procedure TForm1.dccZapiszJako(Sender: TObject);

begin

// Zapisuje plik pod innπ nazwπ

// Wstawienie znaku pustego jako domyúlnej nazwy pliku.

SavePictureDialog1.FileName:='';

// Uruchomienie okna dialogowego do zapisu rysunku.

SavePictureDialog1.Execute;

{

Sprawdzenie, czy zosta≥a podana nazwa pliku.

Jeøeli tak, to dokonaj zapisu, w przeciwnym przypadku nie wykonuj nic.

}

if (Trim(SavePictureDialog1.FileName)<>'') then

begin

// Zapisanie pliku na dysk.

dccImage[(Sender as TImage).Tag].Picture.SaveToFile
(Trim(SavePictureDialog1.FileName));

{

(Sender as TImage).Tag ñ konstrukcja ta umoøliwia

przekazanie w≥asnoúci, ktÛre sπ wspÛlne dla wszystkich

komponentÛw Image. W tym przyk≥adzie chodzi o

przekazanie identyfikatora wybranego komponentu Image.

Sender ñ jest referencjπ do obiektu, ktÛrego dotyczy zdarzenie

(np. klikniÍcie myszkπ)

}

end;

∆wiczenia z rozwiπzaniami

Zadeklaruj funkcjÍ przez wpisanie jej w sekcji opisowej (interface);

type

TForm1 = class(TForm)

procedure dccZapiszJako(Sender: TObject);

procedure FormCreate(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

Kliknij tÍ formÍ dwukrotnie i w wygenerowanej procedurze wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

var

TT, numY: Integer;

// Deklaracja zmiennych

begin

// Wyszukanie dostÍpnych ikon w bieøπcym katalogu.

ListBoxSzukajPlikow('', '*.ico');

// Przypisanie zmiennej 'numY' wartoúci zero.

numY:= 0;

// Dynamiczne tworzenie komponentu.

for TT:= 0 to ListBox1.Items.Count-1 do

begin

//-- Panel --

// Utworzenie obiektu typu TPanel

dccPanel[1+TT]:= TPanel.Create(ScrollBox1);

{

dccPanel[1+TT]:= TPanel.Create(ScrollBox1);

Wszystkie komponenty posiadajπ konstruktor Create, ktÛry

jest wywo≥ywany z jednym parametrem. Parametr ten okreúla

w≥aúciciela tworzonego obiektu. NajczÍúciej w≥aúcicielem

tworzonego obiektu jest obiekt formatki (czyli Form1), na

ktÛrym to ma siÍ znaleüÊ tworzony obiekt.

}

// Ustalenie pozycji Y

dccPanel[1+TT].Top:= 9+numY;

// Ustalenie pozycji X

dccPanel[1+TT].Left:= 9;

// Ustalenie szerokoúci

dccPanel[1+TT].Width:= 49;

// Ustalenie wysokoúci

dccPanel[1+TT].Height:= 49;

// Wyczyszczenie wyúwietlanego tekstu

dccPanel[1+TT].Caption:= '';

// Umieszczenie utworzonego obiektu na np. formatce

ScrollBox1.InsertControl(dccPanel[1+TT]);

//-- Image --

// Utworzenie obiektu typu TImage

dccImage[1+TT]:= TImage.Create(dccPanel[1+TT]);

// Ustalenie pozycji Y

∆wiczenia z podstawowych komponentÛw Delphi

dccImage[1+TT].Top:= 2;

// Ustalenie pozycji X

dccImage[1+TT].Left:= 3;

// Ustalenie szerokoúci

dccImage[1+TT].Width:= dccPanel[1+TT].Width-5;

// Ustalenie wysokoúci

dccImage[1+TT].Height:= dccPanel[1+TT].Height-5;

// Wy≥πczenie przeüroczystoúci komponentu Image.

dccImage[1+TT].Transparent:= FALSE;

{

Wy≥πczenie moøliwoúci dopasowywania siÍ

komponentu Image do wielkoúci rysunku.

}

dccImage[1+TT].AutoSize:= FALSE;

// Wy≥πczenie moøliwoúci rozciπgniÍcia rysunku.

dccImage[1+TT].Stretch:= FALSE;

// Umieszczenie obrazka w úrodku

dccImage[1+TT].Center:= TRUE;

// Wczytanie obrazka

dccImage[1+TT].Picture.LoadFromFile(ListBox1.Items[TT]);

// Przypisanie metody "dccZapiszJako" do zdarzenia OnClick.

dccImage[1+TT].OnClick:= dccZapiszJako;

// Nadanie identyfikatora tworzonym obiektom.

dccImage[1+TT].Tag:= 1+TT;

{

W≥πczenie moøliwoúci wyúwietlania podpowiedzi w

momencie najechania kursorem myszy na dany obiekt.

}

dccImage[1+TT].ShowHint:= TRUE;

// Wstawienie do podpowiedzi nazwy plikÛw.

dccImage[1+TT].Hint:= ListBox1.Items[TT];

// Umieszczenie utworzonego obiektu na np. formatce

dccPanel[1+TT].InsertControl(dccImage[1+TT]);

{

Licznik umoøliwiajπcy wstawienie tworzonych

obiektÛw z gÛry do do≥u o pewnπ wielkoúÊ

(np. wysokoúÊ tworzonych obiektÛw).

}

numY:= numY+55;

end;

∆wiczenie 5.28. Wczytanie czcionek do listy ComboBox i ListBox

Wykonaj program, ktÛry wczyta dostÍpne w systemie czcionki do listy ComboBox
i ListBox. Rysunek 5.28.1. przedstawia wyglπd takiego programu.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Fonty

∆wiczenia z rozwiπzaniami

Rysunek 5.28.1.

SposÛb wykonania:

Wybierz komponent ComboBox

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Standard).

Wybierz komponent ListBox

(karta Standard).

Wybierz trzy komponenty Label

(karta Standard) i dwa z nich opisz wed≥ug

rysunku 5.28.1.

U≥Ûø wyøej wybrane komponenty zgodnie z rysunkiem 5.28.1.

Kliknij formÍ dwukrotnie i w wygenerowanej procedurze wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

//-- ComboBox --

// Wstawienie czcionek do komponentu ComboBox.

ComboBox1.Items.Clear;

// Wyczyszczenie listy.

// Wstawienie dostÍpnych czcionek do listy.

ComboBox1.Items.Assign(Screen.Fonts);

// Wyczyszczenie zawartoúci edytora.

ComboBox1.Text:= '';

//-- ListBox --

// Wstawienie czcionek do komponentu ListBox.

ListBox1.Items.Clear;

// Wyczyszczenie listy.

// Wstawienie dostÍpnych czcionek do listy.

ListBox1.Items.Assign(Screen.Fonts);

end;

∆wiczenia z podstawowych komponentÛw Delphi

Zaznacz komponent ComboBox i kliknij go dwukrotnie, a w wygenerowanej
procedurze wpisz kod:

procedure TForm1.ComboBox1Change(Sender: TObject);

begin

// Pokaø czcionkÍ po jej wybraniu.

Label3.Font.Name:= ComboBox1.Text;

end;

Zaznacz komponent ListBox i kliknij go dwukrotnie i w wygenerowanej proce-
durze wpisz kod:

procedure TForm1.ListBox1Click(Sender: TObject);

begin

// Pokaø czcionkÍ po jej wybraniu.

if (ListBox1.ItemIndex >-1) then

{

Sprawdzenie czy zosta≥ zaznaczony

element, jeúli tak to wykonaj warunek ÑListBox1.ItemIndex >-1î.

}

begin

Label3.Font.Name:= ListBox1.Items[ListBox1.ItemIndex];

// Zmiana czcionki

end;

∆wiczenie 5.29. Instalacja nowych komponentÛw

Zainstaluj nowe komponenty, ktÛre znajdujπ siÍ w katalogu

Delphi\Nowe_Komponenty

W katalogu tym znajduje siÍ miÍdzy innymi komponent do odczytywania obrazÛw JPG,
ozdobny przycisk, do wyboru folderu i kilka innych.

SposÛb wykonania:

Wybierz menu Component (Komponent).

Wybierz opcjÍ Install component (Instaluj komponent).

Wybierz przycisk Browse (Przeglπdaj), ktÛry znajduje siÍ obok okna Unit file
name (rysunek 5.29.1).

W ukazanym oknie wybierz nazwÍ pliku i naciúnij przycisk OK.

Gdy plik zosta≥ juø wybrany naciúnij przycisk OK.

Po dodaniu komponentu zobaczysz okno (rysunek 5.29.2) z zainstalowanymi
komponentami.

Zamknij okno przedstawione na rysunku 5.29.2.

Odpowiedz twierdzπco przy pytaniu, ktÛre dotyczy zapisania zainstalowanych
komponentÛw.

∆wiczenia z rozwiπzaniami

Rysunek 5.29.1.

Rysunek 5.29.2.

∆wiczenie 5.30. Dymki (Podpowiedzi)

Napisz program, ktÛry wyúwietli opis np. przyciskÛw po najechaniu na nie myszπ. Ry-
sunek 5.30.1 przedstawia program w dzia≥aniu.

Rysunek 5.30.1.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Dymki

∆wiczenia z podstawowych komponentÛw Delphi

Opis:

Dymki (podpowiedzi) sπ komunikatem dla uøytkownika informujπcymi o przeznacze-
niu danej funkcji programu. Sπ one wyúwietlane dopiero po najechaniu myszπ na dany
element. Podpowiedzi te znajdujπ siÍ w ma≥ym okienku, ktÛrego parametry moøna
zmieniaÊ.

Gdy informacja jest za d≥uga, dobrze jest przenieúÊ jej fragment do nastÍpnego wier-
sza.

Dokonujemy tego przez wstawienie do naszego ≥aÒcucha w stosownym miejscu znaku
z kodem Entera, aby podpowiedü wyúwietlona zosta≥a w nastÍpnym wierszu.

Np.

Button1.Hint:= 'To jest podpowiedź na temat klawisza, '+CHR(13)+

'nad którym znajduje się wskaźnik myszy.'+CHR(13)+

'Gdy informacja jest za długa to dobrze '+CHR(32)+

'jest przenieść jej fragment do następnego wiersza';

SposÛb wykonania:

Wybierz przycisk Button

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard) i opisz go zgodnie z rysunkiem 5.30.1.

Kliknij formÍ dwukrotnie i w wygenerowanym zdarzeniu OnCreate wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

// Ustawienie parametrÛw dla dymkÛw.

Application.HintColor:= clLime;

// Ustawienie koloru dla dymku.

// Ustawienie czasu, po ktÛrym ukaøe nam siÍ dymek z podpowiedziπ.

Application.HintPause:= 100;

// Ustawienie czasu, okreúlajπcego jak d≥ugo dymek bÍdzie wyúwietlany.

Application.HintHidePause:= 5000;

Button1.ShowHint:= TRUE;

// W≥πczenie podpowiedzi.

// Button1.Hint ñ Wpisanie podpowiedzi pod konkretny komponent (np. przycisk)

Button1.Hint:= 'To jest podpowiedź na temat klawisza, nad którym
znajduje się wskaźnik myszy.'+CHR(13)+ 'Gdy informacja jest za długa
to dobrze jest przenieść jej fragment do następnego wiersza.';
end;

∆wiczenie 5.31. MDI (aplikacja wielodokumentowa)

Napisz program, w ktÛrym bÍdzie moøliwe otwarcie kilku okien naraz. Rysunek 5.31.1
przedstawia program w dzia≥aniu.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Mdi

∆wiczenia z rozwiπzaniami

Rysunek 5.31.1.

Opis:

Aplikacje o interfejsie wielodokumentowym mogπ jednoczeúnie otwieraÊ i wyúwietlaÊ
kilka plikÛw. Aplikacja typu MDI (

Multiple Document Interface) dzieli siÍ na okno

g≥Ûwne (zwane rodzicem) i okna podrzÍdne (zwane dzieÊmi). Kaøde okno dziecka jest
oddzielnym dokumentem dzia≥ajπcym niezaleønie do innych okien dzieci. Okno
dziecka zawiera w≥asne menu, ktÛre jest niezaleøne do innych menu. Menu to tworzy
siÍ tak samo jak dla formatki, oddzielnie dla kaødego okna dziecka. Wszystkie okna
dzieci sπ wyúwietlane na wspÛlnym obszarze rodzica i nie mogπ wyjúÊ poza ten ob-
szar. Wyjúcie poza ten obszar spowoduje chowanie siÍ okna dziecka. Pomimo wy-
úwietlania duøej iloúci okien dzieci, uøytkownik moøe pracowaÊ w danej chwili tylko
na jednym oknie dziecka.

SposÛb tworzenia aplikacji MDI:

Wybierz opcjÍ New (Nowy) z menu File (Plik).

Wybierz kartÍ Projects (Projekty).

Wybierz projekt o nazwie MDI application.

Zatwierdü wybÛr przyciskiem OK.

NastÍpnie program poprosi o wskazanie katalogu, do ktÛrego zostanie zapisany
wygenerowany kod.

Po wybraniu katalogu zatwierdü wybÛr przyciskiem OK.

∆wiczenia z podstawowych komponentÛw Delphi

Po tych czynnoúciach aplikacja typu MDI jest juø wygenerowana.

Poniøej sπ zamieszczone fragmenty kodu, ktÛre umoøliwiajπ dodanie nowego okna
dziecka:

Deklaracja okna dziecka znajduje siÍ w sekcji Private (Prywatne).

private

{ Private declarations }

procedure CreateMDIChild1(const Name: string);

Natomiast modu≥ deklarujemy po s≥owie uses. W tym przypadku jest to okno dziecka.

uses Child1;

NastÍpnie umieszczona zostaje funkcja wywo≥ujπca okno dziecka:

procedure TMainForm.CreateMDIChild1(const Name: string);

var

Child: TmdiChild1;

begin

{ create a new MDI child window }

Child := TmdiChild1.Create(Application);

Child.Caption := Name;

end;

ZamkniÍcie okna dziecka jest moøliwe dziÍki wywo≥aniu funkcji:

procedure TMainForm.FileCloseItemClick(Sender: TObject);

begin

// ZamkniÍcie aktywnego okna dziecka

if ActiveMDIChild <> nil then

ActiveMDIChild.Close;

end;

Uruchomienie funkcji znajdujπcej siÍ w oknie dziecka za pomocπ przycisku znajdujπ-
cego siÍ w oknie g≥Ûwnym (oknie rodzica) wyglπda nastÍpujπco:

procedure TMainForm.sbWypiszHasloClick(Sender: TObject);

begin

// Uruchamia funkcjÍ z menu, ktÛre znajduje siÍ w oknach dzieci

// Uruchomienie Funkcji "ListBoxNapis1Click(Sender);" w Dziecku 1 (Child1)

if ActiveMDIChild is TmdiChild1 then

TmdiChild1(ActiveMDIChild).ListBoxNapis1Click(Sender);

end;

Uruchomienie funkcji w innym oknie dziecka (okno ma innπ nazwÍ np. TmdiChild2)
wyglπda tak samo, z jedynπ rÛønicπ. Polega ona na zmianie nazwy okna TmdiChild1
na TmdiChild2. NazwÍ okna formatki wpisujemy we w≥aúciwoúci Name wybranej
formatki.

Uruchomienie funkcji znajdujπcej siÍ w oknie rodzica z okna dziecka wyglπda nastÍ-
pujπco:

∆wiczenia z rozwiπzaniami

procedure TmdiChild1.bOtworzPlikClick(Sender: TObject);

begin

// Uruchamia opcjÍ znajdujπcπ siÍ w oknie rodzica z poziomu okna dziecka.

MainForm.FileOpenItemClick(Sender);

{

MainForm.FileOpenItemClick(Sender); ñ Uruchomienie funkcji

MainForm ñ Nazwa okna rodzica

FileOpenItemClick(Sender) ñ Nazwa funkcji znajdujπcej siÍ w oknie rodzica

}

end;

Jak na aplikacjÍ wielodokumentowπ przysta≥o, moøliwe jest otwarcie kilku takich sa-
mych lub rÛønych okien (np. wybierz dwa razy opcjÍ Nowy (ListBox) ñ spowoduje
pojawienie siÍ dwÛch takich samych okien). Istnieje jednak potrzeba, aby jakieú okno
(np. do przeglπdania plikÛw) by≥o otwarte tylko raz niezaleønie od iloúci wybierania
danej opcji (w tym przyk≥adzie jest to opcja Przeglπdaj...). Wybranie tej opcji po-
nownie (po wywo≥aniu okna Przeglπdaj...) spowoduje uaktywnienie tego okna
z automatycznym przesuniÍciem go na plan g≥Ûwny. Funkcja, ktÛra to wykonuje wy-
glπda nastÍpujπco:

procedure TMainForm.FilePrzegldajClick(Sender: TObject);

const

// Zadeklarowanie sta≥ej okreúlajπcej nazwÍ okienka s≥uøπcego do przeglπdania plikÛw.

txtPrzeglad ='Przeglądaj...';

var

TT: Integer;

// Zadeklarowanie zmiennej liczbowej

okCzyIstnieje: Boolean;

// Zadeklarowanie zmiennej logicznej

begin

// Uruchomienie przeglπdania plikÛw.

okCzyIstnieje:= FALSE;

// Przypisanie zmiennej wartoúci FALSE (fa≥sz)

// Sprawdzenie, ktÛre okno s≥uøy do przeglπdania plikÛw.

for TT:= MDIChildCount – 1 downto 0 do

if (MDIChildren[TT].Caption = txtPrzeglad) then

begin

// Gdy okno zostanie znalezione, to uaktywnij go i daj na pierwszy plan.

MDIChildren[TT].BringToFront;

// Przesuwa okna na pierwszy plan

MDIChildren[TT].WindowState:= wsNormal;

// Powoduje ukazanie siÍ okna

// Przypisanie zmiennej 'okCzyIstnieje' wartoúci TRUE jeøeli okno do przeglπdania

// plikÛw zosta≥o znalezione (jest uaktywnione).

okCzyIstnieje:= TRUE;

end;

// Uruchomienie okna do przeglπdania plikÛw, jeøeli zmienna 'okCzyIstnieje'

// rÛwna siÍ FALSE.

if (okCzyIstnieje = FALSE) then CreateMDIChildPrzegladaj(txtPrzeglad);

end;

Tworzπc menu w oknie rodzica trzeba uwaøaÊ, øeby menu utworzone w oknie dziecka
nie zastπpi≥o menu w oknie rodzica (chyba øe jest to konieczne). Moøna temu zapo-

∆wiczenia z podstawowych komponentÛw Delphi

biec przez nadanie numeru rÛønego od zera wybranej opcji menu (np. menu Okno) we
w≥aúciwoúci GroupIndex, co powoduje po≥πczenie siÍ dwÛch menu rodzica i dziecka.

∆wiczenie 5.32. Wczytanie pliku przez podanie jego nazwy jako parametr

Wykonaj program, ktÛry wczyta plik lub pliki w momencie uruchomienia przez klikniÍ-
cie na nazwie pliku.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\ParamStr

Aby przyk≥ad zadzia≥a≥ naleøy program wywo≥aÊ za pomocπ opcji Uruchom w menu
Start piszπc nastÍpujπcπ sk≥adniÍ:

view.exe egipt.bmp fale.bmp

Opis:

MoøliwoúÊ wczytywania pliku do programu przez podanie go jako parametru jest
wygodnym rozwiπzaniem zwalniajπcym uøytkownika od wywo≥ywania funkcji do
wczytania pliku. Zamiast tego moøe on uruchomiÊ program z podaniem nazwy pliku,
co spowoduje uruchomienie aplikacji z automatycznym wczytaniem pliku podanego
jako parametr. Umoøliwia to rÛwnieø skojarzenie plikÛw z konkretnπ aplikacjπ, przez
co wybÛr danego pliku (np. w Eksploratorze) spowoduje uruchomienie siÍ konkretnej
aplikacji.

SposÛb wykonania:

Kliknij dwukrotnie formatkÍ i w wygenerowanym zdarzeniu OnCreate lub
OnShow wpisz kod odpowiedzialny za wczytanie pliku przy uruchomieniu pro-
gramu. W naszym przyk≥adzie kod bÍdzie umieszczony w zdarzeniu OnShow:

procedure TfrmForm1.FormShow(Sender: TObject);

var

TT: Integer;

// Deklaracja zmiennej

begin

// Wyliczanie iloúci parametrÛw podanych w

// momencie uruchomienia aplikacji (programu).

for TT:= 1 to ParamCount do

if (Trim(ParamStr(TT))<>'') then Viewer(Trim(ParamStr(TT)));

{

ParamStr(TT) ñ funkcja zwraca parametr o podanym numerze w wywo≥anym programie.

Funkcja ParamCount zwraca liczbÍ parametrÛw podanych

wywo≥aniu aplikacji. Parametry oddziela siÍ znakiem spacji.

Przyk≥ady:

ParamStr(0) ñ zwraca úcieøkÍ dostÍpu i nazwÍ uruchomionej

aplikacji (programu).

ParamStr(1) ñ zwraca parametr, ktÛry by≥ podany w momencie

wywo≥ania aplikacji (programu).

}

end;

∆wiczenia z rozwiπzaniami

∆wiczenie 5.33. Uruchomienie innego programu z poziomu aplikacji

Wykonaj program, ktÛry bÍdzie uruchamiaÊ programy KALKULATOR i NOTATNIK.
Rysunek 5.33.1 przedstawia okno z kontrolkami takiego programu.

Rysunek 5.33.1

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\RunApp

Opis:

MoøliwoúÊ uruchomienia innego programu (np. kalkulatora) z naszego programu jest
bardzo wygodnym u≥atwieniem zwalniajπcym uøytkownika z dodatkowych czynnoúci
zwiπzanych z uruchomieniem programu (np. kalkulatora w celu dokonania jakichú
obliczeÒ).

SposÛb wykonania:

Wpisz nazwÍ biblioteki ShellApi w deklaracji Uses, np. Ñuses ShellApiî (bez tej
deklaracji funkcja ShellExecute nie bÍdzie dzia≥aÊ).

Wybierz przycisk Button

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Kliknij przycisk dwukrotnie i w wygenerowanym zdarzeniu wpisz kod:

procedure TForm1.bUruchomKalkulatorClick(Sender: TObject);

begin

// Uruchomienie programu Kalkulator (calc.exe)

ShellExecute(Handle, 'open', 'calc.exe', '', '', sw_Normal);

end;

Tak samo postÍpuj przy drugim klawiszu zmieniajπc nazwÍ programu.

∆wiczenie 5.34. Pozycja kursora myszy

Napisz program, ktÛry bÍdzie pokazywa≥ pozycjÍ kursora myszy. Rysunek 5.34.1 poka-
zuje wyglπd takiego programu.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Pkursora

100

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.34.1.

SposÛb wykonania:

Wybierz okno Object Inspector.

Wybierz kartÍ Events.

Wybierz zdarzenie OnMouseMove i kliknij je dwukrotnie.

W wygenerowanej procedurze wpisz kod:

procedure TForm1.FormMouseMove(Sender: TObject; Shift: TShiftState; X,

Y: Integer);

var

// Zadeklarowanie obiektu reprezentujπcego punkty na ekrania.

Position: TPoint;

begin

// Podanie pozycji kursora myszy w momencie poruszania nim.

GetCursorPos(Position);

// Wyúwietlenie pozycji kursora myszy na ekranie za pomocπ komponentu Label.

Label1.Caption:= 'X:'+CHR(32)+IntToStr(Position.X-Left)+CHR(32)+

'/'+CHR(32)+'Y:'+CHR(32)+IntToStr(Position.Y-Top);

end;

∆wiczenie 5.35. Zamiana znakÛw w tekúcie

Napisz program, ktÛry bÍdzie zamienia≥ jeden ciπg znakÛw na inny ciπg znakÛw. Rysu-
nek 5.35.1 przedstawia taki program.

Rysunek 5.35.1.

∆wiczenia z rozwiπzaniami

101

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\zm_znak

SposÛb wykonania:

Wybierz kilka komponentÛw Label

i kilka komponentÛw Edit

(sposÛb

wybrania i umieszczenia komponentu na formatce opisany zosta≥ w podrozdziale
1.1) z palety komponentÛw (karta Standard).

Wybierz przycisk BitBtn

(karta Additional).

Wybrane komponenty rozmieúÊ na formatce zgodnie z rysunkiem 5.35.1.

Napisz funkcjÍ zamieniajπcπ jeden ciπg znakÛw na inny:

function jbZnajdzZamien(txtText, txtFind, txtReplace: String) :String;

var

numPos, numLen: Integer;

// Deklaracja zmiennych

begin

// Funkcja zamienia ciπg znakÛw na inny ciπg znakÛw

numLen:= 0;

numLen:= Length(txtFind);

// Obliczenie d≥ugoúci ciπgu znakÛw

{

AnsiUpperCase()

Zamiana liter (ciπgu znakÛw) na duøe litery (ciπgu znakÛw)

-----------------------------------------------------------

Pos(Szukany_Tekst, Tekst_w_KtÛrym_siÍ_Szuka)

Zwraca pozycjÍ znalezionego ciπgu znakÛw

}

while (Pos(AnsiUpperCase(txtFind), AnsiUpperCase(txtText)) > 0) do

begin

{

PÍtla jest wykonywana tak d≥ugo, jak d≥ugo bÍdzie wystÍpowa≥

wyszukiwany ciπg znakÛw. W przypadku nie znalezienia szukanego

ciπgu znakÛw, pÍtla nie wykona siÍ ani razu.

}

// Podawanie pozycji znalezionego tekstu (ciπgu znakÛw)

numPos:= 0;

numPos:= Pos(AnsiUpperCase(txtFind), AnsiUpperCase(txtText));

// UsuniÍcie znalezionego tekstu (ciπgu znakÛw)

Delete(txtText, numPos, numLen);

// Wstawienie nowego tekstu (ciπgu znakÛw) w miejsce starego

Insert(txtReplace, txtText, numPos);

end;

jbZnajdzZamien:= txtText;

end;

Zaznacz przycisk OK i kliknij go dwukrotnie. Po wygenerowaniu procedury
wpisz kod:

procedure TForm1.BitBtn1Click(Sender: TObject);

begin

// Wywo≥anie funkcji zamieniajπcej ciπgi znakÛw.

102

∆wiczenia z podstawowych komponentÛw Delphi

Memo1.Lines.Clear;

// Wyczyszczenie komponentu Memo1

// Dodanie efektu zamiany tekstu (ciπgu znakÛw) do Memo1

Memo1.Lines.Add(jbZnajdzZamien(

Edit1.Text,

Edit2.Text,

Edit3.Text

));

end;

∆wiczenie 5.36. Grafika

Napisz program, ktÛry narysuje figury geometryczne i napisze tekst na formie (p≥Ûtnie).
Rysunek 5.36.1 przedstawia taki program.

Rysunek 5.36.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Canvas

Opis:

Kaødej formatce przypisana jest w≥asnoúÊ Canvas (P≥Ûtno), ktÛra pochodzi od obiektu
TCanvas. Obiekt ten udostÍpnia funkcje do tworzenia grafiki i wypisywania tekstu.

SposÛb wykonania:

Wybierz komponent Button

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Standard).

Zaznacz ten przycisk i dwukrotnie go kliknij.

W wygenerowanej procedurze wpisz kod:

procedure TForm1.bCanvasClick(Sender: TObject);

begin

// Wyczyszczenie obszaru rysowania.

with Canvas do

begin

∆wiczenia z rozwiπzaniami

103

// Ustalenie stylu wype≥niania

Brush.Style:= bsSolid;

// Ustalenie koloru rysowania

Brush.Color:= clWhite;

// Wype≥nienie aktywnego obszaru

FillRect(ClipRect);

{

ClipRect ñ Reprezentuje bieøπcy prostokπt na

ktÛrym sπ dokonywane operacje graficzne.

}

end;

//-- Ko≥o --

// Ustalenie koloru jakim bÍdzie narysowana figura.

Canvas.Pen.Color:= clBlack;

// Ustalenie koloru jakim bÍdzie wype≥niona figura.

Canvas.Brush.Color:= clRed;

// Narysowanie ko≥a

Canvas.Ellipse(9, 9, 34, 34);

//-- Kwadrat --

// Ustalenie koloru jakim bÍdzie narysowana figura.

Canvas.Pen.Color:= clBlack;

// Ustalenie stylu piÛra

Canvas.Pen.Style:= psDot;

// Ustalenie koloru jakim bÍdzie wype≥niona figura.

Canvas.Brush.Color:= clRed;

// Ustalenie stylu wype≥niania

Canvas.Brush.Style:= bsDiagCross;

// Narysowanie kwadratu

Canvas.Rectangle(39, 9, 66, 36);

//-- Linia --

Canvas.MoveTo(66, 66);

// Okreúlenie poczπtku linii

Canvas.LineTo(366, 66);

// Narysowanie linii

//-- Ko≥o pochylone --

// Ustalenie koloru jakim bÍdzie narysowana figura.

Canvas.Pen.Color:= clBlack;

// Ustalenie koloru jakim bÍdzie wype≥niona figura.

Canvas.Brush.Color:= clRed;

// Ustalenie stylu wype≥niania

Canvas.Brush.Style:= bsCross;

// Narysowanie kwadratu

Canvas.Chord(199, 9, 77, 46, 8, 8, 8, 8);

//-- Tekst --

// Ustalenie czcionki tekstu

Canvas.Font.Name:= 'Arial';

// Ustalenie koloru tekstu

Canvas.Font.Color:= clGreen;

// Ustalenie stylu tekstu

Canvas.Font.Style:= [fsBold, fsItalic, fsUnderline];

// Ustalenie wielkoúci tekstu

104

∆wiczenia z podstawowych komponentÛw Delphi

Canvas.Font.Size:= 33;

// Wypisanie tekstu na ekranie

Canvas.TextOut(23, 88, 'To jest tekst.');

end;

∆wiczenie 5.37. Funkcja s≥ownie

Napisz program, ktÛry bÍdzie zamienia≥ cyfry na s≥owa z zachowaniem gramatyki. Ry-
sunek 5.37.1 przedstawia taki program.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Slownie

Rysunek 5.37.1.

SposÛb wykonania:

Wybierz komponent Edit

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Wybierz komponent Memo

(karta Standard).

Wybierz komponent Button

(karta Standard), umieúÊ go na formie z prawej

strony komponentu Edit i opisz go zgodnie z rysunkiem 5.37.1.

Kliknij ten przycisk dwukrotnie i w wygenerowanej procedurze wpisz kod:

procedure TfrmMain.bSayClick(Sender: TObject);

begin

// S≥ownie

Memo1.lines.Clear;

Memo1.lines.Add(plnSlownie(eNumber.Text));

{

plnSlownie('Cyfra') ñ wywo≥anie funkcji, ktÛra zamienia cyfry

∆wiczenia z rozwiπzaniami

105

traktowane jako ciπg znakÛw na wyrazy.

Przyk≥ad:

63273,46 ñ szeúÊdziesiπt trzy tysiπce dwieúcie siedemdziesiπt

trzy z≥ote i czterdzieúci szeúÊ groszy

UWAGA:

Funkcja bierze pod uwagÍ tylko dwa miejsca po przecinku.

}

end;

Zadeklaruj bibliotekÍ Slownie w deklaracji uses, np.

uses Slownie

W ostatnim kroku napisz bibliotekÍ do konwersji liczb na s≥owa. Przyk≥adowa
biblioteka moøe wyglπdaÊ tak:

unit Slownie;

interface

uses

SysUtils;

function plnSlownie(txtNumber: String) :String;

implementation

{

Funkcja dodaje zero do pojedynczej liczby traktowanej

jako tekst, w innym przypadku zwraca dwie liczby.

Przyk≥ad:

1) 10 ñ zwrÛci nam liczbÍ dziesiÍÊ traktowanπ jako tekst

2) 3 ñ zwrÛci nam liczbÍ 03 traktowanπ jako tekst, przez dodanie zera przed liczbπ trzy

}

function FillZero(txtZero: String): String;

begin

FillZero:= txtZero;

if (Length(txtZero) =1) then FillZero:= '0'+txtZero;

end;

{

Funkcja wyszukuje w ≥aÒcuchu tekstowym przecinek i zamienia go na kropkÍ,

w przeciwnym przypadku nie dokonuje zamiany przecinka na kropkÍ.

Przyk≥ad:

1234,45 -> 1234.45

}

function CommaToDot(txtText: String): String;

var

txtRText: String;

numPos: Shortint;

begin

CommaToDot:= Trim(txtText);

if (Trim(txtText)<>'') then

begin

numPos:= 0;

numPos:= Pos(',', Trim(txtText));

if (numPos<>0) then

begin

txtRText:= '';

txtRText:= Copy(Trim(txtText), 1, numPos-1)+'.'+

Copy(Trim(txtText), numPos+1, Length(Trim(txtText)));

106

∆wiczenia z podstawowych komponentÛw Delphi

CommaToDot:= Trim(txtRText);

end;

// Funkcja konwertujπca liczbÍ na tekst

function mcIntToStr(numNumber: Longint): String;

var

txtText: String;

begin

txtText:= '';

STR(numNumber, txtText);

// Konwertuje wartoúÊ cyfrowπ na tekst.

mcIntToStr:= txtText;

end;

// Funkcja konwertujπca liczbÍ traktowanπ jako tekst na liczbÍ

function mcStrToInt(txtText: String): Longint;

var

I: Integer;

A: Longint;

begin

A:= 0;

I:= 0;

VAL(txtText, A, I);

// Konwertuje tekst na wartoúÊ liczbowπ.

mcStrToInt:= A;

end;

{

Funkcje zamieniajπce cyfry traktowane jako tekst na s≥owa

np. 12356,26 -> dwanaúcie tysiÍcy trzysta piÍÊdziesiπt szeúÊ z≥otych

i dwadzieúcia szeúÊ groszy

}

function txtSlownieGramatyka(txtNumber: String; numPos, okPenny: Shortint)
:String;

// Deklaracja tablic dla funkcji S≥ownieGramatyka.

const

MM: array[1..9, 1..4] of String[20] =

(('sto ', 'dziesięć ', 'jeden ', 'jedenaście '),

('dwieście ', 'dwadzieścia ', 'dwa ', 'dwanaście '),

('trzysta ', 'trzydzieści ', 'trzy ', 'trzynaście '),

('czterysta ', 'czterdzieści ', 'cztery ', 'czternaście '),

('pięćset ', 'pięćdziesiąt ', 'pięć ', 'piętnaście '),

('sześćset ', 'sześćdziesiąt ', 'sześć ', 'szesnaście '),

('siedemset ', 'siedemdziesiąt ', 'siedem ', 'siedemnaście '),

('osiemset ', 'osiemdziesiąt ', 'osiem ', 'osiemnaście '),

('dziewięćset ', 'dziewięćdziesiąt ', 'dziewięć ', 'dziewiętnaście '));

NN: array[1..5, 1..3] of String[11] =

(('złoty ', 'złote ', 'złotych '),

('tysiąc ', 'tysiące ', 'tysięcy '),

('milion ', 'miliony ', 'milionów '),

('miliard ', 'miliardy ', 'miliardów '),

('bilion ', 'biliony ', 'bilionów '));

PP: array [1..3] of String[7] = ('grosz', 'grosze', 'groszy');

// Deklaracja zmiennych.

var

TT, JJ, numTPos: Shortint;

txtSay: String;

∆wiczenia z rozwiπzaniami

107

begin

// txtSlownieGramatyka

txtSlownieGramatyka:= '';

if (numPos < 1) then numPos:= 1;

if (Length(txtNumber) = 1) then txtNumber:= '00'+txtNumber;

if (Length(txtNumber) = 2) then txtNumber:= '0'+txtNumber;

txtSay:= '';

if (txtNumber<>'') and (Length(txtNumber) = 3) then

begin

if (mcStrToInt(Copy(txtNumber, 2, 2)) in [11..19]) and

(mcStrToInt(Copy(txtNumber, 1, 1)) = 0) then

begin

// 11..19 and = 0

txtSlownieGramatyka:= MM[mcStrToInt(Copy(txtNumber, 2, 2))-10,
4]+NN[numPos, 3];
if (okPenny >0) then

txtSlownieGramatyka:= MM[mcStrToInt(Copy(txtNumber, 2, 2))-10,
4]+PP[3];
end

else

if (mcStrToInt(Copy(txtNumber, 2, 2)) in [11..19]) and

(mcStrToInt(Copy(txtNumber, 1, 1)) > 0) then

begin

// 11..19 and > 0

txtSay:= '';

txtSay:= MM[mcStrToInt(Copy(txtNumber, 2, 2))-10, 4]+NN[numPos, 3];

if (okPenny >0) then

txtSay:= MM[mcStrToInt(Copy(txtNumber, 2, 2))-10, 4]+PP[3];

txtSlownieGramatyka:= MM[mcStrToInt(Copy(txtNumber, 1, 1)), 1]+txtSay;

end

else

begin

txtSay:= '';

for TT:= 1 to Length(txtNumber) do

for JJ:= 1 to 9 do

if (Copy(txtNumber, TT, 1) = mcIntToStr(JJ)) then

txtSay:= txtSay+MM[JJ, TT];

numTPos:= 0;

numTPos:= 1;

if (mcStrToInt(Copy(txtNumber, 3, 1)) in [2..4]) then numTPos:= 2;

if (mcStrToInt(Copy(txtNumber, 3, 1)) in [5..9]) or

(mcStrToInt(Copy(txtNumber, 2, 1)) in [2..9]) and

(mcStrToInt(Copy(txtNumber, 3, 1)) =1) or

(mcStrToInt(Copy(txtNumber, 1, 1)) in [1..9]) and

(mcStrToInt(Copy(txtNumber, 2, 1)) = 0) and

(mcStrToInt(Copy(txtNumber, 3, 1)) = 1) or

(mcStrToInt(Copy(txtNumber, 2, 1)) in [1..9]) and

(mcStrToInt(Copy(txtNumber, 3, 1)) = 0) or

(mcStrToInt(Copy(txtNumber, 1, 1)) in [1..9]) and

(Copy(txtNumber, 2, 2) = '00') then

begin

numTPos:= 0;

numTPos:= 3;

end;

txtSlownieGramatyka:= txtSay+NN[numPos, numTPos];

108

∆wiczenia z podstawowych komponentÛw Delphi

if (okPenny >0) then txtSlownieGramatyka:= txtSay+PP[numTPos];

if (Copy(txtNumber, 1, 3) = '000') then txtSlownieGramatyka:= '';

end;

// Rozdzielenie z≥otych od groszy

function txtSlowniePisz(txtNumber, txtPenny: String) :String;

var

txtSay, txtSPenny: String;

TT: Shortint;

begin

// txtSlowniePisz

txtSlowniePisz:= '';

txtSPenny:= '';

txtSPenny:= 'i zero groszy';

if (mcStrToInt(txtPenny) >0) then

begin

txtSPenny:= '';

txtSPenny:= 'i '+txtSlownieGramatyka(FillZero(txtPenny), 1, 1);

end;

// Uzupe≥nij zerami

for TT:= 1 to 15-Length(txtNumber) do

txtNumber:= '0'+txtNumber;

txtSay:= '';

txtSay:= 'zero złotych'+CHR(32);

if (txtNumber <>'') and (Length(txtNumber) = 15) and

(mcStrToInt(txtNumber) >0) then

begin

txtSay:= '';

txtSay:= txtSlownieGramatyka(Copy(txtNumber, 1, 3), 5, 0)+

txtSlownieGramatyka(Copy(txtNumber, 4, 3), 4, 0)+

txtSlownieGramatyka(Copy(txtNumber, 7, 3), 3, 0)+

txtSlownieGramatyka(Copy(txtNumber, 10, 3), 2, 0)+

txtSlownieGramatyka(Copy(txtNumber, 13, 3), 1, 0);

end;

txtSlowniePisz:= txtSay+txtSPenny;

end;

// Wyúwietlenie cyfry s≥ownie.

function plnSlownie(txtNumber: String) :String;

var

numComma: Shortint;

txtBeforeComma, txtAfterComma: String;

begin

// plnSlownie

numComma:= 0;

numComma:= Pos('.', CommaToDot(txtNumber));

if (numComma<>0) then

begin

txtAfterComma:= '';

txtAfterComma:= FillZero(Copy(txtNumber, numComma+1, 2));

txtBeforeComma:= '';

txtBeforeComma:= Copy(txtNumber, 1, numComma-1);

plnSlownie:= txtSlowniePisz(txtBeforeComma, txtAfterComma);

end

∆wiczenia z rozwiπzaniami

109

else

plnSlownie:= txtSlowniePisz(txtNumber, '-1');

end;

end.

∆wiczenie 5.38. Wprowadzenie do baz danych

Napisz s≥ownik, z moøliwoúciπ sortowania i wyszukiwania wed≥ug kolumny Wyraz.
Rysunek 5.38.1 przedstawia wyglπd programu.

Rysunek 5.38.1.

Przedstawiony przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Slownik

Opis:

Baza danych jest to tabela lub kilka powiπzanych ze sobπ tabel. Kaøda tabela sk≥ada
siÍ z kolumn i wierszy. Kaødy wiersz to jeden rekord na ktÛry sk≥ada siÍ jedna kolum-
na lub kilka kolumn.

Wyglπd przyk≥adowej tabeli:

Nazwisko

ImiÍ

Miasto

Kowalski

Tadeusz

Warszawa

Kanarek

Marian

GdaÒsk

Kanapka

Andrzej

Wroc≥aw

110

∆wiczenia z podstawowych komponentÛw Delphi

SposÛb wykonania:

Wybierz kilka przyciskÛw Button

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Standard) i opisz je zgodnie z rysunkiem 5.38.1.

Wybierz komponent Edit

(karta Standard).

Wybierz kilka komponentÛw Label

(karta Standard) i wpisz do nich tekst

zgodnie z rysunkiem 5.38.1.

Wybierz komponenty: DBGrid

(karta Data Controls) i DBEdit

(karta Data Controls).

U≥Ûø wyøej wybrane komponenty zgodnie z rysunkiem 5.38.1.

Wybierz komponenty: Query

(karta Data Access) i DataSource

(karta

Data Access).

W celu utworzenia tabeli wykonaj nastÍpujπce czynnoúci:

Wybierz program Database Desktop z menu Tools (NarzÍdzia) ñ rysunek 5.38.2.

Rysunek 5.38.2.

Wybierz opcjÍ New (Nowy) z menu File (Plik) w programie Database Desktop.

Wybierz opcjÍ Table (Tabela) z menu New (Nowy) ñ rysunek 5.38.3.

Wybierz rodzaj bazy, w ktÛrej chcesz utworzyÊ tabelÍ (domyúlnie ustawiona jest
na Paradox 7) ñ rysunek 5.38.4.

Zatwierdü wybÛr klawiszem Enter lub kliknij przycisk OK, co spowoduje uka-
zanie siÍ okna (rysunek 5.38.5), w ktÛrym bÍdzie moøna definiowaÊ pola.

∆wiczenia z rozwiπzaniami

111

Rysunek 5.38.3.

Rysunek 5.38.4.

Rysunek 5.38.5.

112

∆wiczenia z podstawowych komponentÛw Delphi

Po zdefiniowaniu pÛl, zapisz tabelÍ wybierajπc przycisk Save as... (Zapisz ja-
ko...).

Po tych czynnoúciach trzeba pod≥πczyÊ tabelÍ do programu za pomocπ komponentÛw
do obs≥ugi baz danych, ktÛre znajdujπ siÍ na karcie Data Access i Data Controls
palety komponentÛw. Uøyjemy do tego celu trzech komponentÛw. Sπ nimi Query,
DataSource i DBGrid.
N Query ñ jest komponentem reprezentujπcym zbiÛr danych, ktÛre sπ wynikiem

zapytania SQL (ang.

Standard Query Language).

N DataSource ñ jest komponentem realizujπcym po≥πczenie miÍdzy zbiorami

danych (tabelπ) a innymi komponentami (np. TDBGrid).

N DBGrid ñ jest komponentem s≥uøπcym do wyúwietlania zawartoúci zbioru da-

nych (np. tabeli).

Po≥πczenie tych komponentÛw jest nastÍpujπce:
N Po≥πcz TDataSource z TQuery (np. Query1) za pomocπ w≥aúciwoúci DataSet

komponentu TDataSource (rysunek 5.38.6).

Rysunek 5.38.6.

N Po≥πcz TDBGrid z TDataSource (np. DataSource1) za pomocπ w≥aúciwoúci

DataSource komponentu TDBGrid (rysunek 5.38.7).

Rysunek 5.38.7.

∆wiczenia z rozwiπzaniami

113

Nazwy kolumn w komponencie DBGrid:

Standardowo nazwy wyúwietlane w kolumnach sπ pobierane z bazy. W celu zmiany
opisu kolumn naleøy wykonaÊ nastÍpujπce czynnoúci:

Kliknij dwukrotnie komponent DBGrid (umieszczony jest na formatce), co
spowoduje ukazanie siÍ okna Editing DBGrid1.Columns (Edycja kolumn kom-
ponentu DBGrid) ñ rysunek 5.38.8.

Rysunek 5.38.8

Kliknij przycisk Add (Dodaj), co spowoduje ukazanie siÍ nowego elementu na
liúcie (rysunek 5.38.9).

Rysunek 5.38.9

Zaznacz element na liúcie, w wyniku czego w oknie Object Inspector zobaczy-
my w≥aúciwoúci zaznaczonego elementu (rysunek 5.38.10).

114

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.38.10

Wpisz nazwÍ pola zgodnπ z nazwπ kolumny wystÍpujπcπ w bazie we w≥aúciwo-
úci FieldName zaznaczonego elementu (rysunek 5.38.11).

Rysunek 5.38.11

RozwiÒ w≥aúciwoúÊ Title przez dwukrotne klikniÍcie tej nazwy.

Wpisz we w≥aúciwoúci Caption tekst ÑLista wyrazÛwî (rysunek 5.38.12).

∆wiczenia z rozwiπzaniami

115

Rysunek 5.38.12

Z nastÍpnymi elementami listy postÍpuj tak samo.

Umieszczenie kodu programu:

Wpisz kod odpowiedzialny za wyúwietlenie zawartoúci bazy (tabeli) w zdarzeniu
OnShow (wygenerowanie zdarzenia zosta≥o opisane w podrozdziale 1.3).

procedure TfrmForm1.FormShow(Sender: TObject);

begin

// Wyúwietlenie zawartoúci bazy s≥ownika

Query1.Close;

// ZamkniÍcie bazy danej

Query1.SQL.Clear;

// Czyszczenie zapytania SQL

// Zapytanie SQL

Query1.SQL.Add('SELECT * FROM slownik.db ORDER BY Wyraz');

{

SELECT * FROM slownik.db ORDER BY Wyraz

Wyúwietla zawartoúÊ tablicy slownik.db posortowanπ

alfabetycznie wed≥ug kolumny "Wyraz"

SELECT ñ Uøywany jest do formu≥owania zapytaÒ do

bazy danych w celu uzyskania informacji.

* ñ Oznacza wyúwietlenie wszystkich kolumn z danej bazy.

Gdyby by≥a napisana nazwa kolumny (np. wyraz) zamiast

gwiazdki to wyúwietlona zosta≥aby kolumna o nazwie "Wyraz".

FROM ñ okreúla z jakiej tablicy lub z jakich tablic sπ pobierane dane.

W naszym przypadku jest to tablica o nazwie "slownik.db".

ORDER BY ñ klauzula ta s≥uøy do sortowania wed≥ug wybranej kolumny.

W naszym przyk≥adzie jest to kolumna "Wraz".

}

Query1.Open;

// Otwarcie bazy danych

// Wyúwietla iloúÊ wierszy (rekordÛw) w tabeli.

Label5.Caption:= 'Ilość słów: '+IntToStr(Query1.RecordCount);

{

116

∆wiczenia z podstawowych komponentÛw Delphi

Tworzenie bazy robimy przez wstawienie kodu pod jakiú klawisz:

Query1.Close;

Query1.SQL.Clear;

Query1.SQL.Add('CREATE TABLE slownik.db ('+

'Wyraz CHAR(32), '+

'Znaczenie CHAR(255), '+

'ID CHAR(20))');

Query1.ExecSQL;

}

end;

Wybierz przycisk Dodaj i kliknij go dwukrotnie, a w wygenerowanej procedurze
wpisz kod:

procedure TfrmForm1.bDodajClick(Sender: TObject);

begin

// Dodanie nowego s≥Ûwka (w bazie rekordu).

// Wyúwietlenie nag≥Ûwka okna edycyjnego.

frmDodajEdycja.Caption:= 'Dodaj';

// Wyczyszczenie zawartoúci komponentu EDIT w oknie edycyjnym.

frmDodajEdycja.Edit1.Text:= '';

// Wyczyszczenie zawartoúci komponentu EDIT w oknie edycyjnym.

frmDodajEdycja.Edit2.Text:= '';

// Wywo≥anie okienka edycyjnego do wprowadzenia nowego s≥Ûwka.

frmDodajEdycja.ShowModal;

{

Sprawdzenie czy zosta≥o wpisane nowe s≥Ûwko,

jeøeli tak, do dodaj to s≥Ûwko do tabeli.

}

if (Trim(frmDodajEdycja.Edit1.Text)<>'') then

begin

// Dodanie nowego s≥Ûwka (nowego rekordu).

Query1.Close;

Query1.SQL.Clear;

// INSERT INTO ñ Wstawia jeden lub wiÍcej wierszy do tabeli.

Query1.SQL.Add('INSERT INTO slownik.db ('+

'Wyraz, '+

'Znaczenie, '+

'ID) '+

'VALUES (:p0, :p1, :p2)');

// Pole WYRAZ

Query1.Params[0].AsString:= Trim(frmDodajEdycja.Edit1.Text);

{

W≥aúciwoúÊ Params jest tablicπ numerowanπ od zera, ktÛrπ

moøna wykorzystaÊ do przypisania wartoúci w czasie

wykonywania programu. Zamiast w≥aúciwoúci Params moøna

zastosowaÊ w≥aúciwoúÊ ParamByName(), np.

Query1.ParamByName('Wyraz').AsString:= 'think';

}

∆wiczenia z rozwiπzaniami

117

// Pole "Znaczenie"

Query1.Params[1].AsString:= Trim(frmDodajEdycja.Edit2.Text);

// Pole identyfikacyjne

Query1.Params[2].AsString:= DateTimeToStr(Now);

{

DateTimeToStr(Now) ñ Zwraca datÍ i czas.

DateTimeToStr() ñ Dokonuje konwersji daty i czasu na tekst (string).

Now ñ Zwraca aktualnπ datÍ i czas.

Pole identyfikacyjne, za pomocπ ktÛrego bÍdzie

moøna poprawiaÊ lub usuwaÊ dane s≥Ûwko.

W tym celu wykorzystana zosta≥a data i godzina.

Parametry te sπ rÛøne dla kaødego s≥Ûwka.

}

Query1.ExecSQL;

// Wykonanie zapytania SQL.

FormShow(Sender);

{

FormShow(Sender); ñ Wywo≥anie funkcji odczytujπcej tabelÍ w celu

odúwieøenia wyúwietlanej informacji.

}

end;

Wybierz przycisk Edycja i kliknij go dwukrotnie, a w wygenerowanej procedu-
rze wpisz kod:

procedure TfrmForm1.bEdycjaClick(Sender: TObject);

var

txtID: String;

// Zadeklarowanie zmiennej "txtID".

begin

// Edycja wybranego wiersza (rekordu).

// Przekazanie wartoúci z pola identyfikacyjnego "ID" do zmiennej "txtID".

txtID:= '';

txtID:= Query1.FieldByName('ID').AsString;

// Wyúwietlenie nag≥Ûwka okna edycyjnego.

frmDodajEdycja.Caption:= 'Edycja';

// Odczytanie wiersza z komponentu DBGrid (wyraz). Kolumna 0.

frmDodajEdycja.Edit1.Text:= DBGrid1.Fields[0].AsString;

// Odczytanie wiersza z komponentu DBGrid (znaczenie). Kolumna 1.

frmDodajEdycja.Edit2.Text:= DBGrid1.Fields[1].AsString;

// Wywo≥anie okienka edycyjnego do wprowadzenia nowego s≥Ûwka.

frmDodajEdycja.ShowModal;

// Sprawdzenie czy zosta≥o wpisane nowe s≥Ûwko.

if (Trim(frmDodajEdycja.Edit1.Text)<>'') then

begin

Query1.Close;

Query1.SQL.Clear;

Query1.SQL.Add('UPDATE slownik.db SET Wyraz = :p0, Znaczenie = :p1 '+

'WHERE ID = :p2');

Query1.Params[0].AsString:= Trim(frmDodajEdycja.Edit1.Text);

// Wyraz

Query1.Params[1].AsString:= Trim(frmDodajEdycja.Edit2.Text);

// Znaczenie

Query1.Params[2].AsString:= Trim(txtID);

// Pole identyfikacyjne

Query1.ExecSQL;

// Wykonanie zapytania SQL.

118

∆wiczenia z podstawowych komponentÛw Delphi

FormShow(Sender);

{

FormShow(Sender); ñ Wywo≥anie funkcji odczytujπcej tabelÍ w celu

odúwieøenia wyúwietlanej informacji.

}

end;

Wybierz przycisk UsuÒ i kliknij go dwukrotnie, a w wygenerowanej procedurze
wpisz kod:

procedure TfrmForm1.bUsunClick(Sender: TObject);

var

txtID: String;

// Zadeklarowanie zmiennej "txtID".

begin

// Usuwa zaznaczony wiersz (rekord).

// Przekazanie wartoúci z pola identyfikacyjnego "ID" do zmiennej "txtID".

txtID:= '';

txtID:= Query1.FieldByName('ID').AsString;

Query1.Close;

Query1.SQL.Clear;

Query1.SQL.Add('DELETE FROM slownik.db WHERE ID = :p0');

// Wykorzystanie identyfikatora do usuniÍcia wybranego rekordu.

Query1.Params[0].AsString:= txtID;

Query1.ExecSQL;

// Wykonanie zapytania SQL.

FormShow(Sender);

{

FormShow(Sender); ñ Wywo≥anie funkcji odczytujπcej tabelÍ w celu

odúwieøenia wyúwietlanej informacji.

}

end;

Wybierz komponent Edit (znajdujπcy siÍ na formatce) i kliknij go dwukrotnie,
a w wygenerowanej procedurze wpisz kod:

procedure TfrmForm1.Edit1Change(Sender: TObject);
begin

// Wyszukanie wyrazu (s≥Ûwka).

Query1.Close;
Query1.SQL.Clear;
Query1.SQL.Add('SELECT * FROM slownik.db '+
'WHERE UPPER(Wyraz) LIKE :p_Wyraz '+
'ORDER BY Wyraz');

{
WHERE ñ Po s≥owie WHERE wystÍpuje predykat, ktÛry sk≥ada
siÍ z jednego lub wiÍcej wyraøeÒ.
W tym przypadku UPPER(Wyraz) LIKE :p_Wyraz.
UPPER() ñ Konwertuje ciπg znakÛw na ciπg znakÛw pisany duøymi literami.
LIKE ñ Wyraøenie to pozwala nam na poszukiwanie okreúlonego ciπgu znakÛw.
}

∆wiczenia z rozwiπzaniami

119

{

Przekazanie ciπgu znakÛw jako parametru

wed≥ug ktÛrego nastπpi wyszukiwanie (pole Wyraz).

% ñ Pozwala na wyúwietlenie wszystkich wyrazÛw

zaczynajπcych siÍ od litery np. A, a dziÍki

operatorowi "%" dalsze litery nie sπ brane pod uwagÍ.

}

Query1.Params[0].AsString:= UpperCase(Trim(Edit1.Text))+'%';

// Pole WYRAZ

Query1.Open;

// Otwarcie bazy danych do odczytu.

end;

∆wiczenie 5.39. Wyúwietlenie tabeli w komponencie StringGrid

Napisz program, ktÛry wyúwietli zawartoúÊ bazy (Tabeli) w komponencie StringGrid
i bÍdzie umoøliwia≥ wyszukanie stolicy paÒstwa. Rysunek 5.39.1 przedstawia taki pro-
gram.

Rysunek 5.39.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\StringGrid_SQL

Opis komponentu:

StringGrid (arkusz pÛl edycyjnych) jest komponentem, ktÛry umoøliwia wy-
úwietlenie informacji w sposÛb tabelaryczny lub zrobienie prostego programu

kalkulacyjnego. Komponent ten znajduje siÍ na karcie Standard palety komponen-
tÛw.

SposÛb wykonania:

Wybierz komponent Query

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Da-
ta Access).

120

∆wiczenia z podstawowych komponentÛw Delphi

Wybierz komponent GroupBox

(karta Standard) i we w≥aúciwoúci Caption

wpisz wyraz ÑSzukajî.

Wybierz komponent Label

(karta Standard) i kliknij komponent Group-

Box1, ktÛry ma nazwÍ ÑSzukajî.

Zaznacz komponent Label i we w≥aúciwoúci Caption wpisz ÑWpisz stolicÍî.

Wybierz komponent Edit

(karta Standard) i kliknij komponent Group-

Box1, ktÛry ma nazwÍ ÑSzukajî.

Wybierz komponent GroupBox

(karta Standard) i we w≥aúciwoúci Caption

wpisz wyraz ÑListaî.

Wybierz komponent StringGrid

(karta Additional) i kliknij komponent

GroupBox2, ktÛry ma nazwÍ ÑListaî.

Kliknij dwukrotnie formatkÍ, co spowoduje wygenerowanie zdarzenia OnCreate.
W wygenerowanej procedurze wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

{

Tu wpisujemy funkcje, ktÛre sπ wykonywane w

momencie tworzenia formatki.

}

Edit1.Text:= '';

// Wyczyszczenie komponentu Edit1

end;

W oknie Object Inspector wybierz kartÍ Events i kliknij dwukrotnie zdarzenie
OnShow oraz wpisz kod w wygenerowanej procedurze:

procedure TForm1.FormShow(Sender: TObject);

var

TT: Integer;

// Deklaracja zmiennej "TT"

begin

{

Tu wpisujemy funkcje, ktÛre sπ wykonywane w

momencie otwierania formatki.

}

// Ustawienia dla komponentu StringGrid

StringGrid1.Cells[0, 0]:= 'Państwo';

// Tytu≥ kolumny

StringGrid1.ColWidths[0]:= 144;

// SzerokoúÊ kolumny

StringGrid1.Cells[1, 0]:= 'Stolica';

// Tytu≥ kolumny

StringGrid1.ColWidths[1]:= 199;

// SzerokoúÊ kolumny

StringGrid1.RowCount:= 2;

// IloúÊ wierszy

∆wiczenia z rozwiπzaniami

121

// Zapytanie SQL

Query1.Close;

// ZamkniÍcie bazy danej

Query1.SQL.Clear;

// Czyszczenie zapytania SQL

Query1.SQL.Add('SELECT * FROM Country.db ORDER BY Name');

{

SELECT * FROM Country.db ORDER BY Name

Wyúwietla zawartoúÊ tablicy Country.db posortowanπ

alfabetycznie wed≥ug kolumny "Name"

SELECT ñ Uøywany jest do formu≥owania zapytaÒ do

bazy danych w celu uzyskania informacji.

* ñ Oznacza wyúwietlenie wszystkich kolumn z danej bazy.

Gdyby by≥a napisana nazwa kolumny (np. name) zamiast

gwiazdki to wyúwietlona zosta≥oby kolumna o nazwie "Name".

FROM ñ okreúla z jakiej tablicy lub z jakich tablic sπ pobierane dane.

W naszym przypadku jest to tablica o nazwie "Country.db".

ORDER BY ñ klauzula ta s≥uøy do sortowania wed≥ug wybranej kolumny.

W naszym przyk≥adzie jest to kolumna "Name".

}

Query1.Open;

// Otwarcie bazy danej

// Ustawienia na pierwszy rekord w bazie

Query1.First;

{

Ustawia liczbÍ wierszy w komponencie StringGrid,

wed≥ug iloúci rekordÛw w bazie

}

StringGrid1.RowCount:= 2+Query1.RecordCount;

TT:= 0;

// Przypisanie zmiennej "TT" wartoúci 0

{

Odczytywanie rekordÛw z bazy.

Odczyt zostanie zakoÒczony dopiero po odczytaniu

ostatniego rekordu w bazie.

}

while not(Query1.EOF) do

begin

{

Odczytanie Nazwy z kolumny NAME i przypisanie

jej do pierwszej kolumny komponentu StringGrid.

}

122

∆wiczenia z podstawowych komponentÛw Delphi

StringGrid1.Cells[0, 1+TT]:=
Trim(Query1.FieldByName('Name').AsString);

{

Odczytanie Stolicy z kolumny CAPITAL i przypisanie

jej do drugiej kolumny komponentu StringGrid.

}

StringGrid1.Cells[1, 1+TT]:=
Trim(Query1.FieldByName('Capital').AsString);

Inc(TT);

// Licznik wierszy

// PrzesuniÍcie do nastÍpnego rekordu

Query1.Next;

end;

Zaznacz komponent Edit i kliknij go dwukrotnie (szybko) oraz wprowadü kod
w wygenerowanej procedurze OnChange:

procedure TForm1.Edit1Change(Sender: TObject);

var

TT, numCLS: Integer;

// Zadeklarowanie zmiennych

begin

{

Tu wpisujemy funkcje, ktÛre bÍdπ wykonywane w

momencie zmiany zawartoúci komponentu Edit.

}

Query1.Close;

// ZamkniÍcie bazy danej

Query1.SQL.Clear;

// Czyszczenie zapytania SQL

Query1.SQL.Add('SELECT * FROM Country.db '+

'WHERE UPPER(Capital) LIKE :p_Capital '+

'ORDER BY Name');

{

WHERE ñ Po s≥owie WHERE wystÍpuje predykat, ktÛry sk≥ada

siÍ z jednego lub wiÍcej wyraøeÒ.

W tym przypadku UPPER(Capital) LIKE :p_Capital.

UPPER() ñ Konwertuje ciπg znakÛw na ciπg znakÛw pisany duøymi literami.

LIKE ñ Wyraøenie to pozwala nam na poszukiwanie okreúlonego ciπgu znakÛw.

}

{

Przekazanie ciπgu znakÛw jako parametru

wed≥ug ktÛrego nastπpi wyszukiwanie (pole Capital).

% ñ Pozwala na wyúwietlenie wszystkich wyrazÛw

zaczynajπcych siÍ od litery np. A, a dziÍki

operatorowi "%" dalsze litery nie sπ brane pod uwagÍ.

}

∆wiczenia z rozwiπzaniami

123

Query1.Params[0].AsString:= UpperCase(Trim(Edit1.Text))+'%';

Query1.Open;

// Otwarcie bazy danej

// Ustawienia na pierwszy rekord w bazie

Query1.First;

{

Ustawia liczbÍ wierszy w komponencie StringGrid,

wed≥ug iloúci rekordÛw w bazie

}

StringGrid1.RowCount:= 2+Query1.RecordCount;

TT:= 0;

// Przypisanie zmiennej "TT" wartoúci 0

{

Odczytywanie rekordÛw z bazy.

Odczyt zostanie zakoÒczony dopiero po odczytaniu

ostatniego rekordu w bazie.

}

while not(Query1.EOF) do

begin

{

Odczytanie Nazwy z kolumny NAME i przypisanie

jej do pierwszej kolumny komponentu StringGrid.

}

StringGrid1.Cells[0, 1+TT]:=
Trim(Query1.FieldByName('Name').AsString);

{

Odczytanie Stolicy z kolumny CAPITAL i przypisanie

jej do drugiej kolumny komponentu StringGrid.

}

StringGrid1.Cells[1, 1+TT]:=
Trim(Query1.FieldByName('Capital').AsString);

Inc(TT);

// Licznik wierszy

// PrzesuniÍcie do nastÍpnego rekordu

Query1.Next;

end;

// WyczyúÊ wiersze

for numCLS:= TT+1 to StringGrid1.RowCount-1 do

begin

// Wyczyszczenie wiersza w pierwszej kolumnie

StringGrid1.Cells[0, numCLS]:= '';

// Wyczyszczenie wiersza w drugiej kolumnie

StringGrid1.Cells[1, numCLS]:= '';

end;

124

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 5.40. Sortowanie w komponencie StringGrid

Napisz program, ktÛry wyúwietli dane takie jak: Nazwisko, ImiÍ, Adres i Miasto w po-
staci tabeli. Program powinien posiadaÊ moøliwoúÊ posortowania tabeli wed≥ug wy-
branej kolumny. Do wykonania Êwiczenia naleøy wykorzystaÊ komponent StringGrid.
Rysunek 5.40.1 przedstawia przyk≥adowy wyglπd programu.

Rysunek 5.40.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\StrGrid_Sort

Opis komponentu:

StringGrid (arkusz pÛl edycyjnych) jest komponentem, ktÛry umoøliwia wy-
úwietlenie informacji w sposÛb tabelaryczny lub zrobienie prostego programu

kalkulacyjnego. Komponent ten znajduje siÍ na karcie Standard palety komponen-
tÛw.

SposÛb wykonania:

Wybierz komponent StringGrid

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Additional).

Wybierz dwa przyciski Button

(karta Standard) i nazwij je ÑWyjúcieî

i ÑWype≥nijî.

Wybierz komponent GroupBox

(karta Standard) i we w≥aúciwoúci Cap-

tion wpisz wyraz ÑSortowanieî.

Wybierz komponent Label

(karta Standard) i kliknij komponent GroupBox

oraz we w≥aúciwoúci Caption wpisz wyraz ÑKolumnaî.

Wybierz komponent ComboBox

(karta Standard) i kliknij komponent

GroupBox.

∆wiczenia z rozwiπzaniami

125

Wybierz przycisk Button

(karta Standard) i kliknij komponent GroupBox

oraz we w≥aúciwoúci Caption komponentu Button wpisz ÑSortowanieî.

Kliknij dwukrotnie (szybko) formatkÍ i w wygenerowanym zdarzeniu OnCreate
wpisz kod opisujπcy kolumny:

procedure TForm1.FormCreate(Sender: TObject);

begin

// Wpisanie nazw kolumn

StringGrid1.Cells[0, 0]:= 'Nazwisko';

StringGrid1.Cells[1, 0]:= 'Imię';

StringGrid1.Cells[2, 0]:= 'Adres';

StringGrid1.Cells[3, 0]:= 'Miasto';

// Wyczyszczenie edytora komponentu ComboBox

ComboBox1.Text:= '';

end;

Wybierz przycisk Wype≥nij i kliknij go dwukrotnie oraz wpisz kod do wygene-
rowanej procedury:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Wype≥nienie tabeli

StringGrid1.Cells[0, 1]:= 'Dziedzic';

StringGrid1.Cells[1, 1]:= 'Damian';

StringGrid1.Cells[2, 1]:= 'Akademii Umiejętności';

StringGrid1.Cells[3, 1]:= 'Bielsko-Biała';

StringGrid1.Cells[0, 2]:= 'Roland';

StringGrid1.Cells[1, 2]:= 'Tadeusz';

StringGrid1.Cells[2, 2]:= 'Błotna';

StringGrid1.Cells[3, 2]:= 'Bielsko-Biała';

StringGrid1.Cells[0, 3]:= 'Wojna';

StringGrid1.Cells[1, 3]:= 'Marcin';

StringGrid1.Cells[2, 3]:= 'Siewna';

StringGrid1.Cells[3, 3]:= 'Bielsko-Biała';

StringGrid1.Cells[0, 4]:= 'Wąsowski';

StringGrid1.Cells[1, 4]:= 'Mirek';

StringGrid1.Cells[2, 4]:= 'Modlińska';

StringGrid1.Cells[3, 4]:= 'Wrocław';

StringGrid1.Cells[0, 5]:= 'Gumiś';

StringGrid1.Cells[1, 5]:= 'Arek';

StringGrid1.Cells[2, 5]:= 'Malownicza';

StringGrid1.Cells[3, 5]:= 'Wrocław';

end;

Wybierz przycisk Wyjúcie i kliknij go dwukrotnie oraz wpisz kod w wygenero-
wanej procedurze:

procedure TForm1.Button3Click(Sender: TObject);

126

∆wiczenia z podstawowych komponentÛw Delphi

begin

Close;

// Wyjúcie

end;

Zaznacz komponent ComboBox i przejdü do okna Object Inspector przez
zaznaczenie myszkπ tego okna lub przez naciúniecie klawisza F11.

Wybierz kartÍ Properties i kliknij w≥aúciwoúÊ Items komponentu ComboBox.

Kliknij przycisk

, co spowoduje ukazanie siÍ okna String List editor (Edytor

list ciπgu znakÛw), w ktÛrym wpisz nazwy kolumn (rysunek 5.40.2).

Rysunek 5.40.2

Zatwierdü przyciskiem OK wpisane nazwy.

Napisz funkcjÍ sortujπcπ:

function TForm1.StringGridSort(numCol, numRowMax: Integer; okTitle: Shor-
tint): Integer;
var

AA, BB, TT: Integer;

txtSwap: String;

begin

// StringGridSort

if (okTitle < 0) then okTitle:= 0;

if (okTitle > 1) then okTitle:= 1;

//--- Sort ---

for AA:= numRowMax downto okTitle do

begin

txtSwap:= '';

txtSwap:= StringGrid1.Cells[numCol, AA];

for BB:= numRowMax downto okTitle do

∆wiczenia z rozwiπzaniami

127

begin

if (CompareText(txtSwap, StringGrid1.Cells[numCol, BB]) >0) then

begin

// Swap

for TT:= 0 to StringGrid1.ColCount-1 do

begin

txtSwap:= '';

txtSwap:= StringGrid1.Cells[TT, AA];

StringGrid1.Cells[TT, AA]:= StringGrid1.Cells[TT, BB];

StringGrid1.Cells[TT, BB]:= txtSwap;

end;

Break;

end;

StringGridSort:= numRowMax;

end;

Zadeklaruj funkcje w typie obiektowym:

type

TForm1 = class(TForm)

StringGrid1: TStringGrid;

…………….

function StringGridSort(numCol, numRowMax: Integer; okTitle: Shor-
tint): Integer;
procedure FormCreate(Sender: TObject);

…………..

private

{ Private declarations }

public

{ Public declarations }

end;

Wybierz przycisk Sortowanie i kliknij go dwukrotnie oraz wpisz kod w wygene-
rowanym zdarzeniu:

procedure TForm1.bSortClick(Sender: TObject);

var

TT, numCol: Integer;

begin

// Wywo≥anie funkcji do sortowania

numCol:= 0;

if (ComboBox1.Text = 'Nazwisko') then numCol:= 0;

if (ComboBox1.Text = 'Imię') then numCol:= 1;

if (ComboBox1.Text = 'Adres') then numCol:= 2;

if (ComboBox1.Text = 'Miasto') then numCol:= 3;

for TT:= 0 to StringGrid1.RowCount-1 do

StringGridSort(numCol, StringGrid1.RowCount-1, 1);

end;

128

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 5.41. Alarm

Napisz program, ktÛry bÍdzie wyúwietla≥ komunikat Budzik dzia≥a, gdy czas wprowa-
dzony bÍdzie zgodny z czasem systemowym. Rysunek 5.41.1 przedstawia przyk≥adowy
program.

Rysunek 5.41.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Alarm

SposÛb wykonania:

Wybierz komponent Label

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Wybierz okno Object Inspector naciskajπc klawisz funkcyjny F11 i we w≥aúci-
woúci Caption komponentu Label wpisz ÑPodaj godzinÍ:î.

Wybierz przycisk Button

(karta Standard) i nazwij go wed≥ug rysunku

5.41.1.

Wybierz komponent Label

(karta Standard) i ustaw ten komponent wed≥ug

rysunku 5.41.1.

Kliknij dwukrotnie (szybko) na formatce i w wygenerowanym zdarzeniu On-
Create wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

// Wyczyszczenie zawartoúci komponentu Edit

MaskEdit1.Text:= '';

end;

Napisz funkcje potrzebne do sprawdzania czasu systemowego (powyøej zdarze-
nia, np. OnCreate = procedurze FormCreate, a poniøej s≥owa implementation):

function FillZero(txtZero: String): String;

{

Funkcja dodaje zero do pojedynczej liczby traktowanej

jako tekst, w innym przypadku zwraca dwie liczby.

Przyk≥ad:

1) 10 ñ zwrÛci nam liczbÍ dziesiÍÊ traktowanπ jako tekst

∆wiczenia z rozwiπzaniami

129

2) 3 ñ zwrÛci nam liczbÍ 03 traktowanπ jako tekst, przez dodanie zera przed liczbπ trzy

}

begin

FillZero:= txtZero;

if (Length(txtZero) =1) then FillZero:= '0'+txtZero;

end;

function jbCzas(txtTime: String): Shortint;

{

Funkcja zwraca wartoúÊ 1, gdy podana

godzina zgadza siÍ z godzinπ zegara

systemowego. W innym przypadku

zwraca wartoúÊ -1.

}

var

// Zadeklarowanie zmiennych tekstowych

txtAHour, txtAMin, txtHour, txtMin: String;

begin

// jbCzas

jbCzas:= -1;

// Odczytanie liczb wskazujπcych godzinÍ

txtAHour:= '';

txtAHour:= Copy(TimeToStr(Time), 1, 2);

{

Copy(Tekst, Od_Jakieg_Znaku, Do_Jakiego_Znaku)

Wycina fragment ciπgu znakÛw

Time ñ Zwraca bieøπcy czas

TimeToStr() ñ Konwertuje czas na tekst

}

// Odczytanie liczb wskazujπcych minutÍ

txtAMin:= '';

txtAMin:= Copy(TimeToStr(Time), 4, 2);

{

Sprawdzenie czy zmienna 'txtTime' jest rÛøna od pustego.

Jeøeli tak to wykonaj instrukcje po s≥owie THEN, w

przeciwnym przypadku nie wykonuj nic.

}

if (Trim(txtTime)<>'') then

begin

// Odczytanie liczb wskazujπcych godzinÍ

txtHour:= '';

txtHour:= FillZero(Copy(txtTime, 1, 2));

// Odczytanie liczb wskazujπcych minutÍ

txtMin:= '';

txtMin:= FillZero(Copy(txtTime, 4, 2));

{

130

∆wiczenia z podstawowych komponentÛw Delphi

Jeøeli podany czas jest zgodny z czasem

systemowym to warunek jest spe≥niony.

W innym przypadku warunek nie jest spe≥niony.

}

if (txtHour+':'+txtMin = txtAHour+':'+txtAMin) or

(txtHour+':'+txtMin = '--:'+txtAMin) then jbCzas:= 1;

end;

Wybierz przycisk Budzik i kliknij go dwukrotnie (szybko) oraz wpisz kod
w wygenerowanej procedurze:

procedure TForm1.Button1Click(Sender: TObject);

begin

{

Sprawdzenie czy czas podany zgadza

siÍ z czasem systemowym, jeøeli tak

to wyúwietlony bÍdzie odpowiedni komunikat..

}

if (jbCzas(MaskEdit1.Text) = 1) then

Label2.Caption:= 'Budzik działa'

// Komunikat

else

Label2.Caption:= '';

// Wyczyszczenie komunikatu

end;

∆wiczenie 5.42. Standardowe animacje w systemie Windows

Napisz program, ktÛry zaprezentuje standardowe animacje wystÍpujπce w systemie
Windows. Rysunek 5.42.1 przedstawia taki program.

Rysunek 5.42.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Animate

∆wiczenia z rozwiπzaniami

131

Opis komponentu:

Komponent Animate s≥uøy do odtwarzania standardowych animacji w systemie
Windows. Przyk≥adowo: Kopiowanie plikÛw; Usuwanie plikÛw; Wyszukiwanie

plikÛw; OprÛønianie kosza itp. Rodzaj animacji wybieramy za pomocπ w≥aúciwoúci
CommonAVI komponentu Animate.

SposÛb wykonania:

Wybierz komponent Animate

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Win32).

Wybierz komponent Button

(karta Standard) i opisz go zgodnie z rysun-

kiem 5.42.1.

Wybierz komponent GroupBox

(karta Standard) i we w≥aúciwoúci Cap-

tion wpisz wyraz ÑRodzaj animacjiî.

Wybierz komponent RadioButton

i kliknij komponent GroupBox oznaczo-

ny jako Rodzaj animacji.

Ze wszystkimi komponentami RadioButton postÍpuj tak samo, przez rozmiesz-
czenie i opisanie tych komponentÛw zgodnie z rysunkiem 5.42.1.

Zaznacz pierwszy komponent RadioButton oznaczony jako Brak animacji
i ustaw jego w≥aúciwoúÊ Checked na TRUE (aktywny) bÍdπc w oknie Object
Inspector oraz kliknij go dwukrotnie i w wygenerowanej procedurze wpisz kod:

procedure TForm1.RadioButton1Click(Sender: TObject);

begin

// Brak animacji

Animate1.CommonAVI:= aviNone;

end;

Kliknij dwukrotnie drugi komponent RadioButton oznaczony jako Kopiowanie
pliku i w wygenerowanej procedurze wpisz kod:

procedure TForm1.RadioButton2Click(Sender: TObject);

begin

// Kopiowanie pliku

Animate1.CommonAVI:= aviCopyFile;

end;

Z nastÍpnymi komponentami RadioButton postÍpuj tak samo jak przy drugim
komponencie RadioButton z tπ rÛønicπ, øe w≥aúciwoúci CommonAVI bÍdziesz
przypisywa≥ inne animacje (np. aviEmptyRecycle, aviFindFolder).

Kliknij dwukrotnie przycisk W≥πcz/Wy≥πcz animacjÍ i w wygenerowanej pro-
cedurze wpisz kod:

132

∆wiczenia z podstawowych komponentÛw Delphi

procedure TForm1.Button1Click(Sender: TObject);

begin

// W≥πcza lub wy≥πcza animacjÍ

if (Animate1.Active = TRUE) then

Animate1.Active:= FALSE

else

Animate1.Active:= TRUE;

end;

∆wiczenie 5.43. Dodawanie dni do daty

Napisz program, ktÛry bÍdzie wyúwietla≥ datÍ z moøliwoúciπ zmiany oraz wyúwietla≥
datÍ przysz≥π i przesz≥π rÛøniπcπ siÍ od daty bieøπcej o zadanπ iloúÊ dni. Przyk≥adowy
program przedstawiony jest na rysunku 5.43.1.

Rysunek 5.43.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Data

Opis komponentu:

Komponent DateTimePicker s≥uøy do wybierania daty za pomocπ rozwijanego
kalendarza oraz czasu.

SposÛb wykonania:

Wybierz komponent DateTimePicker

(sposÛb wybrania i umieszczenia

komponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety kompo-
nentÛw (karta Win32).

Wybierz kilka komponentÛw Label

(karta Standard) oraz kilka komponen-

tÛw Edit

(karta Standard) i u≥Ûø je na formatce zgodnie z rysunkiem

5.43.1.

Komponenty Label opisz zgodnie z rysunkiem 5.43.1.

W≥aúciwoúci wszystkich komponentÛw Edit ustaw nastÍpujπco:

∆wiczenia z rozwiπzaniami

133

N W≥aúciwoúÊ Color (Kolor) ustaw na clBtnFace (jest to kolor szary);
N W≥aúciwoúÊ ReadOnly (Tylko odczyt) ustaw na TRUE (brak moøliwoúci

edycji);

N W≥aúciwoúÊ TabStop ustaw na FALSE (brak moøliwoúci przechodzenia miÍ-

dzy komponentami umieszczonymi na formatce za pomocπ klawisza TAB);

Wybierz komponent MaskEdit

(karta Additional).

Zaznacz komponent MaskEdit i naciúnij klawisz funkcyjny F11. BÍdπc na
karcie Properties okna Object Inspector wybierz w≥aúciwoúÊ EditMask
(Edycja maski) przez klikniecie przycisku

. W ukazanym oknie w sekcji Input

Mask (Wprowadü maskÍ) wpisz Ñ999999;1;_î (rysunek 5.43.2).

Rysunek 5.43.2

Napisz funkcje odpowiedzialne za dodawanie i odejmowanie dni od wprowadzo-
nej daty (powyøej zdarzenia, np. OnCreate = procedurze FormCreate, a poniøej
s≥owa implementation):

function DodajZeroPrzed(txtZero: String): String;

begin

{

Funkcja dodaje zero do pojedynczej liczby traktowanej

jako tekst, w innym przypadku zwraca dwie liczby.

Przyk≥ad:

1) 10 ñ zwrÛci nam liczbÍ dziesiÍÊ traktowanπ jako tekst

2) 3 ñ zwrÛci nam liczbÍ 03 traktowanπ jako tekst, przez

dodanie zera przed liczbπ trzy

}

DodajZeroPrzed:= txtZero;

if (Length(txtZero) =1) then DodajZeroPrzed:= '0'+txtZero;

end;

function numIloscDniWMiesiacu(txtDate :String): Shortint;

// Funkcja zwraca liczbÍ dni w danym miesiπcu

134

∆wiczenia z podstawowych komponentÛw Delphi

var

numMonth, numMonthToDays: Shortint;

numYear: Integer;

begin

// IloúÊ Dni w Miesiπcu

// WyciÍcie 4-ro liczbowego roku, np. 2001

numYear:= 0;

numYear:= StrToInt(Copy(txtDate, 1, 4));

// WyciÍcie 2-wu liczbowego miesiπca, np. 09

numMonth:= 0;

numMonth:= StrToInt(Copy(txtDate, 6, 2));

// Zwraca wiadomπ liczbÍ dni w wybranych miesiπcach

numMonthToDays:= 0;

if (numMonth in [1, 3, 5, 7, 8, 10, 12]) then numMonthToDays:= 31;

if (numMonth in [4, 6, 9, 11]) then numMonthToDays:= 30;

if (numMonth = 2) then

begin

{

Sprawdzenie czy podany rok jest rokiem

przestÍpnym (dotyczy tylko miesiπca LUTY)

}

numMonthToDays:= 28;

if ((numYear mod 4 = 0) and (numYear mod 100 <>0)) or

(numYear mod 400 = 0) then

begin

numMonthToDays:= 0;

numMonthToDays:= 29;

end;

numIloscDniWMiesiacu:= numMonthToDays;

end;

function txtJutroJest(txtDate: String): String;

// Funkcja zwraca datÍ jutrzejszπ

var

numMonth, numDay, numDayInMonth: Shortint;

numYear: Integer;

begin

// Jutro Jest

// WyciÍcie 4-ro liczbowego roku, np. 2001

numYear:= 0;

numYear:= StrToInt(Copy(txtDate, 1, 4));

// WyciÍcie 2-wu liczbowego miesiπca, np. 09

numMonth:= 0;

numMonth:= StrToInt(Copy(txtDate, 6, 2));

// WyciÍcie 2-wu liczbowego dnia, np. 15

∆wiczenia z rozwiπzaniami

135

numDay:= 0;

numDay:= StrToInt(Copy(txtDate, 9, 2));

{

Przypisanie zmiennej 'numDayInMonth' iloúci

dni w danym miesiπcu

}

numDayInMonth:= 0;

numDayInMonth:= numIloscDniWMiesiacu(txtDate);

// Jutro jest...

txtJutroJest:= Copy(txtDate, 1, 5)+DodajZeroPrzed(IntToStr(numMonth))+

'-'+DodajZeroPrzed(IntToStr(numDay+1));

if (numDay+1 > numDayInMonth) then

begin

{

Jeøeli iloúÊ dni jest wiÍksza niø iloúÊ dni w

danym miesiπcu to spe≥niony jest warunek, co

spowoduje przesuniÍcie o jeden miesiπc w

przÛd i dodanie 1-go dnia nastÍpnego miesiπca.

}

txtJutroJest:= Copy(txtDate, 1, 5)+

DodajZeroPrzed(IntToStr(numMonth+1))+'-01';

// Jeøeli miesiπc jest 12 to przesuÒ w przÛd o rok

if (numMonth = 12) then txtJutroJest:= IntToStr(numYear+1)+'-01-01';

end;

function txtKiedysBedzie(txtDate: String; numDayPlus: Integer): String;

// Funkcja zwraca datÍ dnia za X dni

var

txtLoopDate: String;

TT: Integer;

begin

// Kiedyú BÍdzie

for TT:= 0 to numDayPlus-1 do

begin

txtLoopDate:= '';

txtLoopDate:= txtJutroJest(txtDate);

// Wywo≥anie funkcji txtJutroJest

txtDate:= '';

txtDate:= txtLoopDate;

end;

txtKiedysBedzie:= txtLoopDate;

end;

function txtWczorajBylo(txtDate: String): String;

// Funkcja zwraca datÍ wczorajszπ

var

numMonth, numDay, numDayInMonth: Shortint;

numYear: Integer;

begin

// Wczoraj By≥o

136

∆wiczenia z podstawowych komponentÛw Delphi

// WyciÍcie 4-ro liczbowego roku, np. 2001

numYear:= 0;

numYear:= StrToInt(Copy(txtDate, 1, 4));

// WyciÍcie 2-wu liczbowego miesiπca, np. 09

numMonth:= 0;

numMonth:= StrToInt(Copy(txtDate, 6, 2));

// WyciÍcie 2-wu liczbowego dnia, np. 15

numDay:= 0;

numDay:= StrToInt(Copy(txtDate, 9, 2));

{

Przypisanie zmiennej 'numDayInMonth' iloúci

dni poprzedniego miesiπca

}

numDayInMonth:= 0;

numDayInMonth:= numIloscDniWMiesiacu(Copy(txtDate, 1, 5)+

DodajZeroPrzed(IntToStr(numMonth-1))+

Copy(txtDate, 8, 3));

// Wczoraj by≥o...

txtWczorajBylo:= Copy(txtDate, 1, 5)+DodajZeroPrzed(IntToStr(numMonth))+

'-'+DodajZeroPrzed(IntToStr(numDay-1));

if (numDay = 1) then

begin

{

Jeøeli jest 1-szy dzieÒ to spe≥niony jest warunek, co

spowoduje cofniÍcie o jeden miesiπc w ty≥ i dodanie

iloúci dni z poprzedniego miesiπca.

}

txtWczorajBylo:= Copy(txtDate, 1, 5)+

DodajZeroPrzed(IntToStr(numMonth-1))+'-'+

DodajZeroPrzed(IntToStr(numDayInMonth));

// Jeøeli miesiπc jest 1 to przesuÒ w ty≥ o rok

if (numMonth = 1) then txtWczorajBylo:= IntToStr(numYear-1)+'-12-31';

end;

function txtKiedysBylo(txtDate: String; numDayMinus: Integer): String;

// Funkcja zwraca datÍ dnia z przed X dni

var

txtLoopDate: String;

TT: Integer;

begin

// Kiedyú By≥o

for TT:= 0 to numDayMinus-1 do

begin

txtLoopDate:= '';

txtLoopDate:= txtWczorajBylo(txtDate);

// Wywo≥anie funkcji txtWczorajBylo

txtDate:= '';

∆wiczenia z rozwiπzaniami

137

txtDate:= txtLoopDate;

end;

txtKiedysBylo:= txtLoopDate;

end;

Kliknij dwukrotnie formatkÍ i w wygenerowanym zdarzeniu OnCreate wpisz
kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

// Inicjacja programu

MaskEdit1.Text:= '4';

// Wpisanie wartoúci 4 do komponentu MaskEdit

// Wywo≥anie poszczegÛlnych funkcji

Edit1.Text:= txtJutroJest(DateToStr(DateTimePicker1.Date));

Edit2.Text:= txtWczorajBylo(DateToStr(DateTimePicker1.Date));

Edit3.Text:= txtKiedysBedzie(DateToStr(DateTimePicker1.Date),
StrToInt(Trim(MaskEdit1.Text)));

Edit4.Text:= txtKiedysBylo(DateToStr(DateTimePicker1.Date),
StrToInt(Trim(MaskEdit1.Text)));
end;

Kliknij dwukrotnie komponent DateTimePicker i w wygenerowanym zdarzeniu
OnChange wpisz kod:

procedure TForm1.DateTimePicker1Change(Sender: TObject);

begin

// Wywo≥anie poszczegÛlnych funkcji w momencie zmiany

Edit1.Text:= txtJutroJest(DateToStr(DateTimePicker1.Date));

Edit2.Text:= txtWczorajBylo(DateToStr(DateTimePicker1.Date));

Edit3.Text:= txtKiedysBedzie(DateToStr(DateTimePicker1.Date),
StrToInt(Trim(MaskEdit1.Text)));
Edit4.Text:= txtKiedysBylo(DateToStr(DateTimePicker1.Date),
StrToInt(Trim(MaskEdit1.Text)));
end;

∆wiczenie 5.44. Nazwy dni i miesiÍcy

Napisz program, ktÛry wczyta do listy nazwy dni i miesiÍcy. Nazwy te muszπ zaczynaÊ
siÍ od duøej litery. Naleøy uøyÊ komponent ComboBox. Rysunek 5.44.1 przedstawia
przyk≥adowy program.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Nazwy

Opis funkcji do wyúwietlania nazw dni i miesiÍcy:

Funkcje s≥uøπce do wyúwietlania nazw dni i miesiÍcy sπ globalnymi zmiennym

zaleønymi od wersji jÍzykowej systemu Windows. Tymi zmiennymi sπ:
N LongDayNames[Index] ñ Tablica pe≥nych nazw dni;
N LongMonthNames[Index] ñ Tablica pe≥nych nazw miesiÍcy.

138

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.44.1

Parametr Index decyduje o wyúwietlonej nazwie dnia lub miesiπca i przyjmuje

nastÍpujπce wartoúci:
N Dla dni od 1 do 7;
N Dla miesiÍcy od 1 do 12.

Opis komponentu:

ComboBox znajduje siÍ na karcie Standard palety komponentÛw. Jest to lista
rozwijana, po≥πczona z edytorem. RozwiniÍcie tej listy nastÍpuje po klikniÍciu

SposÛb wykonania:

Wybierz dwa komponenty ComboBox

(sposÛb wybrania i umieszczenia

komponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety kompo-
nentÛw (karta Standard).

Wybierz dwa komponenty Label

(karta Standard).

Opisz i ustaw te komponenty zgodnie z rysunkiem 5.44.1.

Napisz funkcjÍ, ktÛra bÍdzie ustawiaÊ napisy tak, aby pierwsza litera by≥a duøa,
a reszta liter by≥a ma≥a (powyøej zdarzenia, np. OnCreate = procedurze Form-
Create, a poniøej s≥owa implementation):

function WyrazDLP(txtText: String): String;

begin

{

Funkcja konwertuje pierwsza literÍ ciπgu

znakÛw na duøπ, natomiast nastÍpne znaki

zmienia na ma≥e litery.

∆wiczenia z rozwiπzaniami

139

Przyk≥ad:

1) atari -> Atari

2) delphi -> Delphi

}

WyrazDLP:= AnsiUpperCase(Copy(Trim(txtText), 1, 1))+

AnsiLowerCase(Copy(Trim(txtText), 2,
Length(Trim(txtText))-1));

{

AnsiUpperCase() ñ Zamienia ciπg znakÛw na ciπg

znakÛw pisany duøymi literami

AnsiLowerCase() ñ Zamienia ciπg znakÛw na ciπg

znakÛw pisany ma≥ymi literami

Copy(Tekst, Od_Jakieg_Znaku, Do_Jakiego_Znaku)

Wycina fragment ciπgu znakÛw

Length() ñ Oblicza liczbÍ znakÛw w tekúcie

Trim() ñ Likwiduje spacje z prawej i lewej

strony wyrazu lub ciπgu znakÛw

}

end;

Kliknij dwukrotnie formatkÍ i w wygenerowanym zdarzeniu OnCreate wpisz
kod:

procedure TForm1.FormCreate(Sender: TObject);

var

TT: Shortint;

// Deklaracja zmiennej

begin

{

Tu wpisujemy funkcje, ktÛre sπ wykonywane w

momencie tworzenia formatki.

}

// Wyczyszczenie edytora w komponencie ComboBox

ComboBox1.Text:= '';

ComboBox2.Text:= '';

// Wyczyszczenie listy komponentu ComboBox

ComboBox1.Items.Clear;

ComboBox2.Items.Clear;

// Wpisanie nazw miesiÍcy

for TT:= 0 to 11 do

begin

// Dodanie elementu

ComboBox1.Items.Add(WyrazDLP(LongMonthNames[1+TT]));

end;

140

∆wiczenia z podstawowych komponentÛw Delphi

{

Okreúla iloúÊ wyúwietlanych

elementÛw po rozwiniÍciu listy

}

ComboBox1.DropDownCount:= 12;

// Wpisanie nazw dni

for TT:= 0 to 6 do

begin

// Dodanie elementu

ComboBox2.Items.Add(WyrazDLP(LongDayNames[1+TT]));

end;

{

Zmienne úrodowiskowe zaleøne od

wersji jÍzykowej systemu Windows:

1) LongMonthNames[Index] ñ Tablica pe≥nych nazw miesiÍcy

2) LongDayNames[Index] ñ Tablica pe≥nych nazw dni

}

end;

∆wiczenie 5.45. PageControl (Zak≥adki)

Napisz program, w ktÛrym komponenty bÍdπ u≥oøone na rÛønych zak≥adkach. Zak≥adkÍ
drugπ bÍdzie moøna ukryÊ. Rysunek 5.45.1 przedstawia taki program.

Rysunek 5.45.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\PageControl

∆wiczenia z rozwiπzaniami

141

Opis komponentu:

Komponent PageControl umoøliwia tworzenie zak≥adek. Na kaødej zak≥adce
mogπ znajdowaÊ siÍ zwiπzane tematycznie komponenty. Przechodzenie miÍdzy

zak≥adkami jest moøliwe za pomocπ kombinacji klawiszy Ctrl+Tab ñ do przodu lub
Ctrl+Shift+Tab ñ do ty≥u.

SposÛb wykonania:

Wybierz dwa komponenty PageControl

(sposÛb wybrania i umieszczenia

komponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety kompo-
nentÛw (karta Win32).

UtwÛrz trzy zak≥adki wybierajπc opcjÍ New Page (Nowa strona) z menu podrÍ-
cznego, ktÛre wywo≥uje siÍ prawym przyciskiem myszy po zaznaczeniu kompo-
nentu PageControl znajdujπcego siÍ na formatce.

Nadaj tym zak≥adkom nazwy zgodnie z rysunkiem 5.45.1, przypisujπc w≥aúciwo-
úci Caption poszczegÛlne nazwy po zaznaczeniu kaødej zak≥adki oddzielnie.

Na kaødej zak≥adce umieúÊ kilka dowolnych komponentÛw.

Wybierz dwa przyciski

(karta Standard) i opisz je oraz rozmieúÊ zgodnie

z rysunkiem 5.45.1.

Kliknij dwukrotnie przycisk Pokaø stronÍ pierwszπ i w wygenerowanej proce-
durze wpisz kod:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Pokaø stronÍ pierwszπ

PageControl1.ActivePage:= TabSheet1;

{

TabSheet1 ñ Nazwa strony pierwszej

}

end;

Kliknij dwukrotnie przycisk Pokaø/Ukryj stronÍ 2 i w wygenerowanej procedu-
rze wpisz kod:

procedure TForm1.Button2Click(Sender: TObject);

begin

// Pokazuje/Ukrywa zak≥adkÍ (stronÍ) nr 2

if (TabSheet2.TabVisible = TRUE) then

TabSheet2.TabVisible:= FALSE

else

TabSheet2.TabVisible:= TRUE;

{

TabSheet2 ñ Nazwa strony drugiej

}

end;

142

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 5.46. Rysowanie na ograniczonym obszarze

Wykonaj takie same rysunki jak w Êwiczeniu 5.36. na obszarze ograniczonym. Rysunek
5.46.1 przedstawia taki program.

Rysunek 5.46.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\PaintBox

Opis komponentu:

Komponent PaintBox jest pozwala na rysowanie grafiki ograniczonej w prosto-
kπtnym obszarze, dziÍki temu programista nie musi kontrolowaÊ przekroczenia
obszaru.

SposÛb wykonania:

Wybierz dwa komponenty PaintBox

(sposÛb wybrania i umieszczenia

komponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety kompo-
nentÛw (karta System).

Zaznacz komponent PaintBox, ktÛry jest na formatce.

Przejdü do okna Object Inspector i wybierz kartÍ Events.

BÍdπc na tej karcie wybierz zdarzenie OnPaint i kliknij dwukrotnie pole obok
tego napisu.

W wygenerowanej procedurze wpisz kod:

procedure TForm1.PaintBox1Paint(Sender: TObject);

begin

// PaintBox1Paint ñ Grafika jest odúwieøana w przypadku zas≥oniÍcia

{

Rysuj grafikÍ na ograniczonym obszarze za

pomocπ komponentu PainBox

}

∆wiczenia z rozwiπzaniami

143

// Wyczyszczenie obszaru rysowania.

with PaintBox1.Canvas do

begin

// Ustalenie stylu wype≥niania

Brush.Style:= bsSolid;

// Ustalenie koloru rysowania

Brush.Color:= clWhite;

// Wype≥nienie aktywnego obszaru

FillRect(ClipRect);

{

ClipRect ñ Reprezentuje bieøπcy prostokπt na

ktÛrym sπ dokonywane operacje graficzne.

}

end;

with PaintBox1.Canvas do

begin

//-- Ko≥o --

// Ustalenie koloru jakim bÍdzie narysowana figura.

Pen.Color:= clBlack;

// Ustalenie koloru jakim bÍdzie wype≥niona figura.

Brush.Color:= clRed;

// Narysowanie ko≥a

Ellipse(9, 9, 34, 34);

//-- Kwadrat --

// Ustalenie koloru jakim bÍdzie narysowana figura.

Pen.Color:= clBlack;

// Ustalenie stylu piÛra

Pen.Style:= psDot;

// Ustalenie koloru jakim bÍdzie wype≥niona figura.

Brush.Color:= clRed;

// Ustalenie stylu wype≥niania

Brush.Style:= bsDiagCross;

// Narysowanie kwadratu

Rectangle(39, 9, 66, 36);

//-- Linia --

MoveTo(66, 66);

// Okreúlenie poczπtku linii

LineTo(366, 66);

// Narysowanie linii

144

∆wiczenia z podstawowych komponentÛw Delphi

//-- Ko≥o pochylone --

// Ustalenie koloru jakim bÍdzie narysowana figura.

Pen.Color:= clBlack;

// Ustalenie koloru jakim bÍdzie wype≥niona figura.

Brush.Color:= clRed;

// Ustalenie stylu wype≥niania

Brush.Style:= bsCross;

// Narysowanie kwadratu

Chord(199, 9, 77, 46, 8, 8, 8, 8);

//-- Tekst --

// Ustalenie czcionki tekstu

Font.Name:= 'Arial';

// Ustalenie koloru tekstu

Font.Color:= clGreen;

// Ustalenie stylu tekstu

Font.Style:= [fsBold, fsItalic, fsUnderline];

// Ustalenie wielkoúci tekstu

Font.Size:= 33;

// Wypisanie tekstu na ekranie

TextOut(23, 88, 'To jest tekst.');

end;

∆wiczenie 5.47. Memo do wyúwietlania krÛtkiej pomocy

Wykonaj program, w ktÛrym najechanie na element znajdujπcy siÍ na formatce spowo-
duje wyúwietlenie opisu dla danego elementu. Rysunek 5.47.1 przedstawia przyk≥ado-
wy program.

Rysunek 5.47.1

∆wiczenia z rozwiπzaniami

145

Przyk≥ad znajduje siÍ w katalogu

Delphi\Ciwcz\Qhelp

SposÛb wykonania:

Wybierz komponent Memo

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Napisz funkcjÍ, ktÛra bÍdzie wyúwietla≥a informacjÍ w komponencie Memo:

function TForm1.qhSzybkaPodpowiedz(txtString: String; okVisible: Boolean):
Shortint;

{

Funkcja wyúwietla szybkπ pomoc opisowπ w

komponencie Memo zwanym QuickHelp i zwraca

wartoúÊ 1, jeøeli nowa informacja zosta≥a

wyúwietlona. W innym przypadku funkcja

zwrÛci wartoúÊ -1.

}

begin

// Szybka Podpowiedü

qhSzybkaPodpowiedz:= -1;

{

Wyczyszczenie spacji (pustych znakÛw) z

prawej i lewej strony tekstu

Trim() ñ Likwiduje puste znaki

z dwÛch stron tekstu

}

txtString:= Trim(txtString);

// Ukrycie lub pokazanie komponentu na ekranie

QuickHelp.Visible:= okVisible;

{

Wy≥πczenie moøliwoúci przejúcia do

tego komponentu za pomocπ klawisza TAB

}

QuickHelp.TabStop:= FALSE;

// Wy≥πczenie moøliwoúci edycji

QuickHelp.ReadOnly:= TRUE;

{

Zwijanie tekstu w komponencie w przypadku, gdy

tekst wychodzi poza obramowanie

}

QuickHelp.WordWrap:= TRUE;

// Okreúlenie koloru t≥a

146

∆wiczenia z podstawowych komponentÛw Delphi

QuickHelp.Color:= clYellow;

// Okreúlenie koloru liter

QuickHelp.Font.Color:= clBlack;

{

Jeøeli zawartoúÊ zmiennej "txtString" jest rÛøna od

zawartoúci komponentu "Trim(QuickHelp.Text)" to

spe≥niony jest warunek i nowa informacja zostanie

wyúwietlona. W innym przypadku informacja nie

bÍdzie zmieniona.

}

if (txtString<>Trim(QuickHelp.Text)) then

begin

// Wyczyszczenie zawartoúci komponentu

QuickHelp.Lines.Clear;

// Wprowadzenie (dodanie) nowej informacji

QuickHelp.Lines.Add(txtString);

{

Funkcja zwraca wartoúÊ 1, gdy

warunek jest spe≥niony

}

qhSzybkaPodpowiedz:= 1;

end;

Zadeklaruj funkcjÍ w typie obiektowym:

type

TForm1 = class(TForm)

QuickHelp: TMemo;

................

Label1: TLabel;

function qhSzybkaPodpowiedz(txtString: String; okVisible: Boolean):
Shortint;
............................................

............................................

procedure Edit1MouseMove(Sender: TObject; Shift: TShiftState; X,

procedure Edit1Enter(Sender: TObject);

private

{ Private declarations }

public

{ Public declarations }

end;

Zaznacz komponent Edit

i przejdü do okna Object Inspector.

Wybierz kartÍ Events i wybierz zdarzenie OnEnter.

∆wiczenia z rozwiπzaniami

147

Kliknij dwukrotnie puste pole (obok z prawej strony napisu OnEnter) i w wyge-
nerowanej procedurze wpisz kod, ktÛry bÍdzie wyúwietlany w momencie przej-
úcia na komponent Edit klawiszem Tab:

procedure TForm1.Edit1Enter(Sender: TObject);

begin

{

Wyúwietla informacjÍ o komponencie Edit1, w

przypadku przejúcia na ten komponent za

pomocπ klawisza TAB

}

qhSzybkaPodpowiedz('Zaznaczyłeś komponent EDIT, który '+

'służy do edycji tekstu.', TRUE);

end;

Wybierz zdarzenie OnMouseMove i kliknij dwukrotnie puste pole (znajduje siÍ
z prawej strony obok napisu OnMouseMove). NastÍpnie w wygenerowanej pro-
cedurze wpisz kod, ktÛry pÍdzie wyúwietlany w momencie najechania kursorem
myszy na komponent Edit:

procedure TForm1.Edit1MouseMove(Sender: TObject; Shift: TShiftState; X,

Y: Integer);

begin

// Wyúwietla informacjÍ o komponencie Edit1

qhSzybkaPodpowiedz('Zaznaczyłeś komponent EDIT, który '+

'służy do edycji tekstu.', TRUE);

end;

Z nastÍpnymi komponentami postÍpuj tak samo.

∆wiczenie 5.48. Wπtki

Napisz program, ktÛry wykona dwa rÛøne zadania w tym samym czasie, w ktÛrym bÍ-
dziesz naciskaÊ przycisk Przerywnik. Rysunek 5.48.1 przedstawia przyk≥adowy program.

Rysunek 5.48.1

148

∆wiczenia z podstawowych komponentÛw Delphi

Przyk≥ad znajduje siÍ w katalog

Delphi\Inne\Thread

Opis:

Zastosowanie wπtkÛw jest wygodnym rozwiπzaniem pozwalajπcym na wykonywanie
zadaÒ przez program w tle z jednoczesnym komunikowaniem siÍ z uøytkownikiem.

SposÛb wykonania:

W celu utworzenia klasy wπtku naleøy wykonaÊ nastÍpujπce czynnoúci:
N Wybierz New (Nowy) z menu File (Plik).
N BÍdπc na karcie New (Nowy) wybierz Thread Object (Klasa wπtku).
N W ukazanym oknie New Thread Object (Nowy wπtek) w okienku Class

Name (Nazwa klasy) wpisz nazwÍ nowego wπtku, np. ÑWatek_1î;

N Naciúnij klawisz Enter, co spowoduje wygenerowanie nowej klasy wπtku:

unit Uthread1;

interface

uses

Classes;

type

Watek_1 = class(TThread)

private

{ Private declarations }

protected

procedure Execute; override;

end;

implementation

{ Important: Methods and properties of objects in VCL can only be used in a

method called using Synchronize, for example,

Synchronize(UpdateCaption);

and UpdateCaption could look like,

procedure Watek_1.UpdateCaption;

begin

Form1.Caption := 'Updated in a thread';

end; }

{ Watek_1 }

procedure Watek_1.Execute;

begin

{ Place thread code here }

end;

end.

W celu utworzenia drugiej klasy wπtku postÍpuj tak samo jak wyøej.

∆wiczenia z rozwiπzaniami

149

Wybierz komponent Label

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

We w≥aúciwoúci Caption komponentu Label wpisz tekst zgodny z rysunkiem
5.48.1.

Wybierz dwa przyciski Button

(karta Standard) i opisz je zgodnie z rysun-

kiem 5.48.1.

Wybierz komponent ListBox

(karta Standard).

U≥Ûø komponenty na formatce zgodnie z rysunkiem 5.48.1.

Kliknij dwukrotnie na formatce i w wygenerowanej procedurze wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

{

Tu wpisujemy instrukcje, ktÛre sπ

wykonywane w momencie tworzenia formatki.

}

// Wyczyszczenie zawartoúci komponentu ListBox

ListBox1.Items.Clear;

end;

Uzupe≥nij wπtek o nazwie Watek_1 wpisujπc kod do szkieletowej postaci utwo-
rzonej klasy wπtku ñ wyglπd pe≥nego kodu moøe wyglπdaÊ tak:

unit Uthread1;

{

Wπtek pierwszy, ktÛry bÍdzie wysy≥a≥

tekst "CzeúÊ to ja pierwszy wπtek" do ListBox1

}

interface

uses

Classes;

type

Watek_1 = class(TThread)

private

{ Private declarations }

txtString: String;

protected

procedure UpdateCaption;

procedure Execute; override;

end;

implementation

uses SysUtils, Uthread;

150

∆wiczenia z podstawowych komponentÛw Delphi

// Uthread ñ Nazwa formatki

{ Important: Methods and properties of objects in VCL can only be used in a

method called using Synchronize, for example,

Synchronize(UpdateCaption);

and UpdateCaption could look like,

procedure Watek_1.UpdateCaption;

begin

Form1.Caption := 'Updated in a thread';

end; }

{ Watek_1 }

procedure Watek_1.UpdateCaption;

begin

Form1.ListBox1.Items.Add(txtString);

{

Zapewnia wyúwietlenie wyniku w komponencie ListBox, ktÛry

znajduje siÍ na formatce Form1.

}

end;

procedure Watek_1.Execute;

var

TT: Integer;

begin

{ Place thread code here }

{

W≥πczenie automatycznego zwolnienia obiektu

po jego zakoÒczeniu.

Ustawienie w≥aúciwoúci "FreeOnTerminate" na TRUE

powoduje automatyczne wywo≥anie metody

Free(), ktÛra jest zwiπzana z danym wπtkiem

}

FreeOnTerminate:= TRUE;

// PÍtla wykonywana jest 222222 razy

for TT:= 0 to 222222 do

begin

if Terminated then Break;

{

if Terminated then Break;

Sprawdzenie wartoúci w≥aúciwoúci "Terminated".

Jeøeli w≥aúciwoúÊ ta ma wartoúÊ TRUE to

nastÍpuje zakoÒczenie wπtku.

}

txtString:= '';

txtString:= 'Cześć to ja pierwszy wątek !';

end;

∆wiczenia z rozwiπzaniami

151

Synchronize(UpdateCaption);

end;

end.

Z uzupe≥nieniem drugiej klasy wπtku postÍpuj tak samo.

Zaznacz przycisk W≥πcz wπtki i kliknij go dwukrotnie oraz wpisz kod w wyge-
nerowanej procedurze:

procedure TForm1.bWatkiClick(Sender: TObject);

var

// Deklaracja obiektu Watek_1

WatekPierwszy: Watek_1;

// Deklaracja obiektu Watek_2

WatekDrugi: Watek_2;

begin

// Uruchomienie wπtku 1

WatekPierwszy:= Watek_1.Create(FALSE);

{

O automatycznym uruchomieniu wπtku decyduje jeden parametr konstruktora

Watek_1.Create(FALSE), a mianowicie wartoúÊ FALSE.

WartoúÊ TRUE powoduje zawieszenie wπtku i uruchomienie tego wπtku nastπpi po

wywo≥aniu Watek_1.Resume().

}

// Uruchomienie wπtku 2

WatekDrugi:= Watek_2.Create(FALSE);

end;

Zaznacz przycisk Przerywnik i kliknij go dwukrotnie oraz wpisz kod w wygene-
rowanej procedurze:

procedure TForm1.bPrzerywnikClick(Sender: TObject);

begin

// Wyúwietlenie komunikatu "--- Przerywnik ---"

ListBox1.Items.Add('--- Przerywnik ---');

end;

∆wiczenie 5.49. Wydruki

Napisz program, ktÛry bÍdzie umoøliwia≥ trzy rodzaje wydrukÛw:- wydruk prosty,
wydruk tabeli; wydruk tabeli u≥oøonej w grupy wed≥ug alfabetu. Rysunek 5.49.1 przed-
stawia okno z kontrolkami takiego programu.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\QReport

152

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.49.1

Opis komponentu:

KomponentÛw s≥uøπcych do tworzenia wydruku jest kilkanaúcie i znajdujπ siÍ na kar-
cie QReport. Za ich pomocπ moøna tworzyÊ proste jaki z≥oøone wydruki graficzne.

SposÛb wykonania:

Wybierz trzy komponenty Label

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Standard).

Wybierz trzy komponenty Button

(karta Standard).

RozmieúÊ i opisz wybrane komponenty zgodnie z rysunkiem 5.49.1.

Pozostaw nazwÍ g≥Ûwnej formy (domyúlnπ nazwπ g≥Ûwnej formy jest Form1).
Nazwa formy znajduje siÍ w w≥aúciwoúÊ Name formatki.

Wybierz opcjÍ New Form (Nowa forma) z menu File (rysunek 5.49.2).

Rysunek 5.49.2

CzynnoúÊ poprzedniπ wykonaj jeszcze dwa razy. Tak, aby mieÊ formÍ g≥Ûwnπ
i trzy formy dodatkowe (rysunek 5.49.3).

∆wiczenia z rozwiπzaniami

153

Rysunek 5.49.3

Na trzech formach dodatkowych bÍdπ tworzone wydruki.

Wybranπ formÍ nazwij ÑfrmRaportProstyî wpisujπc tπ nazwÍ we w≥aúciwoúci
Name (Nazwa) formatki, uprzednio przechodzπc do okna Object Inspector (ry-
sunek 5.49.4).

Rysunek 5.49.4

Tak samo postÍpuj z nastÍpnymi dwoma formami nadajπc im nazwy frmLista-
Rekordow i frmPogrupowaneRekordy.

Wydruk graficzny:

PrzesuÒ na plan pierwszy formÍ nazwanπ frmRaportProsty (rysunek 5.49.5).

Wybierz komponent QuickRep

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta QReport).

Wybierz komponent QRLabel

(karta QReport) i umieúÊ go na komponen-

cie QuickRep1, ktÛry znajduje siÍ na formatce.

154

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.49.5

We w≥aúciwoúci Caption komponentu QRLabel wpisz dowolny tekst (np. ÑTo
jest prosty raportî), uprzednio przechodzπc do okna Object Inspector (rysunek
5.49.6).

Rysunek 5.49.6

Wybierz komponent QRImage

(karta QReport) i kliknij komponent Quic-

kRep1, ktÛry znajduje siÍ na formatce.

Kliknij dwukrotnie komponent QRImage, co spowoduje otwarcie okna Picture
editor (Edytor obrazu).

W oknie tym kliknij przycisk Load (Wczytaj), co spowoduje otwarcie okna
wyboru rysunkÛw (rysunek 5.49.7).

Wybierz dowolny rysunek i potwierdü wybÛr klikajπc przycisk OtwÛrz.

∆wiczenia z rozwiπzaniami

155

Rysunek 5.49.7

Wybierz kilka komponentÛw QRLabel

(karta QReport) i umieúÊ je na

komponencie QuickRep1, ktÛry znajduje siÍ na formatce. UWAGA: Kompo-
nenty znajdujπce siÍ na komponencie QuickRep1 muszπ przesuwaÊ siÍ razem
z tym komponentem, w przypadku przesuwania.

Wybrane komponenty rozmieúÊ i opisz zgodnie z rysunkiem 5.49.8.

Rysunek 5.49.8

Wybierz przycisk Podglπd prostego wydruku, ktÛry znajduje siÍ na g≥Ûwnej
formie i kliknij go oraz wpisz kod w wygenerowanej procedurze:

procedure TForm1.Button3Click(Sender: TObject);

156

∆wiczenia z podstawowych komponentÛw Delphi

begin

// Podglπd prostego raportu

frmRaportProsty.QuickRep1.Preview;

end;

Wydruk rekordÛw z bazy w formie tabeli:

PrzesuÒ na plan pierwszy formÍ nazwanπ frmListaRekordow.

Wybierz komponent QuickRep

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta QReport).

Wybierz komponent QRBand

(karta QReport) i umieúÊ go na komponencie

QuickRep1, ktÛry znajduje siÍ na formie.

Wybierz komponent QRLabel

(karta QReport) i umieúÊ go na komponen-

cie QRBand oznaczonym jako rbTitle we w≥aúciwoúci BandType oraz opisz
zgodnie z rysunkiem 5.49.10.

Wybierz komponent QRBand

(karta QReport) i umieúÊ go na komponencie

QuickRep1, ktÛry znajduje siÍ na formie.

Ustaw w≥aúciwoúÊ BandType komponentu QRBand na rbColumnHeader,
bÍdπc w oknie Object Inspector.

Wybierz dwa komponenty QRLabel

(karta QReport) i umieúÊ je na kom-

ponencie QRBand oznaczonym jako rbColumnHeader we w≥aúciwoúci Band-
Type.

Ustaw dla komponentÛw QRLabel w≥aúciwoúÊ DrawBottom na wartoúÊ TRUE
w≥aúciwoúci Frame (rysunek 5.49.9).

Rysunek 5.49.9

U≥Ûø je obok siebie i opisz je zgodnie z rysunkiem 5.49.10.

∆wiczenia z rozwiπzaniami

157

Rysunek 5.49.10

Wybierz komponent QRBand

(karta QReport) i umieúÊ go na komponencie

QuickRep1, ktÛry znajduje siÍ na formie.

Ustaw w≥aúciwoúÊ BandType komponentu QRBand na rbDetail, bÍdπc w oknie
Object Inspector.

Wybierz dwa komponenty QRDBText

(karta QReport) i umieúÊ je na

komponencie QRBand oznaczonym jako rbDetail we w≥aúciwoúci BandType
zgodnie z rysunkiem 5.49.10.

Wpisz pierwszemu komponentowi QRDBText1 nazwÍ kolumny ÑNameî, zgod-
nie z nazwπ kolumny w bazie danych we w≥aúciwoúci DataField.

Wpisz drugiemu komponentowi QRDBText2 nazwÍ kolumny ÑCapitalî, zgod-
nie z nazwπ kolumny w bazie danych we w≥aúciwoúci DataField.

Wybierz komponent DataSource

oraz Query

(obydwa komponenty

znajdujπ siÍ na karcie Data Access) i umieúÊ je na formatce.

Po≥πcz komponent DataSource z komponentem Query za pomocπ w≥aúciwoúci
DataSet komponentu DataSource.

Po≥πcz komponent QuickRep1 z komponentem Query za pomocπ w≥aúciwoúci
DataSet komponentu QuickRep1.

Po≥πcz komponenty QRDBText z komponentem Query za pomocπ w≥aúciwoúci
DataSet komponentu QRDBText.

Wybierz komponent QRBand

(karta QReport) i umieúÊ go na komponencie

QuickRep1, ktÛry znajduje siÍ na formie.

Ustaw w≥aúciwoúÊ BandType komponentu QRBand na rbPageFooter, bÍdπc
w oknie Object Inspector.

158

∆wiczenia z podstawowych komponentÛw Delphi

Wybierz komponent QRSysData

(karta QReport) i umieúÊ go na kompo-

nencie QRBand oznaczonym jako rbPageFooter we w≥aúciwoúci BandType.

W≥aúciwoúÊ Data komponentu QRSysData ustaw na qrsPageNumber.

Napisz procedurÍ odczytujπcπ rekordy z bazy:

procedure TfrmListaRekordow.QReportWydruk;

begin

// QReportWydruk

{

Wpisanie tekstu, ktÛry bÍdzie

wyúwietlany obok numeru strony

}

QRSysData1.Text:= 'Strona: ';

// Zapytanie SQL

Query1.Close;

// ZamkniÍcie bazy danej

Query1.SQL.Clear;

// Czyszczenie zapytania SQL

Query1.SQL.Add('SELECT * FROM Country.db ORDER BY Name');

{

SELECT * FROM Country.db ORDER BY Name

Wyúwietla zawartoúÊ tablicy Country.db posortowanπ

alfabetycznie wed≥ug kolumny "Name"

SELECT ñ Uøywany jest do formu≥owania zapytaÒ do

bazy danych w celu uzyskania informacji.

* ñ Oznacza wyúwietlenie wszystkich kolumn z danej bazy.

Gdyby by≥a napisana nazwa kolumny (np. name) zamiast

gwiazdki to wyúwietlona zosta≥oby kolumna o nazwie "Name".

FROM ñ okreúla z jakiej tablicy lub z jakich tablic sπ pobierane dane.

W naszym przypadku jest to tablica o nazwie "Country.db".

ORDER BY ñ klauzula ta s≥uøy do sortowania wed≥ug wybranej kolumny.

W naszym przyk≥adzie jest to kolumna "Name".

}

Query1.Open;

// Otwarcie bazy danej

QuickRep1.Preview;

// Wyúwietlenie podglπdu

end;

Zadeklaruj funkcjÍ w typie obiektowym w sekcji public (Publicznej), aby by≥a
moøliwoúÊ odwo≥ania siÍ do tej funkcji z modu≥u g≥Ûwnego:

type

TfrmListaRekordow = class(TForm)

∆wiczenia z rozwiπzaniami

159

QuickRep1: TQuickRep;

……………..

QRDBText2: TQRDBText;

private

{ Private declarations }

public

{ Public declarations }

procedure QReportWydruk;

end;

Wybierz przycisk Podglπd listy, ktÛry znajduje siÍ na g≥Ûwnej formie i kliknij go
oraz wpisz kod w wygenerowanej procedurze:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Podglπd listy rekordÛw

frmListaRekordow.QReportWydruk;

end;

Wydruk rekordÛw z bazy w formie pogrupowanej tabeli:

PrzesuÒ na plan pierwszy formÍ nazwanπ frmPogrupowaneRekordy.

Wybierz komponent QuickRep

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta QReport).

Wybierz komponent QRBand

(karta QReport) i umieúÊ go na komponencie

QuickRep1, ktÛry znajduje siÍ na formie.

Wybierz komponent QRLabel

(karta QReport) i umieúÊ go na komponen-

cie QRBand oznaczonym jako rbTitle we w≥aúciwoúci BandType oraz opisz
zgodnie z rysunkiem 5.49.14.

Wybierz komponent QRBand

(karta QReport) i umieúÊ go na komponencie

QuickRep1, ktÛry znajduje siÍ na formie.

Ustaw w≥aúciwoúÊ BandType komponentu QRBand na rbColumnHeader,
bÍdπc w oknie Object Inspector.

Wybierz dwa komponent QRLabel

(karta QReport) i umieúÊ je na kompo-

nencie QRBand oznaczonym jako rbColumnHeader we w≥aúciwoúci BandTy-
pe.

Ustaw dla komponentÛw QRLabel w≥aúciwoúÊ DrawBottom na wartoúÊ TRUE
w≥aúciwoúci Frame (rysunek 5.49.11).

160

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.49.11

U≥Ûø je obok siebie i opisz je zgodnie z rysunkiem 5.49.14.

Wybierz komponent QRGroup

(karta QReport) i umieúÊ go na komponen-

cie QuickRep1, ktÛry znajduje siÍ na formie.

Wpisz we w≥aúciwoúci Expression komponentu QRGroup oznaczonego jako
rbGroupHeader wyraøenie Ñcopy(Name, 1, 1)î (rysunek 5.49.12).

Rysunek 5.49.12

Wybierz komponent QRBand

(karta QReport) i umieúÊ go na komponencie

QuickRep1, ktÛry znajduje siÍ na formie.

Ustaw w≥aúciwoúÊ BandType komponentu QRBand na rbGroupFooter, bÍdπc
w oknie Object Inspector.

Wybierz komponent QRLabel

(karta QReport) i umieúÊ go na komponen-

cie QRBand oznaczonym jako rbGroupFooter we w≥aúciwoúci BandType oraz
opisz zgodnie z rysunkiem 5.49.14.

Wybierz komponent QRExpr

(karta QReport) i umieúÊ go na komponencie

QRBand oznaczonym jako rbGroupFooter we w≥aúciwoúci BandType zgodnie
z rysunkiem 5.49.14.

Wpisz we w≥aúciwoúci Expression komponentu QRExpr wyraøenie Ñsum(Money)î.

∆wiczenia z rozwiπzaniami

161

W≥aúciwoúÊ ResetAfterPrint komponentu QRExpr ustaw na TRUE, co zapo-
biegnie sumowaniu siÍ obliczeÒ poszczegÛlnych grup.

Ustaw w≥aúciwoúÊ FooterBand komponentu QRGroup oznaczonego jako
rbGroupHeader na QRBand (na tym komponencie koÒczy siÍ grupa i taki
komponent oznaczony jest jako rbGroupFooter we w≥aúciwoúci BandType) ñ
rysunek 5.49.13.

Rysunek 5.49.13

Wybierz komponent QRExpr

(karta QReport) i umieúÊ go na komponencie

QRGroup, ktÛry jest oznaczony jako rbGroupHeader.

Wpisz we w≥aúciwoúci Expression komponentu QRExpr wyraøenie Ñcopy(Name,
1, 1)î.

Ustaw w≥aúciwoúÊ Master komponentu QRGroup oznaczonego jako rbGro-
upHeader we w≥aúciwoúci BandType na QuickRep1.

Wybierz komponent QRBand

(karta QReport) i umieúÊ go na komponencie

QuickRep1, ktÛry znajduje siÍ na formie.

Ustaw w≥aúciwoúÊ BandType komponentu QRBand na rbDetail, bÍdπc w oknie
Object Inspector.

Wybierz trzy komponenty QRDBText

(karta QReport) i umieúÊ je na

komponencie QRBand oznaczonym jako rbDetail we w≥aúciwoúÊ BandType
zgodnie z rysunkiem 5.49.14.

Wpisz pierwszemu komponentowi QRDBText1 nazwÍ kolumny ÑNameî, zgod-
nie z nazwπ kolumny w bazie danych we w≥aúciwoúci DataField.

Wpisz drugiemu komponentowi QRDBText2 nazwÍ kolumny ÑCapitalî, zgod-
nie z nazwπ kolumny w bazie danych we w≥aúciwoúci DataField.

162

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.49.14

Wpisz trzeciemu komponentowi QRDBText3 nazwÍ kolumny ÑMoneyî, zgod-
nie z nazwπ kolumny w bazie danych we w≥aúciwoúci DataField.

Wybierz komponent QRBand

(karta QReport) i umieúÊ go na komponencie

QuickRep1, ktÛry znajduje siÍ na formie.

Ustaw w≥aúciwoúÊ BandType komponentu QRBand na rbPageFooter, bÍdπc
w oknie Object Inspector.

Wybierz komponent QRSysData

(karta QReport) i umieúÊ go na kompo-

nencie QRBand oznaczonym jako rbPageFooter za pomocπ w≥aúciwoúci
BandType.

W≥aúciwoúÊ Data komponentu QRSysData ustaw na qrsPageNumber.

Wybierz komponent DataSource

oraz Query

(obydwa komponenty

znajdujπ siÍ na karcie Data Access) i umieúÊ je na formatce.

Po≥πcz komponent DataSource z komponentem Query za pomocπ w≥aúciwoúci
DataSet komponentu DataSource.

Po≥πcz komponent QuickRep1 z komponentem Query za pomocπ w≥aúciwoúci
DataSet komponentu QuickRep1.

Po≥πcz komponenty QRDBText z komponentem Query za pomocπ w≥aúciwoúci
DataSet komponentu QRDBText.

Napisz procedurÍ odczytujπcπ rekordy z bazy:

procedure TfrmPogrupowaneRekordy.QReportWydruk;

begin

// QReportWydruk

∆wiczenia z rozwiπzaniami

163

{

Wpisanie tekstu, ktÛry bÍdzie

wyúwietlany obok numeru strony

}

QRSysData1.Text:= 'Strona: ';

// Zapytanie SQL

Query1.Close;

// ZamkniÍcie bazy danej

Query1.SQL.Clear;

// Czyszczenie zapytania SQL

Query1.SQL.Add('SELECT * FROM Country.db ORDER BY Name');

{

SELECT * FROM Country.db ORDER BY Name

Wyúwietla zawartoúÊ tablicy Country.db posortowanπ

alfabetycznie wed≥ug kolumny "Name"

SELECT ñ Uøywany jest do formu≥owania zapytaÒ do

bazy danych w celu uzyskania informacji.

* ñ Oznacza wyúwietlenie wszystkich kolumn z danej bazy.

Gdyby by≥a napisana nazwa kolumny (np. name) zamiast

gwiazdki to wyúwietlona zosta≥oby kolumna o nazwie "Name".

FROM ñ okreúla z jakiej tablicy lub z jakich tablic sπ pobierane dane.

W naszym przypadku jest to tablica o nazwie "Country.db".

ORDER BY ñ klauzula ta s≥uøy do sortowania wed≥ug wybranej kolumny.

W naszym przyk≥adzie jest to kolumna "Name".

}

Query1.Open;

// Otwarcie bazy danej

QuickRep1.Preview;

// Wyúwietlenie podglπdu

end;

Zadeklaruj funkcjÍ w typie obiektowym w sekcji public (Publicznej), aby by≥a
moøliwoúÊ odwo≥ania siÍ do tej funkcji z modu≥u g≥Ûwnego:

type

TfrmPogrupowaneRekordy = class(TForm)

QuickRep1: TQuickRep;

…………………

............................

Query1: TQuery;

private

{ Private declarations }

public

{ Public declarations }

procedure QReportWydruk;

end;

164

∆wiczenia z podstawowych komponentÛw Delphi

Wybierz przycisk Podglπd pogrupowanych rekordÛw, ktÛry znajduje siÍ na
g≥Ûwnej formie i kliknij go oraz wpisz kod w wygenerowanej procedurze:

procedure TForm1.Button2Click(Sender: TObject);

begin

// Podglπd pogrupowanych rekordÛw

frmPogrupowaneRekordy.QReportWydruk;;

end;

W momencie kompilowania programu Delphi wyúwietli komunikat ÑForm ëForm1í refe-
rences from ëfrmListaRekordowí declared in unit ëUnit2í which is not in your USES list.
Do you wish to add it?î (Forma ëForm1í wywo≥uje deklaracje z ëfrmListaRekordowí znaj-
dujπcπ siÍ w jednostce ëUnit2í, ktÛra nie jest zadeklarowana w liúcie po s≥owie USES. Czy
øyczysz sobie zadeklarowaÊ tπ jednostkÍ?) ñ rysunek 5.49.15.

Rysunek 5.49.15

Przez klikniecie na przycisk Yes (Tak) wyraøamy zgodÍ na zadeklarowanie jednostki
Unit2. W podobnych przypadkach postÍpuj tak samo.

∆wiczenie 5.50. Wyúwietlenie nazw kolumn z bazy

Napisz program, ktÛry bÍdzie umoøliwia≥ odczytanie nazw kolumny wystÍpujπcych
w bazie. Rysunek 5.50.1 przedstawia okno z kontrolkami przyk≥adowego programu.

Rysunek 5.50.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\dbfield

Opis komponentu:

Query jest komponentem s≥uøπcym do reprezentowania danych, ktÛre sπ efek-
tem zadanego pytania SQL w stosunku do jednej lub wiÍkszej iloúci tabel.

∆wiczenia z rozwiπzaniami

165

SposÛb wykonania:

Wybierz komponent Query

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Da-
ta Access).

Wybierz komponent ListBox

(karta Standard).

Kliknij dwukrotnie na formie, co spowoduje wygenerowanie zdarzenia OnCreate
oraz wpisz w wygenerowanej procedurze kod:

procedure TForm1.FormCreate(Sender: TObject);

var

TT: Integer;

// Deklaracja zmiennej TT

begin

{

Tu wpisujemy instrukcje, ktÛre sπ

wykonywane w momencie tworzenia formatki.

}

// Zapytanie SQL

Query1.Close;

// ZamkniÍcie bazy danej

Query1.SQL.Clear;

// Czyszczenie zapytania SQL

Query1.SQL.Add('SELECT * FROM Reservat.db');

{

SELECT * FROM Country.db

Wyúwietla zawartoúÊ tablicy Country.db

SELECT ñ Uøywany jest do formu≥owania zapytaÒ do

bazy danych w celu uzyskania informacji.

* ñ Oznacza wyúwietlenie wszystkich kolumn z danej bazy.

Gdyby by≥a napisana nazwa kolumny (np. name) zamiast

gwiazdki to wyúwietlona zosta≥oby kolumna o nazwie "Name".

FROM ñ okreúla z jakiej tablicy lub z jakich tablic sπ pobierane dane.

W naszym przypadku jest to tablica o nazwie "Country.db".

}

Query1.Open;

// Otwarcie bazy danej

//-- Odczytanie nazw pÛl z bazy danej --

ListBox1.Items.Clear;

for TT:= 0 to Query1.FieldCount-1 do

ListBox1.Items.Add(Trim(Query1.Fields[TT].DisplayName));

{

ListBox1.Items.Clear;

166

∆wiczenia z podstawowych komponentÛw Delphi

Wyczyszczenie zawartoúci komponentu ListBox

for TT:= 0 to Query1.FieldCount-1 do

Wykonanie pÍtli tyle razy ile jest pÛl w bazie danych

Query1.FieldCount ñ Zwraca liczbÍ pÛl w bazie

ListBox1.Items.Add() ñ Dodaje element do listy

Trim()

Likwiduje puste znaki (Spacje) po obu stronach tekstu (ciπgu znakÛw)

Query1.Fields[Index].DisplayName

Wyúwietla nazwÍ pola wystÍpujπcego w bazie o zadanym indeksie

}

end;

∆wiczenie 5.51. Wyselekcjonowanie liczb z tekstu

Napisz program, ktÛry wyselekcjonuje liczby z wprowadzonego tekstu. Rysunek 5.51.1
przedstawia przyk≥adowy program.

Rysunek 5.51.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Edycja

SposÛb wykonania:

Wybierz komponent Edit

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Wybierz dwa przyciski Button

(karta Standard).

Napisz funkcjÍ, ktÛra wyselekcjonuje liczby z wprowadzonego tekstu (powyøej
zdarzenia, np. OnCreate = procedurze FormCreate, a poniøej s≥owa implemen-
tation):

function jbTylkoLiczby(txtString: String; chrComma: Char): String;

{

Funkcja z wprowadzonego tekstu

wybiera liczby i zwraca je jako tekst.

∆wiczenia z rozwiπzaniami

167

Jeøeli nie podamy øadnego tekstu, to

funkcja zwrÛci liczbÍ 0 traktowanπ jako tekst.

W przypadku, gdy tekst nie zawiera liczb to

funkcja nie zwrÛci øadnej liczby

traktowanej jako tekst.

Przyk≥ad:

1) wprowadzony tekst "-Przy123k≥a-d4owy te5k6,st 7.8"

2) Wyselekcjonowany tekst "-123456,78"

}

var

txtText: String;

// Zadeklarowanie zmiennej tekstowej

AA: Integer;

// Zadeklarowanie zmiennej liczbowej

begin

// jbTylkoLiczby

jbTylkoLiczby:= '0';

txtString:= Trim(txtString);

{

Trim() ñ Likwiduje spacje (znaku puste) po

obu stronach wprowadzonego tekstu

}

{

Jeøeli zmienna "txtString" zawiera ciπg znakÛw

to spe≥niony jest warunek i zostanπ wykonane

instrukcje po s≥owie IF...THEN

}

if (txtString<>'') then

begin

txtText:= '';

// Wyczyszczenie zmiennej tekstowej

for AA:= 0 to Length(txtString) do

if (txtString[AA] in ['0'..'9', chrComma]) then

txtText:= txtText+txtString[AA];

{

FOR AA:= 0 TO Length(txtString) DO

PÍtla FOR...TO...DO jest wykonywane tyle

razy ile jest znakÛw w wprowadzonym tekúcie

Length() ñ Oblicza z ilu znakÛw

sk≥ada siÍ wprowadzony tekst

IF (txtString[AA] in ['0'..'9', chrComma]) THEN

Sprawdza czy znak jest zgodny zez znakami

od 0 do 9 oraz znakiem reprezentujπcym przecinek.

txtText:= txtText+txtString[AA];

Dodanie do zmiennej "txtText" znaku, w

przypadku spe≥nienia warunku

}

168

∆wiczenia z podstawowych komponentÛw Delphi

// Zwraca wyselekcjonowane liczby traktowane jako tekst

jbTylkoLiczby:= Trim(txtText);

{

Sprawdza, czy znak minus by≥ na poczπtku

wprowadzonego tekstu. Jeøeli tak to warunek

jest spe≥niony i nastπpi dodanie znaku

minus na poczπtku tekstu. Przyk≥ad: -ab34cd -> -34

}

if (txtString[1] ='-') then jbTylkoLiczby:= '-'+Trim(txtText);

end;

Kliknij dwukrotnie formatkÍ i w wygenerowanej procedurze wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

{

Wprowadzenie przyk≥adowego tekstu

zawierajπcego rÛwnieø liczby

}

Edit1.Text:= '-Przy123kła-d4owy te5k6,st 7.8';

end;

Zaznacz przycisk i kliknij go dwukrotnie oraz wpisz kod w wygenerowanej
procedurze:

procedure TForm1.bOKClick(Sender: TObject);

begin

{

Wywo≥uje funkcjÍ do wyselekcjonowania

liczb z wprowadzonego tekstu

jbTylkoLiczby(Wprowadü_Tekst,

Znak_reprezentujπcy_przecinek);

}

Edit1.Text:= jbTylkoLiczby(Edit1.Text, ',');

end;

∆wiczenie 5.52. Gauge

Napisz program, taki sam jak w Êwiczeniu 5.9 wykorzystujπc komponent Gauge.
Program ma mieÊ moøliwoúÊ zmiany po≥oøenia wykresu. Rysunek 5.52 przedstawia
przyk≥adowy program.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Gauge

Opis komponentu:

Komponent Gauge s≥uøy do pokazywania postÍpu wykonywanej pracy. Pasek po-
stÍpu moøe byÊ przedstawiony w pozycji poziomej i pionowej lub w postaci ko≥a.

∆wiczenia z rozwiπzaniami

169

Rysunek 5.52.1

SposÛb wykonania:

Wybierz komponent GroupBox

(sposÛb wybrania i umieszczenia kompo-

nentu na formatce opisany zosta≥ w podrozdziale 1.1) (karta Standard).

Wybierz trzy komponenty RadioButton

(karta Standard).

Wybierz komponent Button

(karta Standard).

U≥Ûø i opisz te komponenty zgodnie z rysunkiem 5.52.1.

Wybierz komponent Gauge

(karta Sample).

Kliknij dwukrotnie formÍ i w wygenerowanej procedurze wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

{

Tu sπ wpisywane instrukcje, ktÛre

sπ wykonane w momencie tworzenia formatki.

}

//-- Inicjalizacja komponentu Gauge --

// Okreúlenie koloru t≥a

Gauge1.BackColor:= clWhite;

// Okreúlenie koloru paska

Gauge1.ForeColor:= clNavy;

// Okreúlenie minimalnej wartoúci

Gauge1.MinValue:= 0;

// Okreúlenie maksymalnej wartoúci

Gauge1.MaxValue:= 100;

// Okreúlenie iloúci wykonanego zadania

Gauge1.Progress:= 0;

170

∆wiczenia z podstawowych komponentÛw Delphi

// Wywo≥anie pierwszej opcji ÑPoziomoî

RadioButton1Click(Sender);

end;

Wybierz RadioButton z napisem Poziomo i kliknij go dwukrotnie oraz wpisz
kod w wygenerowanej procedurze:

procedure TForm1.RadioButton1Click(Sender: TObject);

begin

// Ustawienie wykresu w pozycji poziomej

Gauge1.Kind:= gkHorizontalBar;

Gauge1.Width:= 144;

// SzerokoúÊ

Gauge1.Height:= 22;

// WysokoúÊ

// Okreúlenie iloúci wykonanego zadania

Gauge1.Progress:= 0;

// Uaktywnienie opcji

RadioButton1.Checked:= TRUE;

end;

Wybierz RadioButton z napisem Pionowo i kliknij go dwukrotnie oraz wpisz
kod w wygenerowanej procedurze:

procedure TForm1.RadioButton2Click(Sender: TObject);

begin

// Ustawienie wykresu w pozycji pionowej

Gauge1.Kind:= gkVerticalBar;

Gauge1.Width:= 22;

// SzerokoúÊ

Gauge1.Height:= 122;

// WysokoúÊ

// Okreúlenie iloúci wykonanego zadania

Gauge1.Progress:= 0;

// Uaktywnienie opcji

RadioButton2.Checked:= TRUE;

end;

Wybierz RadioButton z napisem Ko≥owy i kliknij go dwukrotnie oraz wpisz
kod w wygenerowanej procedurze:

procedure TForm1.RadioButton3Click(Sender: TObject);

begin

// Ustawienie wykresu w postaci ko≥a

Gauge1.Kind:= gkPie;

Gauge1.Width:= 122;

// SzerokoúÊ

Gauge1.Height:= 122;

// WysokoúÊ

// Okreúlenie iloúci wykonanego zadania

Gauge1.Progress:= 0;

// Uaktywnienie opcji

RadioButton3.Checked:= TRUE;

end;

∆wiczenia z rozwiπzaniami

171

Wybierz przycisk Pokaø i kliknij go oraz wpisz kod w wygenerowanej procedu-
rze:

procedure TForm1.Button1Click(Sender: TObject);

var

TT: Integer;

// Zadeklarowanie zmiennej "TT"

begin

// Pokaø postÍp wykonanej procy pÍtli FOR

for TT:= 0 to 99 do

Gauge1.Progress:= 1+TT;

// PÍtla FOR zostanie wykonana 1000 razy

end;

∆wiczenie 5.53. Chart ñ wykresy

Napisz program, ktÛry przedstawi w formie wykresu ko≥owego np. zdobyte oceny.
Rysunek 5.53.1 przedstawia taki program.

Rysunek 5.53.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Chart

Opis komponentu:

Chart jest komponentem umoøliwiajπcym tworzenie rÛønego rodzaju wykresÛw
dwuwymiarowych i trÛjwymiarowych. Znajduje siÍ on na karcie Additional i jest

dostÍpny w Delphi oznaczonym jako Client/Server.

172

∆wiczenia z podstawowych komponentÛw Delphi

SposÛb wykonania:

Wybierz komponent Chart

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) (karta Additional).

Wybierz komponent GroupBox

(karta Standard).

Wybierz kilka komponentÛw CheckBox

(karta Standard).

Pouk≥adaj i opisz te komponenty zgodnie z rysunkiem 5.53.1.

Kliknij dwukrotnie formÍ i w wygenerowanej procedurze wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

// Inicjalizacja komponentu Chart

// Wyzerowanie wykresu

Series1.Clear;

// Dodanie danych do wykresu

Series1.Add(56, 'Bardzo dobrych', clNavy);

Series1.Add(36, 'Dobrych', clGreen);

Series1.Add(65, 'Dostatecznych', clWhite);

Series1.Add(20, 'Niedostatecznych', clRed);

end;

Zaznacz komponent Chart i kliknij go dwukrotnie.

Przejdü do karty Series (Seria), ktÛra znajduje siÍ na karcie Chart (Wykres) ñ
rysunek 5.53.2.

Rysunek 5.53.2

∆wiczenia z rozwiπzaniami

173

Kliknij przycisk Add (Dodaj), co spowoduje ukazanie siÍ okna z rodzajami
wykresÛw do wyboru (rysunek 5.53.3).

Rysunek 5.53.3

Wybierz wykres Pie (Ko≥owy), co spowoduje dodanie tego wykresu do listy (ry-
sunek 5.53.4).

Rysunek 5.53.4

Przejdü do karty Titles (Tytu≥y), ktÛra znajduje siÍ na karcie Chart (Wykres)
i wpisz tekst ÑZdobyte ocenyî (rysunek 5.53.5).

174

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.53.5

Kliknij dwukrotnie napis 3D i w wygenerowanej procedurze wpisz kod:

procedure TForm1.CheckBox1Click(Sender: TObject);

begin

// Wykres trÛjwymiarowy/dwuwymiarowy

Chart1.View3D:= CheckBox1.Checked;

end;

Ustaw w≥aúciwoúÊ Checked na wartoúÊ TRUE komponentu z napisem 3D w ok-
nie Object Inspector.

Kliknij dwukrotnie napis Legenda i w wygenerowanej procedurze wpisz kod:

procedure TForm1.CheckBox2Click(Sender: TObject);

begin

// Pokazuje/ukrywa LegendÍ

Chart1.Legend.Visible:= CheckBox2.Checked;

end;

Ustaw w≥aúciwoúÊ Checked na wartoúÊ TRUE komponentu z napisem Legenda
w oknie Object Inspector.

Kliknij dwukrotnie na napis Tytu≥ i w wygenerowanej procedurze wpisz kod:

procedure TForm1.CheckBox3Click(Sender: TObject);

begin

// Pokazuje/ukrywa Tytu≥

Chart1.Title.Visible:= CheckBox3.Checked;

end;

Ustaw w≥aúciwoúÊ Checked na wartoúÊ TRUE komponentu z napisem Tytu≥
w oknie Object Inspector.

∆wiczenia z rozwiπzaniami

175

Kliknij dwukrotnie napis Dymki i w wygenerowanej procedurze wpisz kod:

procedure TForm1.CheckBox4Click(Sender: TObject);

begin

// Pokazuje/ukrywa Dymki

Series1.Marks.Visible:= CheckBox4.Checked;

end;

Ustaw w≥aúciwoúÊ Checked na wartoúÊ TRUE komponentu z napisem Dymki
w oknie Object Inspector.

Kliknij dwukrotnie napis Gradient i w wygenerowanej procedurze wpisz kod:

procedure TForm1.CheckBox5Click(Sender: TObject);

begin

{

W≥πcza/wy≥πcza gradient

(przejúcie z jednego koloru na inny kolor)

}

Chart1.Gradient.Visible:= CheckBox5.Checked;

// Okreúlenie pierwszego koloru

Chart1.Gradient.StartColor:= clYellow;

// Okreúlenie drugiego koloru

Chart1.Gradient.EndColor:= clRed;

// Okreúlenie kierunku przechodzenia kolorÛw

Chart1.Gradient.Direction:= gdBottomTop;

end;

Ustaw w≥aúciwoúÊ Checked na wartoúÊ TRUE komponentu z napisem Gradient
w oknie Object Inspector.

∆wiczenie 5.54. Liczenie plikÛw

Napisz program, ktÛry poda liczbÍ plikÛw o rozszerzeniu BMP i PAS znajdujπcych siÍ
w podanym katalogu. Rysunek 5.54.1. przedstawia przyk≥adowy program.

Rysunek 5.54.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\liczplik

176

∆wiczenia z podstawowych komponentÛw Delphi

SposÛb wykonania:

Wybierz komponent Label

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Wybierz komponent Button

z palety komponentÛw (karta Standard).

U≥Ûø te komponenty zgodnie z rysunkiem 5.54.1.

Napisz funkcjÍ obliczajπcπ iloúÊ plikÛw w podanym katalogu (powyøej zdarze-
nia, np. OnCreate = procedurze FormCreate, a poniøej s≥owa implementation):

function IloscPlikow(txtSciezka, txtRozszerzenie: String): Integer;

{

Funkcja "IloscPlikow" zawraca liczbÍ plikÛw znajdujπcych

siÍ w podanym katalogu (parametr: txtSciezka) i o

podanym rozszerzeniu (parametr: txtRozszerzenie).

Jeøeli nie bÍdzie øadnych plikÛw, to

funkcja zwrÛci wartoúÊ 0.

}

var

SR: TSearchRec;

{

SR: TSearchRec;

Zadeklarowanie rekordu zawierajπcego

informacje o znalezionym pliku.

}

// Zadeklarowanie zmiennej liczbowej 'numLicznik'

numLicznik: Integer;

// Zadeklarowanie zmiennej tekstowej 'txtFullPath'

txtFullPath: String;

begin

// IloscPlikow

// Przypisanie zmiennej 'txtFullPath'

// parametrÛw funkcji

txtFullPath:= '';

txtFullPath:= Trim(txtSciezka)+Trim(txtRozszerzenie);

// Przypisanie zmiennej 'numLicznikí wartoúci 0

numLicznik:= 0;

{

FindFirst(Sciezka, Atrybut, SR ñ Rekord TSearchRec)

Funkcja szuka pliku w podanym

folderze (parametr: åcieøka), spe≥niajπcego

atrybuty podane w parametrze 'Atrybut'.

Informacja o pierwszym znalezionym pliku

∆wiczenia z rozwiπzaniami

177

jest umieszczana w parametrze SR.

Funkcja zwrÛci 0, jeøeli plik zostanie

znaleziony, w innym przypadku zostanie

zwrÛcony kod b≥Ídu.

}

if (FindFirst(txtFullPath, faAnyFile, SR) = 0) then

begin

repeat

if (SR.Attr<>faDirectory) then numLicznik:= numLicznik+1;

{

if (SR.Attr<>faDirectory) then

Warunek bÍdzie spe≥niony, gdy szykany

element nie bÍdzie katalogiem.

numLicznik:= numLicznik+1;

PowiÍksza zmiennπ 'numLicznik' o jeden, w

przypadku spe≥nienia warunku.

}

until(FindNext(SR)<>0);

{

FindNext(SR)

Funkcja kontynuuje szukanie nastÍpnego pliku o

takich samych parametrach, ktÛre by≥y podane

przy wywo≥ywaniu funkcji 'FindFirst'.

Dane o szukanych plikach sπ przechowywane w

parametrze SR. Funkcja zwrÛci wartoúÊ 0 w

przypadku znalezienia pliku. Jeøeli plik

nie zostanie znaleziony funkcja zwrÛci kod b≥Ídu.

}

FindClose(SR);

{

FindClose(SR)

Funkcja zwalnia pamiÍÊ, ktÛra zosta≥a

przydzielona przez funkcjÍ 'FindFirst'.

}

end;

// Zwraca wartoúÊ zmiennej 'numLicznik'

IloscPlikow:= numLicznik;

end;

Kliknij dwukrotnie formatkÍ i w wygenerowanej procedurze OnCreate wpisz
kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

// Wywo≥anie funkcji 'IloscPlikow'

// Obliczenie iloúci plikÛw o rozszerzeniu BMP

178

∆wiczenia z podstawowych komponentÛw Delphi

// SposÛb wywo≥ania funkcji IloscPlikow:

// IloscPlikow(Nazwa_Katalogu, Rozszerzenie_Pliku)

Label1.Caption:= 'Plików jest '+

IntToStr(IloscPlikow('', '*.bmp'))+

' o rozszerzeniu BMP.';

end;

UWAGA: Brak nazwy katalogu oznacza, øe pliki bÍdπ pobierane z katalogu
bieøπcego.

Kliknij dwukrotnie przycisk i w wygenerowanej procedurze OnClick wpisz kod:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Wywo≥anie funkcji 'IloscPlikow'

// Obliczenie iloúci plikÛw o rozszerzeniu PAS

Button1.Caption:= 'Plików jest '+

IntToStr(IloscPlikow('', '*.PAS'))+

' o rozszerzeniu PAS.';

end;

∆wiczenie 5.55. Okno InputBox

Napisz program, ktÛry umoøliwi wpisanie teksu przy pomocy polecenia InputBox.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Inputbox

SposÛb wykonania:

Wybierz komponent Button

(sposÛb wybrania i umieszczenia komponentu

na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta
Standard).

Kliknij ten przycisk dwukrotnie i w wygenerowanej procedurze OnClick wpisz
kod:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Wywo≥anie okna edycyjnego 'InputBox'

Button1.Caption:= InputBox('Tekst',

'Wpisz jakiś tekst:',

'To jest tekst domyślny');

{

InputBox(Nazwa_Okna,

Tekst_Opisujπcy_Edytorek,

Tekst_Domyslny);

InputBox ñ Funkcja zwraca tekst wprowadzony przez

uøytkownika w przypadku naciúniÍcia

klawisza ENTER lub klikniÍcia na

przycisk z napisem OK.

W przeciwnym razie zostanie zwrÛcony

∆wiczenia z rozwiπzaniami

179

tekst domyúlny wprowadzony w trzecim

parametrze funkcji 'Tekst_Domyslny'

(w tym przyk≥adzie bÍdzie to tekst:

"To jest tekst domyúlny").

Nazwa_Okna ñ W tym parametrze wpisujemy nazwÍ okna,

ktÛra zostanie wyúwietlona na pasku

tytu≥owym, np. "Tekst".

Tekst_Opisujπcy_Edytorek ñ W tym parametrze wpisujemy

tekst, ktÛry ukaøe siÍ nad

okienkiem edycyjnym,

np. "Wpisz jakiú tekst:".

Tekst_Domyslny ñ W tym parametrze wpisujemy tekst, ktÛry

zostanie wyúwietlony w edytorku.

}

end;

∆wiczenie 5.56. Plik rekordowy

Napisz program, ktÛry zapisze zawartoúÊ tabeli StringGrid do pliku oraz umoøliwi
odczytane tej tabeli z pliku. Rysunek 5.56.1 przedstawia taki program.

Ryusnek 5.56.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Plikrek

SposÛb wykonania:

Wybierz cztery komponenty Button

(sposÛb wybrania i umieszczenia kom-

ponentu na formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw
(karta Standard).

UmieúÊ je na formatce i opisz zgodnie z rysunkiem 5.56.1.

Wybierz komponent StringGrid

(karta Additional) i umieúÊ go na format-

ce.

Zadeklaruj sta≥π tekstowπ ëprNazwaPlikuí poniøej dyrektywy uses:

const prNazwaPliku = 'baza.dat';

180

∆wiczenia z podstawowych komponentÛw Delphi

W miejscu deklaracji typÛw (poniøej uses i const) wpisz:

// Deklaracja pliku rekordowego

type

PlikRek = record

Imie: String[20];

Nazwisko: String[50];

Miasto: String[140];

end;

W deklaracji zmiennych globalnych modu≥u (pomiÍdzy s≥owami var i imple-
mentation) wpisz deklaracjÍ zmiennej plikowej:

PR: file of PlikRek; // Deklaracja zmiennej plikowej

Kliknij jednokrotnie formatkÍ i w wygenerowanej procedurze OnCreate wpisz
kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

// Opisanie nag≥ÛwkÛw poszczegÛlnych kolumn

StringGrid1.Cells[0, 0]:= 'Imię';

StringGrid1.Cells[1, 0]:= 'Nazwisko';

StringGrid1.Cells[2, 0]:= 'Miasto';

end;

Kliknij dwukrotnie przycisk Wype≥nij tabelÍ i w wygenerowanej procedurze
OnClick wpisz kod:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Wype≥nienie kolumn

//-1-

StringGrid1.Cells[0, 1]:= 'Jan';

StringGrid1.Cells[1, 1]:= 'Biernat';

StringGrid1.Cells[2, 1]:= 'Bielsko';

//-2-

StringGrid1.Cells[0, 2]:= 'Krzych';

StringGrid1.Cells[1, 2]:= 'Dalton';

StringGrid1.Cells[2, 2]:= 'Warszawa';

//-3-

StringGrid1.Cells[0, 3]:= 'Maria';

StringGrid1.Cells[1, 3]:= 'Janosik';

StringGrid1.Cells[2, 3]:= 'Gdańsk';

//-4-

StringGrid1.Cells[0, 4]:= 'Ela';

StringGrid1.Cells[1, 4]:= 'Perepeczko';

StringGrid1.Cells[2, 4]:= 'Kraków';

end;

∆wiczenia z rozwiπzaniami

181

Kliknij dwukrotnie przycisk WyczyúÊ tabelÍ i w wygenerowanej procedurze
OnClick wpisz kod:

procedure TForm1.Button2Click(Sender: TObject);

var

AA, BB: Integer;

begin

// Czyúci tabelÍ

for AA:= 0 to StringGrid1.RowCount-1 do

for BB:= 0 to StringGrid1.ColCount-1 do

StringGrid1.Cells[BB, 1+AA]:= '';

end;

Kliknij dwukrotnie przycisk Odczytaj tabelÍ i w wygenerowanej procedurze
OnClick wpisz kod:

procedure TForm1.Button3Click(Sender: TObject);

// Deklaracja zmiennych

var

R1: PlikRek;

// Typ rekordowy

TT: Longint;

begin

// Odczytanie tabeli z pliku rekordowego

if (FileExists(prNazwaPliku) = TRUE) then

// Odczytaj plik, jeøeli istnieje.

begin

// Powiπzanie nazwy pliku z fizycznym plikiem na dysku

AssignFile(PR, prNazwaPliku);

Reset(PR);

// Otwarcie istniejπcego pliku

// Odczyt tabeli z pliku rekordowego

for TT:= 0 to StringGrid1.RowCount do

begin

if (FilePos(PR) < FileSize(PR)) then

begin

{

Odczyt pliku bÍdzie przebiegaÊ aø do

ostatniego rekordu. W innym przypadku

warunek nie bÍdzie wykonany.

FileSize(Plik) ñ Zwraca liczbÍ zapisanych

rekordÛw w pliku.

}

// Odczytanie rekordu od 1 do koÒca

Seek(PR, FilePos(PR));

Read(PR, R1);

// Odczytanie danych

182

∆wiczenia z podstawowych komponentÛw Delphi

// Przypisanie poszczegÛlnym kolumnom danych

StringGrid1.Cells[0, 1+TT]:= Trim(R1.Imie);

StringGrid1.Cells[1, 1+TT]:= Trim(R1.Nazwisko);

StringGrid1.Cells[2, 1+TT]:= Trim(R1.Miasto);

end;

CloseFile(PR);

// ZamkniÍcie pliku

end;

Kliknij dwukrotnie przycisk Zapisz tabelÍ i w wygenerowanej procedurze
OnClick wpisz kod:

procedure TForm1.Button4Click(Sender: TObject);

// Deklaracja zmiennych

var

R1: PlikRek;

// Typ rekordowy

TT: Longint;

begin

// Zapisanie tabeli do pliku rekordowego

DeleteFile(prNazwaPliku);

// UsuniÍcie pliku

// Powiπzanie nazwy pliku z fizycznym plikiem na dysku

AssignFile(PR, prNazwaPliku);

// Tworzenie i otwieranie pliku do zapisu

Rewrite(PR);

// Pobranie danych z tabeli i zapisanie do pliku

for TT:= 0 to StringGrid1.ColCount do

begin

// Przypisanie zmiennym "Imie",

// "Nazwisko", "Miasto" danych z tabeli.

R1.Imie:= Trim(StringGrid1.Cells[0, 1+TT]);

R1.Nazwisko:= Trim(StringGrid1.Cells[1, 1+TT]);

R1.Miasto:= Trim(StringGrid1.Cells[2, 1+TT]);

// Zapisanie rekordu na koniec pliku

Seek(PR, FilePos(PR));

{

Seek(Plik, Pozycja) ñ Ustawienie pliku na

okreúlonej pozycji, na

ktÛrej bÍdπ dokonywane

operacje odczytu i zapisu.

Parametr 'Pozycja' umoøliwia

podanie numeru zapisanego rekordu.

∆wiczenia z rozwiπzaniami

183

FilePos(Plik) ñ Zwraca numer bieøπcej pozycji

zapisanego rekordu.

}

Write(PR, R1);

// Zapisanie danych

end;

CloseFile(PR);

// ZamkniÍcie pliku

end;

∆wiczenie 5.57. Odliczanie czasu w ty≥

Napisz program, ktÛry bÍdzie odlicza≥ czas w ty≥ od zadanej godziny.

Ryusnek 5.57.1.

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\odlicz_czas

SposÛb wykonania:

Wybierz komponent Label

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Wybierz komponenty Edit

(karta Standard).

Wybierz komponent Button

(karta Standard).

UmieúÊ te komponenty na formatce i opisz zgodnie z rysunkiem 5.57.1.

Wybierz komponent Timer

(karta System) i umieúÊ go na formatce.

Napisz funkcje odpowiedzialne za odliczanie czasu w ty≥ (powyøej zdarzenia, np.
OnCreate = procedurze FormCreate, a poniøej s≥owa implementation):

{

Funkcja dodaje zero do pojedynczej liczby traktowanej

jako tekst, w innym przypadku zwraca dwie liczby.

Przyk≥ad:

1) 10 ñ zwrÛci nam liczbÍ dziesiÍÊ traktowanπ jako tekst

2) 3 ñ zwrÛci nam liczbÍ 03 traktowanπ jako tekst, przez dodanie zera przed liczbπ trzy

}

function FillZero(txtZero: String): String;

begin

184

∆wiczenia z podstawowych komponentÛw Delphi

FillZero:= txtZero;

if (Length(txtZero) =1) then FillZero:= '0'+txtZero;

end;

function IleCzasuPozostalo(txtCzas: String): String;

{

Funkcja zwraca czas jaki zosta≥

do zakoÒczenia odliczenia.

}

var

// Deklaracja zmiennych

numGodz, numMinut, numSekund: Shortint;

begin

// IleCzasuPozostalo

numGodz:= 0;

// Wyzerowanie zmiennej

// Przypisanie zmiennej GODZIN

numGodz:= StrToInt(Copy(txtCzas, 1, 2));

numMinut:= 0;

// Wyzerowanie zmiennej

// Przypisanie zmiennej MINUT

numMinut:= StrToInt(Copy(txtCzas, 4, 2));

numSekund:= 0;

// Wyzerowanie zmiennej

// Przypisanie zmiennej SEKUND

numSekund:= StrToInt(Copy(txtCzas, 7, 2));

// Liczenie...

if (numSekund = 0) then

begin

{

Jeøeli zmienna 'numSekund' jest rÛwna zeru

to przypisz jej wartoúÊ 59, w przeciwnym

przypadku zmniejsz wartoúÊ zmiennej

'numSekund' o jeden.

UWAGA:

Tak samo jest w przypadku

zmiennej 'numMinut' i 'numGodz'.

}

numSekund:= 59;

// Przypisanie zmiennej wartoúÊ 59

if (numMinut = 0) then

begin

numMinut:= 59;

// Przypisanie zmiennej wartoúÊ 59

∆wiczenia z rozwiπzaniami

185

if (numGodz = 0) then

numGodz:= 23

// Przypisanie zmiennej wartoúÊ 23

else

numGodz:= numGodz-1;

// Zmniejszanie liczby GODZ. o wartoúÊ 1

end

else

numMinut:= numMinut-1;

// Zmniejszanie liczby MINUT o wartoúÊ 1

end

else

numSekund:= numSekund-1;

// Zmniejszanie liczby SEKUND o wartoúÊ 1

// Odliczanie...

IleCzasuPozostalo:= FillZero(IntToStr(numGodz))+':'+

FillZero(IntToStr(numMinut))+':'+

FillZero(IntToStr(numSekund));

end;

Kliknij dwukrotnie formÍ i w wygenerowanym zdarzeniu OnCreate wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

Edit1.Text:= '00:02:00';

// Wprowadzenie czasu

// Wy≥πczenie komponentu TIMER

Timer1.Enabled:= FALSE;

end;

Kliknij dwukrotnie przycisk START i w wygenerowanym zdarzeniu OnClick
wpisz kod:

procedure TForm1.Button1Click(Sender: TObject);

begin

// Uruchomienie odliczania w ty≥

Edit1.Text:= '00:02:00';

// Wprowadzenie czasu

// W≥πczenie komponentu TIMER

Timer1.Enabled:= TRUE;

end;

Kliknij dwukrotnie komponent Timer i w wygenerowanym zdarzeniu OnTimer
wpisz kod:

procedure TForm1.Timer1Timer(Sender: TObject);

begin

// Wywo≥anie funkcji odliczajπcej czas do ty≥u

Edit1.Text:= IleCzasuPozostalo(Edit1.Text);

end;

186

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 5.58. Zmiana wielkoúci liter

Napisz program, ktÛry bÍdzie zamienia≥ tekst na duøe i ma≥e litery oraz umoøliwi
pisanie kaødego wyrazu w zdaniu z duøej litery.

Rysunek 5.58.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Inne\Litery

SposÛb wykonania:

Wybierz komponent Label

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Wybierz komponenty Edit

(karta Standard).

Wybierz komponent GroupBox

(karta Standard).

Wybierz trzy komponenty RadioButton

(karta Standard).

RozmieúÊ i opisz je zgodnie z rysunkiem 5.58.1.

Napisz funkcjÍ odpowiedzialnπ za zamianÍ liter (powyøej zdarzenia, np. OnCreate
= procedurze FormCreate, a poniøej s≥owa implementation):

function ZmianaZnakow(txtString: String; chrFind: Char;

okSwitch: Shortint): String;

{

Funkcja zmienia tekst na tekst pisany literami

ma≥ymi lub duøymi albo kaødy wyraz rozpoczyna

siÍ z wielkiej litery.

}

var

// Inicjalizacja zmiennych

TT: Integer;

txtTemp: String;

begin

// ZmianaZnakow

∆wiczenia z rozwiπzaniami

187

txtString:= Trim(txtString);

ZmianaZnakow:= txtString;

if (txtString<>'') then

begin

{

Funkcja bÍdzie wykonana, jeøeli zmienna

'txtString' bÍdzie zawiera≥a jakieú dane.

W przeciwnym przypadku funkcja nie bÍdzie wykonana.

}

{

Zamiana tekstu na ma≥e litery.

Zamiana ta dokonywana jest

przez funkcjÍ 'AnsiLowerCase()'

}

if (okSwitch <= 1) then

ZmianaZnakow:= AnsiLowerCase(txtString);

{

Zamiana tekstu na duøe litery.

Zamiana ta dokonywana jest

przez funkcjÍ 'AnsiUpperCase()'

}

if (okSwitch = 2) then

ZmianaZnakow:= AnsiUpperCase(txtString);

{

Zamiana tekstu tak, aby wszystkie

wyrazy rozpoczyna≥y siÍ duøπ literπ.

}

if (okSwitch = 3) then

begin

{

Zamiana pierwszej litery w tekúcie na duøπ,

reszta znakÛw w tekúcie zamieniona zostaje na ma≥e litery.

}

txtString:= AnsiUpperCase(Copy(txtString, 1, 1))+

AnsiLowerCase(Copy(txtString, 2, Length(txtString)-1));

txtTemp:= '';

// Wyczyszczenie zmiennej 'txtTemp'

{

PÍtla wykonywana jest tyle razy ile jest

znakÛw w tekúcie. IloúÊ znakÛw w teksie

obliczona jest za pomocπ funkcji 'Length()'

}

for TT:= 1 to Length(txtString) do

if (txtString[TT-1] = CHR(32)) or

(txtString[TT-1] = chrFind) then

188

∆wiczenia z podstawowych komponentÛw Delphi

{

Sprawdzenie czy znak na pozycji TT zmniejszonej

o jeden jest rÛwny znakowi spacji lub znakowi,

ktÛry jest wprowadzony do zmiennej 'chrFind' w

wywo≥aniu funkcji. Jeøeli warunek jest spe≥niony

tzn. znak leøπcy na pozycji TT zmniejszonej o

jeden bÍdzie rÛwny znakowi pustemu lub znakowi

znajdujπcemu siÍ w zmiennej 'chrFind' to powiÍksz

znak, ktÛry leøy na pozycji TT. Zmienna TT zawiera

pozycjÍ kolejnego znaku w tekúcie.

txtTemp:= txtTemp+AnsiUpperCase(txtString[TT])

Dodanie do zmiennej 'txtTemp' kolejnego powiÍkszonego znaku

}

txtTemp:= txtTemp+AnsiUpperCase(txtString[TT])

else

txtTemp:= txtTemp+txtString[TT];

{

txtTemp:= txtTemp+ txtString[TT]

Dodanie do zmiennej 'txtTemp' bez zmian

kolejnego znaku.

}

ZmianaZnakow:= txtTemp;

end;

Kliknij dwukrotnie opcjÍ ma≥e litery i w wygenerowanej procedurze wpisz kod:

procedure TForm1.RadioButton1Click(Sender: TObject);

begin

// Zmienia tekst na ma≥e litery.

Edit1.Text:= ZmianaZnakow(Edit1.Text, '-', 1);

end;

Kliknij dwukrotnie opcjÍ WIELKIE LITERY i w wygenerowanej procedurze
wpisz kod:

procedure TForm1.RadioButton2Click(Sender: TObject);

begin

// Zmienia tekst na duøe litery.

Edit1.Text:= ZmianaZnakow(Edit1.Text, '-', 2);

end;

Kliknij dwukrotnie opcjÍ Jak W Nazwie W≥asnej i w wygenerowanej procedu-
rze wpisz kod:

procedure TForm1.RadioButton3Click(Sender: TObject);

begin

∆wiczenia z rozwiπzaniami

189

{

Zmienia tekst na tekst, w ktÛrym wszystkie

wyrazy rozpoczynajπ siÍ z duøej litery.

}

Edit1.Text:= ZmianaZnakow(Edit1.Text, '-', 3);

end;

∆wiczenie 5.59. Szukanie danych w komponencie StringGrid

Napisz program, ktÛry bÍdzie umoøliwia≥ przeszukanie rekordu z nazwiskami.

Rysunek 5.59.1

Przyk≥ad znajduje siÍ w katalogu

Delphi\Cwicz\Strgrid_find

SposÛb wykonania:

Wybierz komponent Label

(sposÛb wybrania i umieszczenia komponentu na

formatce opisany zosta≥ w podrozdziale 1.1) z palety komponentÛw (karta Stan-
dard).

Wybierz komponenty Edit

(karta Standard).

Wybierz komponent StringGrid

(karta Additional).

RozmieúÊ i opisz je zgodnie z rysunkiem 5.59.1.

Napisz funkcjÍ odpowiedzialnπ za wyszukanie danych (powyøej zdarzenia, np.
OnCreate = procedurze FormCreate, a poniøej s≥owa implementation):

function TForm1.StringGridSearch(numCol: Integer; txtFind: String): Inte-
ger;

// Funkcja wskazuje znaleziony element

var
TT, numLen: Integer;
txtText: String;
begin

// StringGridSearch

StringGridSearch:= -1;

190

∆wiczenia z podstawowych komponentÛw Delphi

{
txtFind:= AnsiLowerCase(Trim(txtFind));
Przypisanie wartoúci ze zmiennej 'txtFind' do tej samej
zmiennej, po zlikwidowaniu zbytecznych spacji i zamianie
wszystkich liter na ma≥e
---------------------------------------------------
AnsiLowerCase() ñ Zmniejszenie wszystkich liter
Trim() ñ wyczyszczenie spacji po obu stronach
wprowadzonego ciπgu znakÛw
}

txtFind:= AnsiLowerCase(Trim(txtFind));

// Obliczenie iloúci znakÛw podanego ciπgu

numLen:= 0;
numLen:= Length(txtFind);

{
Przypisanie numeru kolumny, ktÛry
podany jest w parametrze funkcji
}

StringGrid1.Col:= numCol;

// Przypisanie nr 1 pierwszemu wierszowi

StringGrid1.Row:= 1;

// Wskazanie pierwszego elementu

StringGrid1.CellRect(StringGrid1.Col, StringGrid1.Row);

// Przeszukanie wszystkich elementÛw

for TT:= 0 to StringGrid1.RowCount-1 do
begin

txtText:= '';

// Wyczyszczenie zmiennej

txtText:= AnsiLowerCase(Trim(StringGrid1.Cells[numCol, 1+TT]));

{
txtText:= AnsiLowerCase(Trim(StringGrid1.Cells[numCol, 1+TT]));
Przypisanie wartoúci ze zmiennej 'txtFind' do tej samej
zmiennej, po zlikwidowaniu zbytecznych spacji i zamianie
wszystkich liter na ma≥e
---------------------------------------------------
AnsiLowerCase() ñ Zmniejszenie wszystkich liter
Trim() ñ wyczyszczenie spacji po obu stronach
wprowadzonego ciπgu znakÛw
}

if (Copy(txtText, 1, numLen) = txtFind) then
begin

{

∆wiczenia z rozwiπzaniami

191

Jeøeli element zostanie znaleziony, to zostanπ
wykonane instrukcje po konstrukcji if...then
}

{
Przypisanie numeru wierszowi, w ktÛrym
jest znaleziony element
}

StringGrid1.Row:= 1+TT;

// Wskazanie znalezionego elementu

StringGrid1.CellRect(StringGrid1.Col, StringGrid1.Row);

// Funkcja zwraca numer wiersza, w ktÛry zosta≥ wskazany

StringGridSearch:= StringGrid1.Row;

Break;

// Przerwanie i opuszczenie pÍtli

end;

end;
end;

W kolejnym kroku umieúÊ deklaracjÍ tej funkcji (metody) w typie obiektowym.

type
TForm1 = class(TForm)
Label1: TLabel;
Edit1: TEdit;
StringGrid1: TStringGrid;
private

{ Private declarations }

function StringGridSearch(numCol: Integer; txtFind: String): Integer;
public

{ Public declarations }

end;

Kliknij dwukrotnie na formie i w wygenerowanej procedurze OnCreate =
FormCreate wpisz kod:

procedure TForm1.FormCreate(Sender: TObject);

begin

// Wyczyszczenie zawartoúci komponentu Edit

Edit1.Text:= '';

// Wprowadzenie danych do komponentu StringGrid

// Nag≥Ûwki

StringGrid1.Cells[0, 0]:= 'Imię';

StringGrid1.Cells[1, 0]:= 'Nazwisko';

// Dane

StringGrid1.Cells[0, 1]:= 'Jan';

StringGrid1.Cells[1, 1]:= 'Biernat';

192

∆wiczenia z podstawowych komponentÛw Delphi

StringGrid1.Cells[0, 2]:= 'Jan';

StringGrid1.Cells[1, 2]:= 'Kowalski';

StringGrid1.Cells[0, 3]:= 'Tadek';

StringGrid1.Cells[1, 3]:= 'Kowalski';

StringGrid1.Cells[0, 4]:= 'Mirek';

StringGrid1.Cells[1, 4]:= 'Dalton';

StringGrid1.Cells[0, 5]:= 'Jaś';

StringGrid1.Cells[1, 5]:= 'Filutek';

StringGrid1.Cells[0, 6]:= 'Małgosia';

StringGrid1.Cells[1, 6]:= 'Piernik';

StringGrid1.Cells[0, 7]:= 'Staś';

StringGrid1.Cells[1, 7]:= 'Wiatrak';

StringGrid1.Cells[0, 8]:= 'Nel';

StringGrid1.Cells[1, 8]:= 'Wojna';

StringGrid1.Cells[0, 9]:= 'Maja';

StringGrid1.Cells[1, 9]:= 'Listek';

StringGrid1.Cells[0, 9]:= 'Damian';

StringGrid1.Cells[1, 9]:= 'Listek';

StringGrid1.Cells[0, 10]:= 'Darek';

StringGrid1.Cells[1, 10]:= 'Listek';

StringGrid1.Cells[0, 11]:= 'Mirek';

StringGrid1.Cells[1, 11]:= 'Listek';

StringGrid1.Cells[0, 12]:= 'Joasia';

StringGrid1.Cells[1, 12]:= 'Pawlik';

end;

Zaznacz komponent Edit i przejdü do okna Object Inspector.

Wybierz kartÍ Events.

Kliknij dwukrotnie obok zdarzenia OnKeyDown.

W wygenerowanej procedurze wpisz kod, ktÛry umoøliwi przejúcie do kompo-
nentu StringGrid, za pomocπ klawiszy ze strza≥kami w dÛ≥ i gÛrÍ:

procedure TForm1.Edit1KeyDown(Sender: TObject; var Key: Word;

Shift: TShiftState);

begin

// Przejúcie do komponentu StringGrid

if (Key = VK_DOWN) or (Key = VK_UP) then StringGrid1.SetFocus;

end;

Zaznacz komponent StringGrid i przejdü do okna Object Inspector.

∆wiczenia z rozwiπzaniami

193

Wybierz kartÍ Events.

Kliknij dwukrotnie obok zdarzenia OnKeyPress.

W wygenerowanej procedurze wpisz kod, ktÛry umoøliwi przejúcie do kompo-
nentu Edit, za pomocπ dowolnego klawisza:

procedure TForm1.StringGrid1KeyPress(Sender: TObject; var Key: Char);
begin

// Przejúcie do komponentu Edit

Edit1.SetFocus;
end;

Kliknij dwukrotnie na komponent Edit i w wygenerowanej procedurze wpisz
kod, ktÛry jest odpowiedzialny za wywo≥anie funkcji wyszukujπcej dane:

procedure TForm1.Edit1Change(Sender: TObject);
begin

// Wywo≥anie funkcji wyszukujπcej dane

StringGridSearch(1, Edit1.Text);
end;

∆wiczenie 5.60. Polskie znaki(Ogonki)

Ustaw stronÍ kodowπ polskich znakÛw dla formatki i sterownikÛw baz danych Paradox.

SposÛb wykonania:

Przejdü do okna Object Inspector.

RozwiÒ w≥aúciwoúÊ Font dwukrotnym klikniÍciem na tej nazwie (rysunek
5.60.1).

Rysunek 5.60.1

RozwiÒ listÍ w≥aúciwoúci Charset.

Z listy tej wybierz stronÍ kodowπ EASTEUROPE_CHARSET (rysunek 5.60.2).

194

∆wiczenia z podstawowych komponentÛw Delphi

Rysunek 5.60.2

Czcionki ustawione sπ na stronie kodowej Europy årodkowo-Wschodniej.

W celu ustawienia strony kodowej dla sterownikÛw baz danych typu Paradox naleøy
wykonaÊ nastÍpujπce kroki:

Wybierz menu Start/Ustawienia/Panel sterownia.

W oknie Panelu sterowania wybierz BDE Administrator (rysunek 5.60.3).

Rysunek 5.60.3

Wybierz kartÍ Configuration (Konfiguracja).

RozwiÒ drzewo Configuration (Configuration/Drives/Native/Paradox), aø doj-
dziesz do sterownika Paradox (rysunek 5.60.4).

Na karcie Definition (Definicja), ktÛra znajduje siÍ po prawej stronie okna BDE
Administratorëa rozwiÒ listÍ LANGDRIVER.

Z rozwiniÍtej listy wybierz stronÍ kodowπ Paradox Polish 852 (rysunek 5.60.5).

∆wiczenia z rozwiπzaniami

195

Rysunek 5.60.4

Rysunek 5.60.5

W≥aúciwoúÊ LANGDRIVER sterownika baz danych typu PARADOX wykorzystuje
polskπ stronÍ kodowπ.

∆wiczenia do samodzielnego wykonania

∆wiczenie 1.

Do Êwiczenia 5.17 dopisz procedurÍ wczytujπcπ tabelÍ do komponentu StringGrid,
ktÛra bÍdzie wykrywa≥a iloúÊ kolumn i dodawa≥a wiersze.

∆wiczenie 2.

Napisz program, ktÛry losowo bÍdzie rysowa≥ figury na formie i podpisywa≥ narysowa-
ne figury. Rysunek przedstawia przykladowy program:

∆wiczenie 3.

Napisz przeglπdarkÍ obrazkÛw bitmapowych. Rysunek przedstawia wyglπd przyk≥ado-
wej przeglπdarki.

∆wiczenie 4.

Napisz program, ktÛry bÍdzie losowa≥ liczby i konwertowa≥ je na s≥owa (patrz Êwicze-
nie 5.37).

∆wiczenia do samodzielnego wykonania

197

∆wiczenie 5.

Napisz program korzystajπc z programu napisanego w Êwiczeniu 3 dodajπc pokaz
slajdÛw.

∆wiczenie 6.

Napisz program do nauki tabliczki mnoøenia.

∆wiczenie 7.

Napisz program do przechowywania informacji dotyczπcych: ñ nazwiska; ñ imienia; ñ
adresu; ñ telefonu. Piszπc ten program korzystaj z informacji zawartych w Êwiczeniu
5.38.

∆wiczenie 8.

Napisz program, ktÛry bÍdzie wyúwietla≥ tablicÍ kodÛw ASCII.

∆wiczenie 9.

Napisz program, ktÛry poda nazwÍ dnia na podstawie daty.

∆wiczenie 10.

Napisz przeglπdarkÍ do plikÛw bazodanowych Dbase i Paradoxía z moøliowúciπ
wczytania pliku przez podanie go jako parametr przy wywo≥ywaniu tego programu.
Korzystaj z wiadomoúci zawartych w Êwiczeniu 5.38 i 5.32. Rysunek przydstawia
przyk≥adowy program:

∆wiczenie 11.

NapisaÊ program do odczytywania ikon, wykorzystujπc dynamiczne tworzenie kompo-
nentÛw. Ikony majπ byÊ w kilku kolumnach. Rysunek poniøszy przedstawia przyk≥ado-
wy program.

198

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 12.

Napisz program, ktÛry bÍdzie przypomina≥ o úwiÍtach.

∆wiczenie 13.

Napisz program, ktÛry bÍdzie zamienia≥ liczby na s≥owa przez schowek.

∆wiczenia do samodzielnego wykonania

199

∆wiczenie 14.

NapisaÊ program, ktÛry bÍdzie posiada≥ bazÍ uczniÛw wraz z ocenami oraz bÍdzie
posiada≥ moøliwoúÊ wydrukowania danych.

∆wiczenie 15.

Do Êwiczenia 5.53 dodaj procentowπ prezentacjÍ liczb, zapisywanie oraz kopiowanie
wykresu do schowka.

∆wiczenie 16.

Napisz program, ktÛry bÍdzie porÛwnywa≥ zdobyte oceny uczniÛw i wyniki te przedsta-
wi na wykresie.

∆wiczenie 17.

Napisz program, ktÛry bÍdzie podawa≥ iloúÊ dni pomiÍdzy dwoma dowolnymi datami.

∆wiczenie 18.

Napisz program, ktÛry bÍdzie odtwarza≥ pliki düwiÍkowe pobrane z listy przez jakiú
okreúlony czas.

∆wiczenie 19.

Napisz program, ktÛry poda na podstawie daty urodzenia danej osoby nastÍpujπce
informacje: ñ wiek osoby (braÊ pod uwagÍ rok przestÍpny); ñ dni imienin; ñ dzieÒ
urodzin oraz nazwÍ tego dnia.

∆wiczenie 20.

Napisz program, ktÛry bÍdzie liczy≥ úredniπ z podanych ocen oraz bÍdzie podawa≥ iloúÊ
ocen pozytywnych i negatywnych.

∆wiczenie 21.

Napisz tekstowπ bazÍ danych, ktÛra bÍdzie zawiera≥a nastÍpujπce pola: imiÍ, nazwi-
sko, adres i telefon oraz bÍdzie umoøliwia≥a sortowanie wed≥ug tych pÛl. Program ten
naleøy pisaÊ w oparciu o komponent StringGrid.

∆wiczenie 22.

Napisz program, ktÛry bÍdzie automatycznie numerowa≥ nazwy plikÛw przy zapisywa-
niu.

∆wiczenie 23.

Napisz program do obliczania rÛwnania kwadratowego i X1, X2.

200

∆wiczenia z podstawowych komponentÛw Delphi

∆wiczenie 24.

Napisz program, ktÛry bÍdzie automatycznie zmienia≥ imiona i nazwiska tak, aby
zaczyna≥y siÍ z duøej litery, natomiast tytu≥y naukowe pisa≥ z ma≥ej litery.

∆wiczenie 25.

Napisz bazÍ danych w oparciu o komponent StringGrid, ktÛra bÍdzie zawiera≥a nastÍ-
pujπce kolumny: ImiÍ, Nazwisko i Adres. Baza ma umoøliwiaÊ dodawanie, edycjÍ,
usuwanie, odczytywanie i zapisywanie oraz wyszukiwanie i sortowanie danych.

Wyszukiwarka

Podobne podstrony:
Podstawowe wlasciwosci komponentow w Delphi
11 podstawowe komponenty
Konspekt szkoleniowy Podstawy programowania w Delphi
zaawansowane ustawienia parametrów pracy podstawowych komponentów komputera XDJYAH5KV2WQZOUDAGPQ4BAK
Podstawowe komponenty sieci Maul Patryk 3 TI
[pl book] fr delphi 7 i bazy danych r 10 podstawy tworzenia komponentow 7FDOYSNI5YQ5QOZJJ6PQHI2UFEOM
[pl book] fr delphi 7 i bazy danych r 10 podstawy tworzenia komponentow 7FDOYSNI5YQ5QOZJJ6PQHI2UFEOM
Pl Book Fr Delphi 7 I Bazy Danych R 10 Podstawy Tworzenia Komponentow
Sem II Transport, Podstawy Informatyki Wykład XXI Object Pascal Komponenty
Podstawy Informatyki Wykład XVII Object Pascal Komponenty
Sem II Transport, Podstawy Informatyki Wykład XXI Object Pascal Komponenty
Podstawowe zasady udzielania pomocy przedlekarskiej rany i krwotoki
Farmakologia pokazy, Podstawy Farmakologii Ogólnej (W1)

więcej podobnych podstron