Základy programování v DELPHI by siz19146

VIEWS: 0 PAGES: 36

									Základy programování
 v Pascalu a Delphi
A. Základy Pascalu
Programovací jazyk Delphi byl vytvořen z Pascalu. Programování v Pascalu je sice náročnější na čas, ale
abyste pochopili zásadu, ukážeme si některé programovací prvky, které se budou stejně používat také
v Delphi.

I. Obecná pravidla pro psaní programů v Pascalu
Každý programovací jazyk má svá pravidla, kterými se musíme řídit. V Pascalu jsou to:

 Každý program má svoji strukturu, která musí být dodržena (viz. Struktura programu);
 Za každý vykonávaný příkaz napíšeme středník, pokud nebude uvedeno jinak.
 Pascal nerozlišuje malá a velká písmena. Přesto je ale vhodné psát v našem programu i velká písmena.
  Většinou u každého příkazu se píše první písmeno velké. Každý příkaz musí být pojmenován jedním
  slovem, tedy pokud jej chceme zapsat jako více slov, nesmíme mezi nimi psát mezeru, ale vždy nové
  slovo začneme velkým písmenem. Počítači na tom sice nezáleží, ale náš program se stává
  přehlednějším.



II. Struktura programu
   1) Pojmenování programu
Každý program v Pascalu má své jméno. Proto psaní našeho programu zahájíme tím, že
napíšeme slovo Program, jeho název a středník:

Program Název;

Středníkem budeme v Pascalu ukončovat každý řádek, pokud nebude uvedeno jinak.
Tento řádek není nutný, ale protože kromě programů budeme psát i např. tzv. Unity, je lepší jej uvádět.

2) Definování použitých knihoven
V Pascalu máme možnost používat spoustu příkazů. Každý příkaz vykonává určitou činnost. Vžijme se
ale do role počítače. On jistě neví, které příkazy zrovna v našem programu použijeme, tak by se je musel
“naučit” všechny. Proto jsou jednotlivé typy příkazů zařazeny do různých skupin. Každá skupina příkazů
je v jakési obálce, která má své jméno a říká se jí knihovna.

Základní knihovny:
System               Nejběžněji používané příkazy
Crt                  Příkazy pro práci s textem
Dos                  Příkazy pro vytváření adresáře, mazání, přejmenování,…
Graph                Příkazy pro práci s grafikou
String               Příkazy pro práci s řetězci znaků na vyšší úrovni

Musíme tedy znát, jaký příkaz je v jaké knihovně. Knihovny, z kterých budeme používat příkazy, musíme
počítači sdělit následovně - napíšeme slovo:
Uses a jednotlivé typy knihoven oddělené čárkou. Řádek opět ukončíme středníkem.
Bez knihovny System se nikdy neobejdeme, obsahuje totiž ty nejzákladnější příkazy, které budeme muset
vždy použít, proto počítač automaticky počítá s tím, že bude použita, a proto ji nemusíme uvádět do Uses.
Pokud tedy budeme používat pouze knihovnu System, nemusíme tento řádek vůbec uvádět.

Např. :
Uses Crt, Dos;

Pozor - Pokud patřičnou knihovnu zapomeneme nadefinovat, počítač tyto příkazy nezná a pokud je najde
v našem programu, vyvolá chybu.

3) Nadefinování jednotlivých proměnných, které budou v programu použity:
Většina našich programů bude zpracovávat nějaké informace s daty, které zadáme pomocí klávesnice až
ve spuštěném programu. My ale nevíme, jaká čísla nebo slova budou zadána. Tento problém se řeší
pomocí proměnných stejně jako v matematice.
Každému číslu nebo slovu, které bude zadané dodatečně, přiřadíme určité písmenko nebo slovo, které
nazveme proměnnou. Potom místo konkrétního čísla nebo slova budeme psát tuto proměnnou. Jakmile
budou konkrétní hodnoty známé, počítač si již dosadí sám. Je nutné ale dodat, že proměnné mohou být
různých typů. Za některé budeme dosazovat číslo, za jiné znak, ještě za jiné slovo atd. Rozeznáváme tedy
více typů proměnných :

a) Nejběžněji používané jednoduché proměnné :

Název                          Typ                            Rozsah
Byte                           Celé číslo                     0 – 255
Word                           Celé číslo                     0 – 65535
Integer                        Celé číslo                     -32768 – 32767
LongInt                        Celé číslo                     -2147483648 – 2147483647
Real                           Reálné číslo
Char                           Jeden znak
String                         Množina znaků = slovo, věta    Max. 255 znaků
Boolean                        Logická                        True nebo False

Další část našeho programu tedy bude vypadat :
Var – tímto slovem dáme počítači najevo, že začínáme definovat typy proměnných, které použijeme dále
v našem programu

Např.
Var
I, J : Byte;
    K : Word;
P, Q : Real;

Nadefinovali jsme proměnné I, J jako čísla od 0 do 255, K jako číslo od 0 do 65535 a P, Q jako reálná
čísla.
Všimněte si, že jednotlivé proměnné oddělujeme čárkou, nakonec napíšeme dvojtečku, potom typ, který
proměnným přiřazujeme a řádek ukončíme středníkem. Všimněte si také, že za klíčovým slovem Var
středník nepíšeme.

Složitější je to s typem String :
Pokud víme, kolik náš řetězec bude obsahovat maximálně znaků, můžeme proměnnou typu String omezit
tím, že za ni do hranaté závorky napíšeme toto číslo. Toto číslo může maximálně nabývat hodnoty 255.
Např.
Var
Slovo : String[10];

V příkladu do proměnné slovo můžeme zapsat maximálně 10 znaků. Napíšeme-li jich více, nadbytečné
znaky budou odříznuty. Proto, pokud nevíme, kolik znaků bude naše proměnná přesně obsahovat, je lepší
si nechat určitou rezervu.
Pokud závorku s číslem neuvedeme, automaticky je mu přiřazena maximální hodnota tj. 255.

Typ: Místo proměnné typu Char můžeme tedy psát :

Var
Znak : String[1];

b) Proměnné typu pole
Představte si, že budeme chtít napsat program, který bude určitým způsobem zpracovávat všechna čísla
tažená ve Sportce v celém roce. Máme na to 2 možnosti, jak přichystat jednotlivé proměnné tak, abychom
mohli do nich napsat opravdu všechna čísla. A jak už to v životě bývá, jedna možnost je horší a druhá
lepší :

1) Výpisem všech proměnných
var
Tyden1Cislo1, Tyden1Cislo2, Tyden1Cislo3,…
Tyden1Cislo6, Tyden2Cislo1,… : byte;

Samozřejmě tři tečky uvádím pouze pro úsporu místa. V naše programu bychom ale museli vypsat všech
6x54 proměnných. Je vidět že toto natypování je nepraktické, a proto si zahrajeme na zemědělce a
naučíme se pracovat s proměnnou typu pole:

2) Pomocí pole
Pole si můžeme představit jako tabulku čísel určitého typu. Pro náš případ postačí taková tabulka, která
bude obsahovat pouze čísla typu byte :

             1. číslo     2. číslo      3. číslo     4. číslo      5. číslo      6. číslo
1. týden
2. týden
…
54. týden

čísla budeme tedy vpisovat do nějakého pole, definujeme je pomocí slova array:

Var
Cisla : Array[1..6,1..54] of byte;

Tím máme nadefinovány také místa pro všechna čísla Sportky
Všimněte si, jak se Array používá :

Za slovo Array se do hranaté závorky udají parametry tabulky.
1..6 nám říká, že první souřadnice nabývá hodnoty od 1 do 6
1..54 druhá souřadnice nabývá hodnoty od 1 do 54

- obecně bychom mohli vytvořit pole o n-souřadnicích.
Za závorkami následuje slovo of a za ním typ našich proměnných. V našem případě je to byte, protože
žádné tažené číslo nebude větší než 255.

Pokud chceme později pracovat s touto proměnnou v programu, odkážeme se na ni tak, že napíšeme její
název a do hranaté závorky pozice v poli.

Např. 2. Tažené číslo v 5. Týdnu nám reprezentuje proměnná : Cisla[2,5]

Typ : Proměnná typu String se dá zapsat také takto :

Var
Veta : Array[0..255] of char;


4) Tělo hlavního programu

Begin
- Tady je celý náš program
End.

Nakonec píšeme vlastní program, který uvedeme slovem Begin a ukončíme slovem End s tečkou.

Struktura může obsahovat i více různých věcí, jako např. Type, ale o těch se zmíníme dále.

III. Začínáme psát jednoduché programy
1) Psaní komentářů
Libovolný komentář můžeme napsat v našem programu do složených závorek nebo pomocí závorky a
hvězdičky. Tyto řádky počítač automaticky přeskakuje, ale náš program se stává přehlednějším. Složitější
řádky bychom měli komentovat, co děláme, protože později nám to umožní lepší orientaci v programu.

{ Toto je náš komentář }
(* Toto je také komentář *)

2) Přiřazení hodnoty našim proměnným a práce s nimi
Proměnným, které jsme si již předdefinovali pomocí Var, musíme umět přiřadit konkrétní hodnoty, jinak
nemají žádný smysl.

Přiřazovat můžeme více způsoby. Uvedeme si nejzákladnější dva :

a) Proměnné přiřadíme hodnotu přímo v programu
Přiřazení se značí pomocí := (dvojtečka rovná se);

- Proměnná číselného typu – očekává číslo, desetinou čárku značíme tečkou.
A:=1; { proměnné A jsme přiřadili jedničku }

- Proměnná textového typu – očekává text, který musí být vložen do uvozovek
Slovo := ‘Ahoj’;
- Proměnná typu Boolean – očekává pouze hodnou TRUE (=pravda) nebo FALSE (=nepravda)
Stav:=False;

Dříve jsme si řekli, že pokud napíšeme kdekoliv v programu název libovolné proměnné, program si pod
tímto názvem představí již konkrétní hodnotu, která jí byla přiřazena. Proto můžeme proměnné1 přiřadit
proměnnou2, která je stejného typu a má už přiřazenou konkrétní hodnotu

Var
  Veta1, Veta2 : String

Begin
  Veta1 := ’Toto je text pro větu1, který přiřadíme i větě2’;
  Veta2 := Veta1;
End;

b) proměnné přiřadíme hodnotu ve spuštěném programu pomocí klávesnice :
k tomu složí příkaz :

Read( sem napíšeme název naší proměnné );

Jakmile spuštěný program dojde k tomuto řádku, žádá z klávesnice číslo, slovo nebo větu ukončenou
Entrem, která se bude v průběhu našeho psaní vypisovat na pozici kurzoru. Při stisku klávesy Enter se
tedy přiřadí naší proměnné číslo, slovo, nebo věta z klávesnice. Musíme ale dávat pozor, abychom
nepřiřadily proměnná typu číslo nějaká slovo apod. Program by vyvolal chybu nebo se zasekl. Opak dělá
příkaz Write

Write( sem napíšeme parametr );

Tento parametr bude vypsán na monitoru na pozici kurzoru. Možná jste si všimli, že u příkazu Read jsem
uvedl : sem napíšeme název naší proměnné a u write sem napíšeme parametr. Je to proto, protože u
příkazu write může být parametrem jak proměnná, tak i konkrétní hodnota. Proč nemůžeme přiřadit
příkazu read parametrem konkrétní hodnotu, na to přijdete určitě sami.

Podobně se chovají příkazy ReadLn a WriteLn, ale ty po jejich vykonání posunou kurzor na začátek
nového řádku, takže při dalším volání těchto příkazů a příkazů Write, Read a dalších se vše začne psát na
nový řádek.

Pokud chceme zapsat na obrazovku více textů za sebou, použijeme opakovaně příkaz Write nebo také jej
můžeme použit pouze jednou a jako parametr vypíšeme jednotlivé proměnné nebo konkrétní hodnoty
oddělené čárkou.

Ještě je dobré znát příkaz :

ClrScr; - píše se bez parametrů a smaže nám obrazovku. Ten ale obsahuje knihovna Crt, proto ji
musíme uvést do Uses.

Begin
  I:=10;
  Write(‘Proměnné I byla přiřazena hodnota ‘);
  Write(I);
End.

nebo
Begin
  I:=10;
  Write (‘Proměnné I byla přiřazena hodnota ’,I);
End.

3) Práce s čísly
- Používají se proměnné typu Byte, Word, Integer, LongInt, Real

Pro práci s čísly se nejčastěji používají tyto operace:
+ … plus – sčítá jednotlivá čísla
- … minus – odčítá jednotlivá čísla
* … krát – násobí jednotlivá čísla
/ … děleno – dělí 2 čísla - pozor při dělení dvou celých čísel můžeme dostat racionální číslo.
div … vydělí 2 čísla a odtrhne jim zbytek např. 5 div 2 = 2
mod … vydělí 2 čísla a zapíše pouze zbytek při jejich dělení např. 5 mod 2 = 1
dále se hodně používá příkaz trunc(číslo), který odtrhne od parametru číslo desetinnou část.

4) Práce se znaky a textem
- Používají se proměnné typu Char, String

Pro práci s řetězci se hlavně používá :
+ … plus – sloučí jednotlivé řetězce nebo znaky v jeden řetězec
Jednotlivým proměnným typu string a char přiřazujeme znak(y) v programu tak, že je narozdíl od čísel
vládáme do jednoduchých uvozovek. Pokud chceme přiřadit znak, který pomocí klávesnice nemůžeme
zapsat, zapíšeme jej pomocí ASCII kódu, před který uvedeme znak # a jednotlivé znaky sloučíme pomocí
+.

Var
  Text : String[4];

Begin
  Text := ‘ahoj’;
  Text := #97+#104+#111+#106;                   {Oba řádky dělají totéž}
End.

Jak se dá vypsat např. druhý znak z proměnné text je popsáno dále

5) Práce s polem
Již jsme si řekli, že pole si můžeme představit jako tabulku čísel, znaků nebo vět stejného typu.
Pomocí Array jsme do hranatých závorek nadefinovali její rozsah. Jednotlivé hodnoty přiřazujeme potom
takto:

Název proměnné [souřadnice v tabulce] := … ; souřadnic píšeme tolik a tak, jak byly definovány pomocí
array.

Vraťme se k výpisu čísel Sportky. Řekli jsme si, že pole nadefinujeme takto :

Var
Cisla : Array[1..6,1..54] of byte;

Kde 1. parametr je od 1 do 6 a udává kolikáté je to tažené číslo a 2. Parametr nám udává týden tažení od
1 do 54.
Pokud např. tažené druhé číslo ve 12. týdnu byla pětka, přiřadíme:

Cisla[2,12]:=5;

Typ: Dříve jsme si řekli, že proměnná typu String je vlastně pole znaků. Můžeme si ji tedy představit jako
tabulku s jedním sloupcem, kde v každém okénku je jeden znak.
Pokud je např. proměnná slovo typu string, proměnná slovo[x] nám vypíše x-tý znak.

Tento fakt nám napomáhá vybírat z věty pouze konkrétní znaky, které potřebujeme.

Např.
Var
Slovo : string;
PrvniZnak : char;

Begin
  Writeln(‘Zapište sem slovo’);
  Readln(slovo);
  PrvniZnak:=Slovo[1];
  Writeln (‘První znak slova je : ‘,PrvniZnak);
End.

Zajímavost:
Jednotlivým znakům ve slově přísluší takové indexy v poli, na jakém pořadí se nacházejí.
Ale řekli jsme si že string = array [0..255] of byte. Co se tedy nachází na nultém místě v poli ?
Tam je uložena v ASCII-kódu skutečná délka slova. O to se my nestaráme, je tam přepočítávána
automaticky. Jakmile dopíšeme slovo, spočítá se počet znaků, v ASCII – tabulce se najde tomuto číslu od
0 do 255 příslušný znak a zapíše se na nultou pozici.

Ukážeme si to na příkladě. Budeme ale muset použít nové příkazy :

Chr(číslo) – pod námi zadaným číslem si představí znak z ASCII tabulky na této pozici.
Ord(znak) – dělá opak – pod námi zadaným znakem si představí číslo, které určuje pozici našeho znaku
v Ascii tabulce.

Var
Slovo:string;
Delka:byte;

Begin
  WriteLn(‘Zapište slovo‘);
  ReadLn(Slovo);
  Delka:=Ord(Slovo[0]); {V nultém znaku je uložen znak,                                           který
charakterizuje délku slova, ten ale musíme převést na číslo}
  Writeln(‘Délka slova je : ’,Delka);
End.

6) Testování podmínek
Určitě budeme muset v našem programu otestovat platnost nějaké podmínky. Pokud platit bude, vykoná
se určitá část programu a pokud platit nebude, vykoná se úplně jiná část.

K tomu slouží příkaz If nebo příkaz Case :
a) příkaz If

If podmínka then
   Begin
{Tento oddíl ohraničený slovy Begin a End; se vykoná jen tehdy, když podmínka bude   pravdivá.}
   End ;
{Zde bude program pokračovat automaticky}

nebo i s příkazem ELSE

If podmínka then
   Begin
{Tento oddíl se vykoná, bude-li podmínka pravdivá}
   End {bez středníku}
Else
   Begin
{Tento oddíl se vykoná, bude-li podmínka nepravdivá}
   End ; {se středníkem}
{Zde bude program pokračovat automaticky}

Pozn.
- Pokud oddíl mezi Begin a end obsahuje pouze jeden příkaz, nemusíme jej ohraničovat těmito slovy.
- Podmínka Else není nutná viz. příklad výše.
- Poslední příkaz před slovem Else a samotné Else nekončí středníkem.


Operátory pro podmínky :

A = B … rovná se – podmínka je pravdivá, jestli hodnota A je stejná jako B
A <> B … nerovná se - opak

A > B … je větší - podmínka je pravdivá, jestli hodnota A je větší jako B
A <= B … menší nebo rovno - opak

A < B … je menší - podmínka je pravdivá, jestli hodnota A je menší jako B
A >= B … větší nebo rovno – opak

Pozn. Text1>Text2 – porovnává jednotlivé znaky podle pozice Ascii tabulce. Protože ty jsou řazeny
podle abecedy, bude podmínka pravdivá, pokud Text1 bude dál v abecedě než Text2.

Např.
Var
  Cislo:byte

Begin
  WriteLn (‘Zvolte číslo do 100’);
  ReadLn(Cislo);
  If Cislo<50 then
     Writeln(‘Vaše číslo je menší než 50’)
  Else
     Writeln(‘Vaše číslo je větší nebo rovno 50’);
  Writeln(‘Konec’);
End.
Testování několika podmínek současně :
- Jednotlivé podmínky musíme zapisovat do kulatých závorek
- Mezi jednotlivými podmínkami píšeme nejčastěji operátory AND, OR

AND :
If (podmínka1) and (podmínka2) and … then …
- Celek bude pravdivý, když všechny podmínky budou pravdivé

OR :
If (podmínka1) or (podmínka2) or … then …
- Celek bude pravdivý, když aspoň jedna podmínka bude pravdivá

Negace podmínky :

NOT :
If Not (Podmínka) then …
- bude pravdivé, když podmínka bude nepravdivá a naopak

b) Testování pomocí Case

-   Představme si, že máme proměnnou “den” typu byte a ta obsahuje číslo 1-7, které nám určuje,
    kolikátý den v týdnu právě je. My ale budeme chtít vypsat název tohoto dne slovem. Už víme, že
    pomocí If by to vypadalo následovně :

If den=1 then WriteLn(„Pondělí‟);
If den=2 then WriteLn(„Úterý‟);
…
If den=7 then WriteLn(„Neděle‟);

Pomocí Case bude program jednodušší :

Case den Of { za Of nepíšeme středník }
  1 : WriteLn(„Pondělí‟);
  2 : WriteLn(„Úterý‟);
  …
  7 : WriteLn(„Neděle‟)
  Else WriteLn(„Tolikátý den u nás nemáme‟);
end; {End ukončí příkaz Case}

Obecné použití příkazu case je tedy:

Case proměnná Of
  hodnota1 :
     Begin
        {vykonej tento blok za předpokladu, že proměnná=hodnota1 }
     End;
  hodnota2 :
     Begin
         {vykonej tento blok za předpokladu, že proměnná=hodnota2 }
    End;
…
Else
  Begin
 { Pokud nebyla splněna žádná z podmínek, dělej tento blok }
 End;
End; { Tento End ukončí Case }

Podobně jako u IF:
- Pokud oddíl mezi Begin a End obsahuje pouze jeden příkaz, nemusíme jej ohraničovat těmito slovy.
- Podmínka Else se může vynechat a hned ukončit CASE pomocí End;
- Poslední příkaz před slovem Else nemusí, ale může končit středníkem. (Pozor, u IF nesmělo)

7) Cykly For, Repeat, While
-   Cykly se používají při stálém opakovaní určité části programu, která provádí stejné operace, ale
    s různými hodnotami

a) Obecné použití příkazu For:

For proměnná := počáteční hodnota To konečná hodnota Do
  Begin
  … {blok příkazů}
  End;

Proměnná je typu celé číslo, při zahájení procesu je ji přiřazeno číslo počáteční hodnota. Poté se
provedou příkazy mezi Begin a End; s touto hodnotou. Jakmile program skončí tyto příkazy, proměnná
zvětší svoji hodnotu o 1 a znovu se s novou hodnotou vykoná blok příkazů. To se stále opakuje, pokud
proměnná nepřesáhne číslo konečná hodnota. Poté začne program vykonávat další příkazy pod tímto
cyklem.


Pozn.
- Při záměně slova TO na DOWNTO cyklus proměnné jedničku odečítá
- Pokud oddíl mezi Begin a end obsahuje pouze jeden příkaz, nemusíme jej ohraničovat těmito slovy.

b) Obecné použití příkazu Repeat

Repeat { za Repeat nepíšeme středník }
  {blok příkazů}
Until podmínka;

V podmínce může být zapsán libovolný výraz jako v příkazu IF, který samozřejmě může obsahovat i
operátory AND, OR, NOT. Vždy se aspoň jednou provede blok příkazů. Jakmile program dojde k příkazu
Until, vyhodnotí jestli podmínka platí. Jestli neplatí, celý blok se znovu vykoná a to se opakuje tak
dlouho, než začne podmínka platit. Poté začne program vykonávat další příkazy pod tímto cyklem.

c) Obecné použití příkazu While

While podmínka Do                { za While … Do nepíšeme středník }

Begin
  {Blok příkazů};
End;
Zápis podmínky je stejný jako u Repeat nebo If. Pokud tato podmínka platí, vykoná se blok příkazů, poté
znovu otestuje, jestli podmínka platí. Pokud Ano, Znovu se vykoná blok příkazů a to se bude provádět tak
dlouho, dokud podmínka bude platit. Poté začne program vykonávat další příkazy pod tímto cyklem.

Všimněte si, že v cyklu While nemusí být někdy Blok příkazů vůbec proveden, ale u cyklu Repeat je
proveden vždy aspoň jedenkrát.

Následující program vypisuje všemi možnostmi pomocí cyklů čísla od 1 do 10 :

Var I : Byte;

Begin
  For I:=1 To 10 Do Write(I,’ ‘);
  WriteLn(‘’); {Přejdeme na nový řádek}

  For I:=10 DownTo 1 Do Write(11-I,’ ‘);
  WriteLn(‘’); {Přejdeme na nový řádek}

  I:=1;
  Repeat
    Write(I,’ ‘);
    I:=I+1;
  Until (I=11); {Jakmile I bude 11, cyklus se přeruší číslo 11 již nebude
vytisknuto}
  WriteLn(‘’); {Přejdeme na nový řádek}

  I:=1;
  While (I<11) Do {Dokud I bude menší než 11, bude se postupně vypisovat
a zvyšovat svoji hodnotu o 1}
     Begin
       Write(I,’ ‘);
       I:=I+1;
     End;
End.

Pozn.
Pokud proměnnou I chceme zvětšit o 1, můžeme použít
I:=I+1 nebo příkaz Inc(I)

Pokud proměnnou I chceme zmenšit o 1, můžeme použít
I:=I-1 nebo příkaz Dec(I)


8) Procedury a Funkce

Do teď jsme nerozlišovali rozdíl mezi funkcí a procedurou, prostě vše pro nás byl nějaký příkaz. Teď si
uvědomme rozdíl např. mezi příkazy Chr a Write.
Obě mají společné to, že do nich vlákáme určité parametry, že vykonávají určitou činnost, ale rozdíl je ve
výsledku této činnosti :

U příkazu A:=Chr(číslo) – my zapíšeme jako parametr číslo, ale počítač si pod tímto celkem představí
znak, který můžeme například přiřadit proměnné A, která je typu char.
Pokud nějaký příkaz spustíme jeho názvem a parametry nebo bez parametrů a pod tímto celkem si počítač
představí nějakou konkrétní hodnotu určitého typu, nazveme jej funkcí.

U příkazu Write(parametr) - program vykoná také nějakou funkci, ale pod celkem si nic nepředstaví.
Pokud nějaký příkaz spustíme jeho názvem a parametry nebo bez parametrů a pod tímto celkem si počítač
nic nepředstaví, nazveme jej procedurou.

Musíme ale rozlišovat 2 rozdílné pojmy :
1) Hlavní tělo procedury, které zpracovává určitou věc
2) Pouze spuštění procedury nebo funkce pomocí jejího názvu a parametrů

Do teď jsme pracovali pouze s bodem 2. Např. pokud jsme chtěli vypsat něco na obrazovku, pouze jsme
spustili proceduru write s parametrem. Hlavní tělo této procedury je umístěno mimo náš program o
kterém ani nevíme. Co ale ve skutečnosti musí v něm proběhnou za šílenosti, je nám utajeno.

Nejdříve se naučíme psát procedury, které budou součástí našeho programu.
Náš program s procedurou je jako těhotná žena, kde její plod se samotná procedura.
Tedy je to jakýsi program v programu, který má podobné vlastnosti jako program, ale nazýváme jej
procedurou nebo funkcí

Stejné vlastnosti:
– má také svůj název
– obsahuje pouze své proměnné
– má také vlastní tělo, ohraničené Begin a End; .

Jak je přesně dáno, kde žena nosí svůj plod, tak je také dáno, že procedury a funkce píšeme hned za
všechny definované proměnné (Var). Naše programy mají výhodu proti ženám, že snesou libovolné
množství procedur a funkcí, kdežto žena porodí trojčata a je z toho vedle.
Porod procedur a funkcí a jejich osamostatnění bude probrán až v 8. kapitole – UNIT. Zatím se musíte
spokojit s těhotnými programy.

a) Procedury bez parametrů

- Místo slova Program Název; napíšeme :
Procedure Název ;

- Dále napíšeme slovo Var a definujeme proměnné, které využívá pouze naše procedura.
Jestli zvolíme stejné názvy proměnných jako má hlavní program, nic se neděje, parametry nebudou
vzájemně přepisovány, přestože mají stejný název. Po ukončení této procedury nebo funkce budou stejně
zapomenuty – můžeme s nimi pracovat pouze za chodu procedury, ne však již v těle hlavního programu.

- Mezi klíčová slova Begin a End; napíšeme hlavní tělo procedury - (Pozor, program je ukončený pomocí
End s tečkou, ale procedura a funkce pomocí End se středníkem.

Ukážeme si opět výpis řady čísel od 1 do 10, ale pomocí spuštění procedury
Program VypisCisel;

{zde by patřilo definování proměnných pomocí Var, ale žádné nemáme}

{Zde začíná tělo naší procedury}
Procedure VypisCisla;
Var I: byte;

Begin
  For I:=1 To 10 Do WriteLn(I,’ ‘);
  Writeln(‘’); {Přejdeme na nový řádek}
End;
{Zde končí tělo naší procedury}

{Zde teprve začíná náš hlavní program}
Begin
  Writeln(‘Teď vám vypíšu čísla do 10 pomocí procedury :’);
  VypisCisla;
  Writeln(‘A ještě dvakrát :’);
  VypisCisla;
  VypisCisla;
End.

b) Procedury s jedním parametrem

Nyní použijeme proceduru která se bude spouštět jedním parametrem určitého typu. Všechno bude stejné
až na pár výjimek:
- Tuto proceduru budeme muset i s tímto parametrem spouštět – buď pomocí proměnné nebo konkrétního
textu
- Budeme muset změnit v těle procedury její název tak, aby byla schopna parametr přijmout: Úvodní
hlavička procedury tedy nebude obsahovat pouze její název, ale bude vypadat následovně :

Procedure Název( proměnná : typ );

- na místo proměnná napíšeme název nějaké nové proměnné, která bude typu typ a pod tímto názvem
tohoto typu ji bude procedura znát. Tato proměnná se bude tvářit, jako každá jiná definovaná pomocí Var.
Po ukončení procedury bude zapomenuta stejně jako jednotlivé proměnné definované v proceduře
pomocí Var. Tím proceduru připravujeme na fakt, že bude spouštěna s parametrem typu typ. Tuto
proměnnou už nedefinujeme pomocí Var.

Vytvořme si proceduru, která bude mít název PisOpacne, bude se chovat stejně jako WriteLn, ale celé
věty bude psát opačně. Parametr bude tedy typu String:

Program Opacne;

Var
Veta : String;

{Zde začíná tělo naší procedury}

Procedure PisOpacne(Text:String); {Procedura očekává, že bude spouštěna
parametrem typu string a tento řetězec uloží do proměnné Text }
Var
Pozice, DelkaVety : Byte;

Begin
  DelkaVety:=Ord(Text[0]);
  For Pozice:=DelkaVety DownTo 1 do Write(Text[Pozice]);
  { Postupně Budeme brát jednotlivá písmenka pozpátku a jednotlivě
vypisovat }
  WriteLn(‘’); { Přejdeme na nový řádek }
End;

{Zde končí tělo naší procedury}

{ Zde začíná hlavní tělo programu }
Begin
  WriteLn(‘Umím napsat pozpátku slovo počítač :’);
  PisOpacne(‘počítač’);
  WriteLn(‘Teď si vyber sám, co mám napsat pozpátku’);
  ReadLn(Veta);
  PisOpacne(Veta);
End.

Všimněte si, že klidně můžeme spustit proceduru s proměnnou Veta, ale procedura ji přijme pod názvem
Text – nezáleží na názvu, ale musí být stejného typu. Jak počítač opouští tělo našeho programu a utíká do
těla procedury, aby ji mohl zpracovat, nese si s sebou už hotový text nebo číslo, který ji má “sdělit”.
Pokud je tedy zadán pomocí proměnné, nese již její hodnotu. V našem případě to není slovo Veta ale
hned text, který obsahuje. Jakmile doběhne k proceduře, ta už prakticky nepozná, zda byla spuštěna
s proměnnou nebo s konkrétním textem.

c) Procedury s více parametry

Chovají se podobně jako procedury s jedním parametrem, ale musíme si říct, jak je budeme oddělovat
mezi s sebou :

- Při spouštění procedury s více parametry je zapíšeme do kulaté závorky stejně jako při jednom
parametru a oddělíme je čárkami. Pozor, záleží na pořadí. V jakém pořadí je napíšeme, v takovém je tělo
procedury přijme.

- V hlavičce těla procedury parametry stejného typu oddělujeme čárkami až by měl následovat jiný typ,
napíšeme dvojtečku a typ předcházejících, poté středník a tak pokračujeme.

Např. Proceduru s názvem Abc a s postupně třemi parametry typu byte a jedním typu string bychom
spustili např. příkazem :
        Abc(12,1,80,’Prostějov’);

Hlavičku těla procedury bychom definovaly :
       Procedure Abc( k,l,m : byte; nazev : string);

d) Funkce

Psaní funkcí je podobné jako psaní procedury. Vše, co jsme dělali u procedur, budeme dělat i tady a ještě
něco navíc.
Parametry a název definujeme úplně stejně jako u procedury, odlišnosti jsou pouze tyto:

V hlavičce :
- Místo Procedure napíšeme Function
- Za kulatou závorku s parametry napíšeme dvojtečku a typ, pod kterým si bude počítač představovat
   výsledek

Function Název( proměnná1 : typ1; proměnná2 : typ2;… ) : TypVýsledný;

Např. funkci Ord již někdo za nás nadefinoval

Function Ord(znak : Char): LongInt;
- Funkce je spouštěna parametrem typu Char ale ten se zpracuje a pod celkem si počítač představí
   číslo typu LongInt. Obsahem těla funkce se nebudeme zabývat.

Teď tedy víme, jak zadat typ výsledné funkční hodnoty, ale musíme si také říct jak přiřadit samotnou
hodnotu. Je to velice jednoduché. Stačí si představit proměnnou, která má stejný název jako naše funkce a
s typem, který funkce vrací. Tuto proměnnou ale nebudeme zapisovat do bloku Var. Těsně před
ukončením těla procedury této imaginární (neskutečné) proměnné přiřadíme patřičnou hodnotu a tu naše
funkce vrátí. Stručně řečeno, patřičnou hodnotu přiřadíme názvu procedury.

Vytvořme program, který obsahuje funkci, která nám bude počítat Faktoriál:

Program Matematika;

Var
  Cislo : Byte;
  Fak : Longint;

Funkction Faktorial(Zceho : Byte):Longint;
{ Zadáme malé číslo typu Byte a počítač z něj vrátí jeho faktoriál typu
Longint }

Var
Pomocná : Byte;
Vysledek : Longint;

Begin
  Vysledek:=1;
  For I:=1 To Zceho do Vysledek := Vysledek * I;
  { Postupně Vysledek násobíme 1x, 2x, 3x, … celkem tolikrát, z čeho
faktoriál chceme dostat , nakonec v proměnné výsledek máme požadovaný
faktoriál}
  Faktorial:=Vysledek; { Tuto Hodnotu Funkce vrátí }
End;

{Zde začíná tělo programu}
Begin
  Writeln(‘Z čeho určit faktoriál ?’);
  ReadLn(Cislo);
  Fak:=Faktorial(Cislo);
  WriteLn(‘faktoriál je ‘,Fak);
End.
Je tedy vidět, že práce s procedurami a funkcemi je složitá záležitost. A aby to bylo ještě složitější,
musíme si říct, že procedura se někdy může chovat podobně jako funkce, protože je to často potřebné
využívat.

e) Procedury se zpětnými parametry

Nevýhodou funkce je, že nám “spolkne” třeba 10 parametrů různých typů, ale vrátí vždy pouze jediný.
Představme si případ, že budeme chtít poslat dva parametry, ale vrátit také dva. Buď bychom museli
napsat dvě funkce, z kterých by každá vracela jeden, nebo použijeme procedury, ale trochu jinak, než
jsme byli do teď zvyklí.
Typickou procedurou je Write. Zadáme parametr ve formě proměnné nebo přímo textu. Tento text
procedura vypíše na obrazovku a poté je nenávratně pryč.
Jinak je tomu ale u Read. Parametr musíme zadat pouze pomocí proměnné. Do této proměnné je pak
zapsán text, který byl odchycen z klávesnice. Všimněte si tohoto rozdílu. Zatímco Write od nás parametr
“sežere”, Read nám ho “vy… hm, radši vrátí”

Obecně tedy Proceduru voláme parametry. Musíme ale rozlišovat 2 typy parametrů :
- Parametry, které jsou zadány pomocí proměnných a pomocí konkrétních hodnot a které nám
   procedura určitým způsobem zpracuje
- Parametry, které jsou zadány pouze pomocí proměnných a do kterých nám procedura vloží konkrétní
   hodnoty konkrétních typů

O parametrech, které procedura zpracovává jsme se již zmínily a o parametrech které nám pošle zpět jako
výsledek se zmíníme teď. Druhý typ parametrů uvádíme v hlavičce stejně jako první typ, ale napíšeme
před ně ještě slovo Var.

Hlavička Procedury Read může být definována :
Procedure Read( Var Text: String );

Napíšeme Program s procedurou, která bude mít čtyři parametry. Do prvních dvou ji pošleme 2 čísla a
naopak ve 3. a 4. Budeme požadovat, aby nám vrátila jejich součet a jejich součin.

Program Matematika2;

Var
  A,B : Byte;
  Soucet, Soucin : Longint;

Procedure Pocitej(C1,C2 : byte; var Plus,Krat : LongInt)
{ proměnné C1, C2 nám přijdou zadány a naoplátku pošleme zpátky proměnné
plus, krat }

{ Var nebude potřeba }
Begin
  Plus:=C1+C2;
  Krat:=C1*C2;
  {Takové hodnoty máme poslat zpět, dál se už o nic nestaráme, po skončení
procedury budou poslány automaticky}
End;

{Zde začíná tělo programu}
Begin
  Writeln(‘1. číslo’);
  ReadLn(A);
  Writeln(‘2. číslo’);
  ReadLn(B);
  Pocitej (A,B,Soucet,Soucin); { posíláme konkrétní hodnoty A, B pomocí
parametru a budeme vyžadovat vložení do proměnné soucet jejich součet a
do prom. Soucin jejich součin. };
  WriteLn(‘Součet je ’,Soucet);
  Writeln(‘Součin je ’,Soucin);
End.

Pozn. Z procedury nebo funkce můžeme volat jinou proceduru nebo funkci, pokud je volaná procedura
napsána výše. Program totiž při spuštění prochází procedury v jejich pořadí. Jestliže tedy např. v páté
proceduře voláme druhou, nic se neděje protože druhou už celou zná, ale naopak kdybychom ve druhé
volali pátou, počítač k ní ještě nedošel, tedy ji nezná, tedy vyhlásí chybu. Pascal sice tento problém řeší
pomocí slova Far, ale uvádět si ho nemusíme, protože u Delphi už na pořadí nezáleží.

9.Unit
V kapitole 8 jsme probrali, jak se vytváří procedury a funkce. Dále jsme si řekli, že s Pascalem se již
spousta různých procedur a funkcí dodávána, ale proč tedy např. proceduru write můžeme spustit, ale
v našem programu tělo nevidíme ? Je to proto, protože my můžeme libovolné procedury nebo funkce
vložit mimo náš program do tzv. unit = knihovny, kterou nějak pojmenujeme. Unit je tedy speciální
program, který se skládá ze samých těl procedur a funkcí, které můžeme spouštět již z našeho programu.
Každá Unit má své jméno. Pokud se na tuto Unit budeme chtít odkázat, musíme znát její název a ten
zapsát do USES v našem programu. Pokud budeme spouštět procedury a funkce z více Unitů, musíme je
vypsat všechny.
Např. již naprogramovaná procedura ClrScr je v knihovně s názvem CRT, tedy pokud ji budeme chtít
použít, náš program bude muset obsahovat řádek :
Uses : Crt;
Standardně dodávané knihovny jsou vypsány v II. 2).

Struktura Unit :

1) napíšeme slovo Unit a název naší knihovny :

Unit Název;

-   na rozdíl od programu je tento řádek povinný a název musí být stejný s názvem souboru, který unit
    obsahuje.

1) napíšeme slovo :

Interface { bez středníku }

Pod toto slovo napíšeme :
a) Uses a seznam všech jiných knihoven, na které se budeme v této proceduře odvolávat
b) pouze hlavičky těch procedur a funkcí, které se budou moci spouštět z jiných programů.
2) napíšeme slovo :

Implementation { bez středníku }

Pod toto slovo napíšeme :
a) Již celé procedury včetně hlaviček, které jsme nadefinovali v části Interface.
b) Ty procedury a funkce, na které se bude odvolávat pouze naše Unit a nechceme je zpřístupnit
v hlavních programech.

Shrnutí : Část Implementation obsahuje celé procedury a funkce, ale část Interface pouze hlavičky těch
procedur a funkcí, které chceme zpřístupnit z programům užívající náš Unit.

V Delphi budeme používat samé Unity, proto teď není potřeba na ně uvádět příklad.
B. ZÁKLADY PROGRAMOVÁNÍ V DELPHI
                                                  1. Základní obrazovka
                                          2
                                                  Při spuštění Delphi se nám na obrazovce objeví :

              1                                   1.   Prázdné formulářové okno
                                                  2.   Nástrojová lišta + lišta s ikonami
     3                                            3.
                                                  4.
                                                       Inspektor objektů
                                                       Okno pro psaní zdrojového textu

                                  4             1. Prázdné formulářové okno
                                                Tak bude vypadat náš hlavní formulář při spuštění
                                                programu. Standardně se zobrazí jako čistý, my však
                                                můžeme na něj “nasázet” jednotlivé komponenty (=
                                                tlačítka, spínače, textové rámečky, tabulky, ...), které
budeme chtít v našem programu používat. Jednotlivé komponenty můžeme vybírat z horní lišty ikon.
Každá ikona zobrazuje jednu komponentu. Obrázky nám napovídají, o jakou komponentu půjde. Pokud
to stejně nepřeluštíme, můžeme se na ni postavit myší a chvíli vyčkat - objeví se její anglický název
formou bublinkové nápovědy.

2. Lišta s ikonami
Jednotlivé komponenty jsou uspořádány do skupin. Každá skupina má své jméno - (Standard, Addidional,
...). Mezi jednotlivými skupinami se přepínáme tak, že klikneme na tento název. Na liště se potom
skupina komponent odpovídající názvu. Před první a za poslední komponentou si můžeme všimnout
šipek. Tyto šipky složí v případě, že se všechny komponenty dané skupiny na lištu nevejdou všechny.
Potom jimi můžeme listovat pomocí těchto šipek. Jednotlivé komponenty sázíme na náš formulář tak, že
nejdříve klikneme na vybranou komponentu a potom do našeho formuláře na místo, kde má být
komponenta umístěna. standardně se přichytává k předvolené mřížce, která je vytečkována na našem
formuláři. Můžete si zkusit nasázet náš formulář různé druhy komponent. Pomocí tažení myši můžeme
komponenty přemísťovat.

3. Inspektor objektů
U každé komponenty musíme rozeznávat dvě důležité věci :
a) VLASTNOSTI = Properties - Definuje základní vlastnosti komponenty - kde je umístěna, jak je
veliká, jakou má barvu, jak se nazývá, ...
b) UDÁLOSTI = Events - Definuje, na jaké události bude komponenta reagovat - na kliknutí myší, na
dvojkliknutí, na pouhé “projetí” myší přes komponentu, na stisk dané klávesy atd.

Tyto dvě věci musí mít přiřazena každá komponenta, aby byla funkční. Jednotlivé komponenty si
můžeme takto zobrazit v našem Inspektoru objektů. Mezi výpisem vlastností a událostí se přepínáme
kliknutím na Properties nebo Events. Patřičnou komponentu si můžeme zobrazit v inspektoru tak, že buď
na ni klikneme myší přímo v našem formuláři, nebo ji vybereme z rolovací lišty přímo v inspektoru.
Všimněte si, že náš formulář (původně s názvem Form1) jde také zobrazit v inspektoru - chová se jako
komponenta.
Pokud inspektora uzavřeme pomocí křížku, znovu jej můžeme zobrazit pomocí klávesy F11.

4. Zdrojový text
Zde budeme zapisovat pomocí různých příkazů zdrojový kód, který nám umožní udělat náš program
funkční. Je logické, že se nestačí radovat pouze z toho, že náš formulář má plno zajímavých komponent,
když žádná z nich nebude vědět, co má vlastně v našem programu vykonávat. Sem se tedy zapíše, že
např. při stisknutí určitého tlačítka se vykoná v programu určitá činnost.
2. Práce s komponentami
a) Začneme jednoduchým programem
Umístěte na formulář tlačítko Button (skupina Standard, 6. zleva)
Všimněte si v inspektoru objektů, že i tak jednoduché tlačítko má spoustu vlastností.

Hodně se pletou vlastnosti Caption a Name. Obě mají totiž nejprve přiřazený stejný název. Rozdíl je v
tom, že :
Name je název naší komponenty pod kterým si náš program bude komponentu pamatovat a tímto jménem
se na ni budeme odkazovat. Toto přiřazení se většinou nechává beze změny.
Caption je to text, který bude na naší komponentě zobrazen v programu. Ten si většinou přepíšeme na
funkci, kterou bude komponenta vykonávat.

Další důležité vlastnosti :
Top - umístění tlačítka shora vzhledem k formuláři
Left - umístění tlačítka zleva vzhledem k formuláři
Width - šířka tlačítka
Height - výška tlačítka

Všimněte si, že vlastnost tlačítka a skutečná poloha jsou vzájemně propojeny. Pohneme-li tlačítkem na
formuláři, změní se jeho hodnoty v inspektoru a naopak.

PROGRAM 1 : Nyní se pokusíme udělat krátký program, který kliknutím na tlačítko nám změní jeho
popis.

- inspektoru objektů vybereme u našeho tlačítka události (Events) a klikneme na událost OnClick = na
kliknutí. V ten okamžik se v inspektoru přiřadí název procedury, která bude na tuto událost spuštěna (v
našem případě Button1Click) a hned se nám vygeneruje hlavička této procedury. Co napíšeme sem mezi
klíčová slova begin a end, to bude provedeno. Pokud bychom tento název přiřadili v inspektoru více
událostem, bude spuštěno tělo naší procedury u všech událostí, kterým byl přiřazen název této procedury.

Nyní si musíme umět představit všeobecně objektové programování jako např. adresáře a podadresáře.
Představme si, že
- Náš program má svůj adresář
- Každý formulář (v našem případě 1) bude mít v tomto adresáři podadresář s tímto názvem
- Jednotlivé komponenty na jednotlivých formulářích (v našem případě tlačítko Button) bude mít další
podadresář s tímto názvem
- Každá komponenta má své vlastnosti a události, které tvoří další větve adresáře

Narozdíl od adresářů budeme jednotlivé členění oddělovat místo opačného lomítka tečkou.

Pokud bychom byly např. v úplně jiném formuláři a chtěli změnit popis našeho tlačítka Button1 ve
Form1, odvolali bychom se na něj :
Form1.Button1.Caption := ‘nový název’

Tato činnost vyvolá ve spuštěném programu stejnou věc, jako v nespuštěném přes inspektor objektů.

Protože my se nacházíme již v našem formuláři Form1, stačí se odvolat :
Button1.Caption := ‘nový název’

Program spustíme pomocí F9, nebo zelenou šipkou vlevo od lišty s ikonami.
b) Nejpoužívanější vlastnosti a události objektů a formulářů
Pokud jste pochopili na jednoduchém příkladu, co je vlastnost a co událost a jak je můžeme obsluhovat,
uvedeme si nejpoužívanější vlastnosti a události, které má většina komponent.
Některé vlastnosti mají ještě své podvlastnosti - jsou označeny před názvem “+”.
Např. +Font. Celkem budeme měnit písmo na komponentě, ale musíme měnit : velikost, typ písma,
barvu, kurzívu, ...
Takové vlastnosti někdy obsahují místo rozbalovací šipky tři tečky. Při kliknutím na tyto tečky se otevře
úhledný formulář, kde všechny vlastnosti nastavíme.
Problém však nastane, pokud tři tečky neobsahují nebo pokud budeme měnit vlastnosti ze spuštěného
programu. Proto lze podvlastnosti měnit i jiným způsobem. Pokud uděláme dvojklik na názvu této
vlastnosti, otevřou se ty samé podvlastnosti, ale formou tabulky. Zpětným dvojklikem tabulku zavřeme. V
programu se tedy můžeme odvolávat na podvlastnosti pomocí tečky jako na další podadresář. Pokud
všechny z nich jsou typu boolean (true/false),
potom můžeme všechny ty, které mají nabývat hodnoty true vypsat do hranaté závorky a oddělit čárkami
viz. příklady.

Např. Ve Form1 u Tlačítka Button1 budeme chtít změnit typ písma :
       Form1.Button1.Font.Name:=‘Times New Roman CE’
Např. V hlavním formuláři budeme chtít moci použít pouze minimalizační a maximalizační tlačítko :
       Form1.BorderIcons:=[biMinimize, biMaximize]

Vlastnosti (properties) komponent:
Align - kde se bude komponenta nacházet
        alNone- tam, kde byla námi umístěna (vždy nastaveno jako standardní)
        alClient- natáhne se pře celý formulář i když se změní jeho velikost
        alBottom (alTop)- celá spodní (horní) část formuláře, přičemž výška zůstane zachována
        alLeft (alRight)- celá levá (pravá) část formuláře, přičemž šířka zůstane zachována
        pzn. Vyzkoušejte na komp. MEMO a měňte velikost formuláře
Alignment - zarovnání textu v ikoně vlevo, vpravo, doprostřed
Caption - popis, který se zobrazí na komponentě
Checked - u těch komponent, které lze zatrhávat (RadioButton, CheckBox, ...)
        true = je zatržena, false = není zatržena
Cursor - tvar kurzoru při ukázání na danou komponentu
např. křížek = crCross
        standardní šipka = crDefault
        přesýpací hodiny = crHourGlass ...
        (nastavení se projeví až ve spuštěném programu)
Enabled - true = komponenta je aktivní - můžeme ji využít
            false = komponenta je “zmrazená” - bude šedá a nebude reagovat na událost.
Font - mění styl písma formou podvlastností
Height - výška komponenty
Hint - bublinková nápověda - po přidržení myši se po chvíli ukáže tento text za předpokladu, že
vlastnost ShowHint je nastavena na True
Left - umístění tlačítka zleva vzhledem k formuláři
Name - název komponenty
Top - umístění komponenty shora vzhledem k formuláři
Visible - viditelnost. Pokud je nastavena na false, komponenta se ve spuštěném programu       nezobrazí
Width - šířka komponenty

Ostatní vlastnosti jsou méně užívané nebo se vztahují ke specifickým komponentám. Některé z nich si
ukážeme při konkrétní komponentě.
Vlastnost DragCursor a DragMode, kterou obsahují všechny komponenty, je probrána v kapitole Drag
and Drop.

Vlastnosti (properties) pro formuláře
Většina z nich je stejná jako výše uvedené. Protože s formuláři budeme pracovat pořád, uvedeme si
některé další (ty nejpoužívanější)

AutoScrool - true = při “přetečení” nějaké komponenty mimo náš formulář se vytvoří rolovací lišty
BorderIcons - podvlastnosti nastaveny na false = U hlavního formuláře tyto komponenty nebudeme moci
používat - budou zmrazené, u podformulářového okna se ani nezobrazí
BorderStyle - Nastaví typ olemování formuláře + možnost a nemožnost měnit velikost formuláře za běhu
programu
       bsSizeable - okraj je a dá se tažením myši měnit velikost (standardně nastaven)
       bsDialog - okraj je a nedá se tažením myši měnit velikost
       bsSingle - okraj je pouze černá čára a velikost se měnit nedá
       bsNone - okraj není a velikost se měnit nedá
ClientHeight, ClientWidth - výška a šířka okna, kam je možno sázet komponenty (tedy bez horního
rámečku a okrajů)
Color - barva formuláře
Icons - Obrázek ikony formuláře
WindowsState - v jakém stavu bude formulář zobrazen = normální, minimalizovaný, maximalizovaný

Nejčastěji užívané události (events)

a) reakce na činnost myši
OnClick - reakce na kliknutí myší (tlačítko dole + potom nahoře)
OnDblClick - reakce na dvojklik myši
OnMouseDown - reakce na tlačítko myši, které je právě stisknuté
OnMouseUp - reakce na tlačítko myši, které bylo stisknuté, ale právě teď je puštěno
OnMouseMove - přes komponentu “přebíhá” kurzor myši

b) reakce na činnost klávesnice
OnKeyPress - reakce na stisk klávesy - (tlačítko dole + potom nahoře)
OnKeyDown - reakce na klávesu, která je právě stisknutá
OnKeyUp - reakce právě na puštěnou klávesu

c) reakce na stav formuláře
OnClose - reakce na zavření formuláře
OnResize - reakce na změnu velikosti formuláře
OnShow - reakce na otevření formuláře

Reakce na události OnDragDrop, OnDragOver, OnEndDrag jsou probrány v kapitole Drag and Drop.

PROGRAM 2: Vytvořte program, obsahující jedno tlačítko, které pokud bude právě stisknuté,
zdvojnásobí svoji výšku a při puštění se vrátí do původní velikosti
Řešení :
Na událost OnMouseDown ... Button1.Height := Button1.Height*2;
Na událost OnMouseUp ... Button1.Height := trunc(Button1.Height/2);
pozn. Trunc zaokrouhluje hodnotu v závorce. Pokud bychom uvedli dělení bez závorky, počítač by se
bál, že dostane desetinné číslo a program by nespustil.
c) Jednotlivé komponenty (nejčastěji užívané)
1. Komponenta MainMenu
                                         Tato komponenta vytváří horní nabídku
                                        Umístěte tuto komponentu na libovolné místo formuláře a
                                        dvakrát na ni klikněte. Zobrazí se nový formulář, kde budeme
                                        moci psát jednotlivé názvy - do vlastnosti Caption v inspektoru
                                        objektů. Při zadání názvu se automaticky umožní napsat položky
                                        do této nabídky nebo vytvořit vedle další nabídku.

 Položky a nabídky můžeme odstranit pomocí klávesy DEL.
 Mezi položky a nabídky můžeme vkládat další pomocí klávesy INS.

 Z inspektoru objektů jsou kromě Caption důležité vlastnosti :
      Checked - true = vytvoří zatržítko před názvem položky
      Enabled - false = tato nabídka je zmrazená - nedá se využít
      ShortCut - přiřadí této položce také stisk kombinace kláves (CTRL + .., ... )

 Pokud ve vlastnosti Caption v názvu naší položky uvedeme znak &, tento znak se nevypíše, ale
  následující písmeno bude podtržené a pomocí této klávesy se rychleji můžeme ve spuštěném programu
  dostat k položce = tzv. horká klávesa. Toto se užívá ve většině programů (viz. Word, Excel, ...)
 Pokud ve vlastnosti Caption v názvu naší položky uvedeme pouze znak minus, bude zde vytvořena
  čára = oddělení podobných položek

Jakmile s nabídkou budeme hotovy, můžeme ji křížkem zavřít. Zobrazí se nám v našem formuláři.
Nyní jakmile klikneme na libovolnou položku v naší nabídce, vytvoří se ihned procedura, která ji bude
obsluhovat, jako to bylo u tlačítka Button.

2. Komponenta PopupMenu
 Při práci s touto komponentou se postupuje stejně jako s MainMenu. setkat se s ní můžeme např. při
   stisku pravého tlačítka myši na textu ve Wordu.

3. Komponenta Label
 Umožňuje vložit needitovatelný nápis do našeho formuláře
 Vlastnosti jsou popsány ve všeobecných.

4. Komponenta Edit
 Umožňuje vložit okno do našeho formuláře, kde je možno psát za běhu programu text
 Tento Text má v inspektoru objektů vlastnost Text, kde jej můžeme předepsat.

5. Komponenta Memo
 Tato komponenta složí pro zobrazení více řádků textu
                            Tyto řádky mají v inspektoru objektů vlastnost Lines. Při kliknutí na tři
                              tečky je již můžeme předepsat. Tyto řádky se dají přepisovat i ve
                              spuštěném programu. Můžete zkusit vložit do nového formuláře pouze
                              tuto komponentu, upravit její vlastnost Align na alClient a program
                              spustit. Vytvoříme si tak jednoduchý poznámkový blok, kde je možné i
                              označovat části textu, kopírovat je pomocí CTRL + INS, SHIFT + INS,
                              mazat pomocí DEL atd.
 Nová důležitá vlastnost v inspektoru objektů je ScroolBars, která zobrazuje komponentě Memo
  rolovací lišty
  - ssBoth - zobrazí obě
  - ssNone - nezobrazí žádnou
  - ssHorizontal (ssVertical) - zobrazí pouze horizontální (vertikální) lištu
 Nyní si musíme vysvětlit poslední problém - jak vkládat řádky textu ve spuštěném programu s tím, že
  je uživatel nemusí vypisovat. Toto můžeme využít i u dalších komponent, které jsou typu Tstring =
  několik řetězců

Je jasné, že se na vlastnost komponenty budeme odvolávat :

např. : Form1.Memo1.Lines.xxx

kde za xxx můžeme dosadit :
(uvádím pro příklad ty nejdůležitější)

Add (‘řetězec’) - přidá na konec seznamu tento řetězec
Clear - vymaže všechny řetězce
Delete (pozice) - odstraní řádek na této pozici
Exchange (pozice1, pozice2) - prohodí tyto řádky mezi sebou
Insert (pozice; ‘řetězec’) - přidá řetězec na tuto pozici
LoadFromFile(‘cesta+název souboru’) - přepíše řádky tímto souborem
SaveToFile(‘cesta+název souboru’) - uloží všechny řádky jako textový soubor

pozn. první řetězec má pozici 0


PROGRAM 3:
Vytvořte program, který vypíše do našeho formuláře nadpis : „Autoexec.bat :‟ a potom následuje výpis
tohoto souboru, který se nachází v hlavním adresáři.

Řešení :
- Vytvoříme nový formulář
- Vložíme do něj komponentu Memo
- Vlastnost Align v Memo nastavíme na alClient, aby se Memo rozrostlo přes celý formulář
- Výpis nastane hned při objevení formuláře tzn. Klikneme ve inspektoru ve Form1 na událost OnShow
- tělo této procedury bude vypadat následovně :

begin
   Memo1.Lines.LoadFromFile('C:\Autoexec.bat');
   Memo1.Lines.Insert(0,'Autoexec.bat :');
end;

Typ: pokud je potřeba se stále odvolávat na vlastnosti, jejichž počáteční adresy se opakují, můžeme
použít:

With část stejné adresy do
  Begin
    jednotlivé vlastnosti bez výše uvedené části adresy
  End;
Tělo naší procedury tedy můžeme také zapsat ve tvaru :
begin
With Memo1.Lines do
   begin
      LoadFromFile('c:\autoexec.bat');
      Insert(0,'Autoexec.bat :');
   end;
end;

6. Tlačítko Button a BitBtn




 Tlačítko Button jsme si uvedli jako vzorový příklad hned na začátku kapitoly
 Musíme se ale zmínit, že máme tlačítka dvojího typu - druhý typ BitBtn ve skupině Additional
 Tlačítko BitBtn nám umožní vložit standardní tlačítko i s obrázkem např. tlačítko OK se zatržítkem,
  tlačítko Cancel s křížkem, tlačítko Help s otazníkem ...
 Vložte tlačítko BitBtn na formulář a v inspektoru objektů si vyberte ve vlastnosti Kind jaké chcete.
  Potom můžete změnit text ve vlastnosti Caption a obrázek zůstane stejný. To nám umožňuje
  počešťovat názvy - např. místo tlačítka Help psát Nápověda atd.

7. Zatrhávací komponenty CheckBox, RadioButton, RadioGroup




 Tyto komponenty se liší nejen tvarem, ale i funkcí. Pokud seskupíme více tlačítek CheckBox, mohou
  být libovolné z nich zatržené nebo ne. U skupiny s tlačítky RadioButton musí být zatrženo nejvýše
  jedno a při zatržení jiného se hned zatržení předcházejícího zruší (viz. na starých televizích přepínání
  programů). Zatržení nebo nezatržení obsluhuje vlastnost Checked.
 Pokud se nachází na jednom formuláři více skupin tlačítek RadioButton, tj. v každé z nich budeme
  chtít mít jedno zatrženo, musíme je vytvořit pomocí předposlední komponenty v skupině Standard -
  RadioGroup. Toto seskupení pracuje nezávisle na ostatních seskupení tlačítek.
 V RadioGroup jsou tyto důležité vlastnosti :
  1. Caption - název skupiny
  2. Items - několik řetězců jako v komponentě Memo - pro každý řetězec bude vytvořeno jedno
  rádiové tlačítko
  3. ItemIndex - určuje, kolikáté tlačítko je v seskupení zatrženo, kdy pro první tlačítko je přiřazena
  nula. Pokud není zatrženo žádné z nich, je jeho hodnota -1.

8. Komponenty pro výběr položky = ListBox, ComboBox




                                                   Tyto komponenty nám zobrazí seznam nabídek, ze
  kterých si jednu můžeme zvolit
 ListBox nám je ihned vypíše do sloupečku, v případě přetečení doplní rolovací lištou. Z tohoto
  sloupečku ve spuštěném programu můžeme vybrat libovolnou nabídku
 ComboBox je komponenta, která je podobná komponentě Edit, ale navíc obsahuje rozbalovací šipku.
  Kliknutím na tuto šipku se teprve roleta rozbalí, poté můžeme vybrat požadovanou položku. Roleta se
  zpět zahrne a položka se zobrazí do okénka
 Jednotlivé položky v obou oknech jsou zapisovány do vlastnosti Items, která je typu string a platí pro
  ni stejné funkce jako pro vlastnost Lines u komponenty Memo.
 U komponenty ComboBox je ihned po spuštění programu v okénku název ComboBox1 - podle
  vlastnosti Caption. Proto jej musíme přepsat na jednu z položek naší nabídky.

9. Vytvoření díky komponentám TabSet a NoteBook více formulářového vzhledu


S víceformulářovým vzhledem jsme se setkali i v Delphi např. výběr u inspektoru objektů
Properties/Events. Jedná se tedy o několik různých stránek, pod kterými jsou napsány jejich názvy
formou záložek a výběrem nějakého názvu si zobrazíme právě tuto stránku.
K tomuto nám poslouží právě komponenta NoteBook - vícestránkový blok zobrazující právě jednu z
nich, Tabset - komponenta záložek.

Důležité vlastnosti komponenty NoteBook :
Pages - typ TString - formou několika řetězců názvy jednotlivých stránek
PageIndex - číslo právě zobrazené stránky (číslováno od nuly !)

Důležité vlastnosti komponenty TabSet :
Tabs - typ Tstring - formou několika řetězců názvy jednotlivých záložek
TabIndex - číslo právě aktivně vysvícené záložky

PROGRAM 4: Vytvořte 3 stránkový dokument, ve kterým budeme listovat pomocí záložek

Rešení :
1. Práce s NoteBook :
- Ze skupiny Additional vložte do prázdného formuláře komponentu NoteBook
- Její vlastnost Align nastavte na alTop
- Otevřete názvy jejich stránek kliknutím na tři tečky u vlastnosti Pages
- Název Default přepište na STRANA1 a do dalších řádků postupně připište STRANA2, STRANA3.
Pomocí tlačítek Edit a Add. Tím NoteBook počítá, že bude obsahovat tři strany.
- Vlastnost PageIndex nastavte na nulu. Tím se objeví náhled pro první stranu. Nasázejte sem např.
několik tlačítek Button.
- Vlastnost PageIndex nastavte na 1 - objeví se náhled na druhou stranu. Sem nasázejte např. několik
nabídek Edit.
- Vlastnost PageIndex nastavte na 2 - objeví se náhled na třetí stranu. Sem dejte např. komponentu Memo.
- Zpět nastavte vlastnost PageIndex na nulu, aby byl při spuštění programu nejprve náhled na první
stranu.

2. Práce s TabSet :
- Ze skupiny Additional vložte do našeho formuláře komponentu TabSet pod NoteBook.
- Její vlastnost Align nastavte na alTop a tím se zobrazí hned pod NoteBook a vytvoří se tak dojem, že z
NoteBooku “vyčnívají” záložky.
- Otevřte názvy záložek kliknutím na tři tečky u vlastnosti Tabs a pojmenujte je opět jako STRANA1,
STRANA2, STRANA3.
- Vlastnost TabIndex nastavte na nulu, aby při spuštění programu byla nejprve vysvícena první záložka.
- Nyní musíme zabezpečit, aby při kliknutí na jinou záložku se přepnula i aktuální stránka v NoteBooku.
V každém případě musí být na TabSet (na záložku) kliknuto myší - program tedy bude muset reagovat na
událost OnClick v TabSet. Potom pouze v NoteBooku nastavíme takovou stranu, kolikátá je aktuální
záložka :

begin
  NoteBook1.PageIndex:=TabSet1.TabIndex;
end;

3. Vytvoření a zrušení komponenty ve spuštěném programu
Vytvoření komponenty
Do teď jsme měli již všechny komponenty nasázené na našem formuláři, než jsme spustili program. Nyní
si ukážeme způsob, jak můžeme vložit komponentu do našeho formuláře až za běhu programu. Obecně to
můžeme udělat příkazem :

T“typ komponenty”.Create(kde vytvořit).vlastnost := hodnota;

 typ komponenty - napíšeme typ komponenty, který musíme uvést znakem “T” tedy např.
TButton - vytvoří tlačítko
TEdit - vytvoří editovatelné okénko
atd.
Pozn. Pokud je třeba někde se odkázat na typ komponenty (ne na název), vždy napíšeme velké “T” a
teprve potom udáme typ.

 za příkaz Create ( =vytvoř ) napíšeme do kulatých závorek, kde se má komponenta vytvořit.
Pokud ji budeme chtít např. vytvořit na našem formuláři s názvem Form1, uvedeme do závorek Form1.

 následuje jedna vlastnost a její hodnota. Tento celý řádek musíme psát pro všechny vlastnosti, které
  budeme chtít nastavit jinak, než jsou standardně nastaveny. Proto si zopakujte, jak můžeme pracovat s
  příkazem With (viz. komponenta Memo)

 POZOR !
často se zapomíná na dvě velice důležité vlastnosti :
- parent = rodič - znovu se musí ve vlastnostech zapsat “rodič komponenty” tj. který formulář ji bude
vlastnit.
Např. parent := Form1;
- visible = viditelnost komponenty - je standardně nastavena při vytváření komponenty na false tj.
komponenta je neviditelná. Nastavením této vlastnosti na true ji teprve zviditelníme.

Zrušení komponenty
Zrušení komponenty provedeme příkazem :

FindComponent(‘název’).Free;

= nalezni ve formuláři komponentu s tímto názvem a uvolni ji.

Pozor !
Za název komponenty vložíme název, který obsahuje vlastnost name - ne typ komponenty !
PROGRAM 5: Vytvořte program, který po spuštění bude obsahovat pouze dvě tlačítka s názvy vytvoř a
zruš. Stiskem těchto tlačítek se nám bude vytvářet a rušit komponenta Edit s nápisem “Jsem nový Edit”.
Ošetřete také možnost stisků tlačítek. Např. Pokud bude komponenta vytvořena, tlačítko “vytvoř” musí
být zmrazené a naopak. Komponenta musí být opravdu vytvářena a odstraňována. Proto nestačí, abyste ji
pouze zneviditelnili nastavením vlastnosti visible na false.

Řešení :
- nejdříve na formulář umístěte obě tlačítka a změňte jejich popis pomocí vlastnosti Caption - U tlačítka s
názvem Button1 změňte popis na Vytvoř a u tlačítka s názvem Button2 na Zruš.
- hned po spuštění programu formulář komponentu Edit obsahovat nebude, proto nastavte u tlačítka s
nápisem Zruš vlastnost Enabled na false.
- napíšeme obsluhu pro stisk tlačítka Button1 - vlastnost OnClick. Celá procedura tedy bude vypadat
následovně :

procedure TForm1.Button1Click(Sender: TObject);
begin
    With TEdit.Create(Form1) do
    begin
       Parent:=Form1;
       Name:='Edit1';
       Text:='Jsem nový Edit';
       Top:=10;
       Left:=10;
       Visible:=true;
    end;
    Button1.Enabled:=false;
    Button2.Enabled:=true;
end;
- tato procedura vytvoří novou komponentu s názvem Edit1 a nastaví správně obě tlačítka

- napíšeme obsluhu pro stisk tlačítka Button2 - vlastnost OnClick. Celá procedura tedy bude vypadat
následovně :

procedure TForm1.Button2Click(Sender: TObject);
begin
  FindComponent('Edit1').Free;
  Button2.Enabled:=false;
  Button1.Enabled:=true;
end;

4. Vložení zprávy
Jistě víte, že když spustíme libovolný program ve Windows, stále se objevují obdélníčky s nápisy :
Nedostatek paměti !, Chyba při čtení !, Příliš málo mikroprocesoru !, Příliš mnoho disket v mechanice !,...
a plno dalších unavujících hlášek. Když naši bývalí programátoři nám těmito zbytečnými hláškami
zpestřovali život, zpestříme i my život našim uživatelům a pokusíme se vymyslet co nejvíce nových
zbytečných a unavujících hlášek...
Nejdříve se musíme ale naučit, jak se taková hláška dělá. Není to nic složitého. Píší se formou:

MessageDlg( ‘Text zprávy’, Typ zprávy, [výčet tlačítek pod textem zprávy], index nápovědy)

 Text zprávy - Tento text bude vypsán v okénku
 Typ zprávy - Definuje, jakého je zpráva typu. Tento typ nám také zobrazí patřičný symbol před textem
   zprávy a objeví se jako název okénka. Nejzákladnější typy jsou :
- mtWarning                  - mtError            - mtInformation              - mtConfirmation




   výčet tlačítek - do hranatých závorek vypíšeme tlačítka, která mají být zobrazena pod textem. Výběr
    těchto a název těchto tlačítek můžeme najít v komponentě BitBtn ve vlastnosti Kind. Název však
    neuvozujeme písmeny bk, ale mb. Pokud nebudeme chtít pod zprávu zobrazit žádné tlačítko, vložíme
    na tuto pozici prázdné uvozovky. Při zobrazování více tlačítek oddělujeme jednotlivé názvy čárkou.
    Názvy tlačítek i s ikonkou ukazuje následující obrázek :




   Index nápovědy nás číslem odkazuje na patřičný text. Nám bude stačit psát číslo 0 - bez nápovědy.

PROGRAM 6: Vytvořte program, který bude obsahovat horní nabídku se třemi položkami a při kliknutí
na jednu z nich se nám vypíše formou informační zprávy tento text s tlačítkem OK.

Řešení :
- Nejdříve vytvořte horní nabídku pomocí komponenty MainMenu se třemi položkami (viz. kapitola
MainMenu)
- Již z nabídky vašeho formuláře klikněte na první položku. Tím se vytvoří hlavička patřičné procedury,
která bude tuto událost obsluhovat.
Vložte sem řádek :

MessageDlg(‘Vybrána Položka1 ’ , mtInformation , [mbOK] , 0)

- Analogicky postupujte pro ostatní položky.


5. Funkce DRAG AND DROP
Tato funkce doslova znamená “táhni a pusť”. Můžeme se s ní setkat např. ve Windows, pokud přemístíme
ikonu z jednoho okna do druhého. Skládá se tedy ze třech části :
1) Stisk tlačítka myší na daném objektu
2) Při stále stisknutém tlačítku pohyb myší = “táhnutí s myší”
3) Puštění stisknutého tlačítka a tím ukončení procesu

Nejlepší bude vysvětlit tuto funkci přímo na příkladě, proto hned začneme programem :

PROGRAM 7: Vytvořte program, který bude obsahovat 3 komponenty typu Edit s různými názvy. Dále
bude obsahovat jedno tlačítko Button. Tažením “textů” z komponent Edit a puštění na tlačítku Button
bude toto tlačítko měnit svůj popis na tento text.

Řešení:
- Nejdříve na formuláři vytvořte tři komponenty Edit, kde nastavte vlastnosti text na různé názvy. Názvy
nevolte příliš dlouhé, aby se do tlačítka vešli. Poté umístěte do formuláře tlačítko Button.

1. Nejdříve musíme nastavit, aby program na tažení reagoval. U těch komponent, kde bude tažení začínat,
musíme přepnout vlastnost DragMode z dmManual na dmAutomatic. Tím předáme obsluhu tažení
myši. (Při nastavení této vlastnosti na dmManual bychom museli uměle vyvolat tažení voláním
“BeginDrag()”).
V našem programu jsou určeny pro začátek tažení všechny 3 komponenty Edit, proto u všech nastavte
tuto vlastnost.
- Nyní klidně spusťte program a vyzkoušejte. Opravdu při kliknutí na libovolnou komponentu Edit se
nám vytvoří tzv. “zakázaný” kurzor, kterým do doby puštění tlačítka můžeme jezdit po obrazovce.

2. Dalším krokem bude připravit komponentu Button na přijmutí tažení. Ta tedy nejprve bude muset
otestovat, zda bylo opravdu taženo z komponenty Edit. Pokud ano, nachystá se přijmout text. K tomu jsou
v Dephi přichystány u každé komponenty 3 události, o kterých jsme se ještě nezmínili.

- OnDragOver - reaguje, pokud bylo na této komponentě právě teď “taženo myší”

- OnDragDrop - reaguje, pokud bylo na této komponentě právě teď ukončeno tažení myší

- OnEndDrag - reaguje, pokud bylo dříve na této komponentě zahájeno tažení a právě teď bylo ukončeno
na jiné.

Nás budou zajímat pouze první 2.

- Klikněte u tlačítka Button na vlastnost OnDragOver. Tím se nám vytvoří hlavička procedury, která
bude spuštěna vždy, jakmile budeme “táhnout” kurzorem přes toto tlačítko. V hlavičce procedury si
můžete přečíst, že nám tato procedura nějaké parametry přináší a nějaké od nás zase očekává.

Přináší nám zejména parametr Source:
- Source - reprezentuje nám neznámou komponentu, u které bylo zahájeno tažení
S touto proměnnou se naučíme dělat dvě věci :
 Pokud potřebujeme zkontrolovat, jestli komponenta, u které bylo zahájeno tažení, je určitého typu,
   stačí napsat podmínku :

       If Source is TTypKomponenty then ...
       Všimněte si také nového porovnávacího příkazu “is”, který nám porovná komponentu a určitý typ
       komponenty. Pokud je tato komponenta daného typu, potom je podmínka splněna, jinak ne.

 Pokud již máme prověřeno, že neznámá komponenta je našeho žádaného typu, můžeme pracovat s
  jejími vlastnostmi. Odvoláváme se na ně :

       TTypKomponenty(Source).vlastnost

- Jak už to v životě bývá, zadarmo ani kuře nehrabe, proto za tyto skvělé informace od nás počítač
očekává, že mu v této proceduře poradíme, zda má tažení přijmout. Proto již pro nás připravil proměnnou
Accept typu boolean, které v této proceduře přiřadíme buď hodnotu true nebo false.
       - pokud přiřadíme True, program se přichystá přijmout na této komponentě konec tažení
       - pokud přiřadíme False, program nebude na této komponentě na ukončené tažení reagovat

Do této procedury vložíme tedy pouze řádek :

If Source is TEdit then Accept:=true else Accept:=false;

Tento řádek tedy znamená : Pokud komponenta, u které bylo zahájeno tažení, je typu TEdit, potom se
program přichystá na ukončení tažení, jinak bude ukončení tažení ignorovat.
- Nyní opět můžete spustit program. Klikněte na libovolnou komponentu Edit a táhněte na tlačítko
Button. Jakmile jste kurzorem na tlačítku, ze “zakázaného” kurzoru se stane “povolený” kurzor a tím je
tlačítko připraveno přijmout konec tažení. Přerušte program a vložte do formuláře např. komponentu
RadioButton. Upravte ji tak, abychom na ní také mohli začít tažení tj. vlastnost DragMode musí být
dmAutomatic. Pokud teď spustíte program a potáhnete tentokrát z RadioButton na tlačítko Button,
tlačítko Button tažení nepřijme, protože RadioButton není typu TEdit.

3. Nyní musí náš program zareagovat na samotné ukončení tažení u komponenty Button. U této
komponenty tedy klikneme na událost onDragDrop a tím se vytvoří hlavička procedury, která bude
obsluhovat tuto událost. Opět je nám předán parametr Source, který nám reprezentuje komponentu, na
které bylo zahájeno tažení.

Do procedury tedy vložíme :

Button1.Caption:=TEdit(Source).Text;

Tento řádek nám přiřadí popisu tlačítka TButton ten text, který obsahuje komponenta typu TEdit ve
vlastnosti text, na které bylo zahájeno tažení. Že se jedná skutečně o TEdit jsme se už přesvědčili v bodě
2, protože komponentám jiného typu program vůbec přijetí neumožní.

6. Využívání již vytvořených dialogových oken
Možná jste si všimli, že se nám ve Windows objevují stejné typy oken např. pro otevření a uložení
souboru, pro nastavení tisku, písma, atd. Tento fakt je velice dobrý pro uživatele programu, který si
nemusí zvykat u různých programů na různá dialogová okna. Také to je velice výhodné pro nás
programátory, protože okna máme již připravena pro všechny aplikace a tím je nemusíme stále vytvářet.
V této kapitole se naučíme pracovat s těmito hotovými formuláři, které už za nás někdo vytvořil.

Delphi má standardní formuláře ve skupině Dialogs - podle jejich názvu a obrázku je patrné, jaké
dialogové okno se zobrazí a k čemu nám bude sloužit. Nyní se naučíme s těmito dialogy pracovat. Vždy
nejprve umístíme komponentu žádaného dialogu na libovolné místo našeho formuláře. Při spuštění
našeho programu stejně tato ikona zmizí jako např. ikona komponenty MainMenu. Uvědomme si, co
vlastně děláme v takových dialogách. Okno se nám zobrazí, my zde provedeme určité nové nastavení.
Poté máme většinou možnost tlačítkem OK tyto změny potvrdit nebo tlačítkem Cancel (v českých
programech Storno) zrušit a nastavení zůstane původní.

V našem programu můžeme otevřít dialogové okno příkazem :

NázevDialogu.Execute;

Pokud budeme chtít rozlišit stisk tlačítek OK nebo Cancel, dialog už s tím počítá. Pokud bylo po
ukončení zvoleno OK tlačítko, tento výraz je zároveň pravdivý a naopak. Dialogy tedy budeme většinou
vytvářet:

If NázevDialogu.Execute then proveď tento příkaz

Tento jediný krátký příkaz vytvoří dialog, nechá nás v něm editovat a po kliknutí na jedno z tlačítek se
uzavře. Pokud bylo zvoleno tlačítko OK, provede se navíc příkaz za příkazem then.

Obsluhu samotného dialogu tedy vůbec neovlivňujeme. Musíme se tedy zmínit o tom, kde se dozvíme, co
uživatel vlastně v dialogu provedl. Každé dialogové okno má také své vlastnosti jako všechny
komponenty.
1. Komponenta OpenDialog a SaveDialog

 obsahuje dialogové okno pro otevření souboru
 Její vlastnosti si můžeme nechat zobrazit v inspektoru objektů jako každé jiné komponenty. Nám se
  stačí omezit na vlastnosti :
                                                            FileName - zde bude ve spuštěném
                                                              programu po zavření dialogu zapsána
                                                              přesná cesta a název souboru, který
                                                              uživatel pomocí dialogového okna
                                                              nalistoval.
                                                            Filter - zde můžeme v ispektoru objektů
                                                              kliknutím na tři tečky nadefinovat typy
                                                              souborů, které si budeme přát, aby
                                                              dialog zobrazoval (viz. obrázek). Do
                                                              prvního sloupečku napíšeme popis
                                                              masky a do pravého udáme masku, podle
                                                              které    budou     ukazované    soubory
                                                              filtrovány.
                                                            DefaultExt - tato přípona se nastaví jako
  standardní

2. Komponenta FontDialog

 Tato komponenta nám umožní nastavit styl písma
 Nejdůležitější její vlastnost je Font, kde je zapsáno veškeré nastavení písma, které uživatel při práci s
  tímto oknem provedl. Možná si vzpomenete, že hodně aplikací má také vlastnost Font. Vlastnost Font
  těchto aplikací je stejného typu, proto ji stačí pouze přiřadit tu vlastnost Font, která je nastavena v
  dialogovém okně FontDialog. Pokud tedy např. Necháme uživatele pracovat s komponentou Memo,
  můžeme mu za běhu programu povolit nastavení typu písma v tomto textu tím že vložíme komponentu
  FontDialog do našeho formuláře a na stisk tlačítka “Změň Font” napíšeme pouze do této procedury
  řádek :

       if FontDialog1.Execute then Memo1.Font:=FontDialog1.Font;

  FontDialog1 je název komponenty FontDialog a Memo1 název komponenty Memo.

PROGRAM 8: Vytvořte program, který bude obsahovat horní nabídku s nabídkami Soubor a Písmo
- Položky nabídky Soubor budou : Otevři (CTRL+O), Ulož Jako (CTRL+S).
- Položky nabídky Písmo budou : Změň písmo, Zarovnej vlevo, Zarovnej vpravo, Vystřeď, kde položka
změň písmo bude oddělena od ostatních čarou.
Tento program bude malým poznámkovým blokem. Každé z nabídek přiřaďte funkci.

Řešení:
- Horní nabídku s položkami vytvořte sami
- Vložte do formuláře komponentu Memo a nastavte její vlastnost Align na alClient
- Vložte do formuláře ikony dialogů : OpenDialog, SaveDialog, FontDialog.
- Nastavte masky u SaveDialog a OpenDialog na *.Txt
- Nejdříve vytvoříme obsluhu pro položku “Otevři” - klikněte na ni ve vašem formuláři. Vytvoří se nová
procedura do ní napíšeme :

       If OpenDialog1.Execute then
            Memo1.Lines.LoadFromFile(OpenDialog1.FileName);
tj. Pokud bylo zvoleno tlačítko OK, OpenDialog.Filename byla přiřazena cesta a název souboru. Teď si
musíte zavzpomínat, jak se pracovalo s komponentou Memo. Zjistíte, že řádek :
“Memo1.Lines.LoadFromFile(cesta a název souboru)” vlastně vloží do komponenty tento soubor. V
závorce tedy není nic jiného, než je vlastnost FileName komponenty OpenDialog1.

- Obdobně vypracujeme proceduru pro obsluhu události “Uložit jako” :

       If SaveDialog1.Execute then
            Memo1.Lines.SaveToFile(SaveDialog1.FileName);

- Přiřazení písma provedeme tak, jak bylo popsáno u komponenty FontDialog tj. Jeho vlastnost Font
přiřadíme vlastnosti Font u komponenty Memo :

       If FontDialog1.Execute then
            Memo1.Font:=FontDialog1.Font;

- Zarovnávání textu v komponentě Memo řídí vlastnost Alignment. Pokud nabývá hodnoty TaLeftJustify,
text je zarovnán vlevo, pokud TaRightJustify, text je zarovnán vpravo a konečně TaCenter zarovná text
doprostřed.

- Procedura na obsluhu Zarovnej vlevo bude pouze obsahovat :
       Memo1.Alignment:=TaLeftJustify;

- Procedura na obsluhu Zarovnej vpravo bude pouze obsahovat :
       Memo1.Alignment:=TaRightJustify;

- Procedura na obsluhu Vystřeď bude pouze obsahovat :
       Memo1.Alignment:=TaCenter;

Tím je program hotový.

Typ : Pokuste se program zdokonalit tak, že do něj zavedete možnost veškeré práce se schránkou

pozn. :
Memo1.CutToClipBoard - vyřízne text do schránky
Memo1.CopyToClipBoard - zkopíruje text do schránky
Memo1.PasteFromClipBoard - přilepí text ze schránky
Memo1.ClearSelection - vymaže označený text
Memo1.SelectAll - označí všechen text v komponentě Memo1

Stačí tedy vytvořit nabídku Úpravy s položkami: Vyjmout, Kopírovat, Vlepit, Vymazat, Označit Vše
Postupně budeme obsluhovat jednotlivé funkce tím, že mezi příkazy begin a end do těl jednotlivých
procedur vložíme patřičný výše uvedený řádek.

7. Jednoduchý přehrávač zvukových souborů a videa.
 Delphi standardně využívá zvukových souborů *.wav a souborů videa *.avi. Nyní se pokusíme
  vytvořit jednoduchý “přehrávač záznamů”. V Delphi je pro nás již vytvořen ovládací panel, který
  obsahuje potřebná tlačítka k přehrávání záznamů. Můžeme jej najít ve skupině System, komponenta
  MediaPlayer:
 Nejzákladnější vlastnosti komponenty MediaPlayer :
- FileName - musí obsahovat cestu a název souboru, který bude přehráván
- VisibleButtons - kliknutím na tento název rozbalíme seznam všech tlačítek. U těch, které nebudeme
chtít vůbec zobrazit, nastavíme hodnotu false

Naši komponentu přivedeme do činnosti :

NázevKomponenty.Open , standardně tedy : MediaPlayer1.Open;

PROGRAM 9: Vytvořte formulář, který bude obsahovat tlačítko “Otevři” a lištu MediaPlayer. Při
kliknutí na toto tlačítko se otevře dialogové okno, které bude zobrazovat pouze soubory *.Wav a *.Avi
Při výběru platného se zpřístupní komponenta MediaPlayer a pomocí ní může být soubor přehrán.

Řešení:
- Do formuláře vložte Komponentu Button, jejiž vlastnost Caption změňte na “Otevřít” a dále
komponentu MediaPlayer. Dále do formuláře vložte komponentu OpenDialog.
- Vytvořte patřičný filtr u komponenty OpenDialog tj. její vlastnost Filter nastavte tak, aby zobrazovala
pouze soubory *.wav a *.avi. tabulkou :
                     Zvuk                           *.wav
                     Video                          *.avi
- Nyní vytvořte proceduru jako reakci na kliknutí na tlačítko Button (OnClick). Do této procedury mezi
příkazy begin a end vložte :

if OpenDialog1.Execute then
    begin
      MediaPlayer1.FileName:=OpenDialog1.FileName;
      MediaPlayer1.Open;
    end;

Tento výpis znamená : Pokud byl v otevřeném formuláři vybrán soubor a byl potvrzen tlačítkem OK (ne
Cancel), potom přiřaď tento název i s cestou vlastnosti FileName v komponentě s názvem MediaPlayer1
a potom tuto komponentu zaktivuj.

8. Důležité rady na závěr
 Možná se vám někdy plete, kdy použít např. název Button, kdy Button1 a kdy TButton.
  Při sázení jednotlivých komponent do formuláře počítač předpokládá, že jich umístíme na plochu více.
  Protože každá musí mít svůj jedinečný název, standardně je nazývá jejím typem a za tento název
  přiřadí číslo. Tuto vlastnost si mimo jiné můžeme najít v kolonce Name. My tedy máme 2 možnosti :
  Buď nechat tento název a pak se na něj i s číslem odvolávat nebo si komponentu pojmenovat třeba
  podle naší milenky s tím, že ji potom můžeme ohromit, kolikrát se její nádherné jméno vyskytuje v
  našem programu. Doporučuje se ale varianta 1.
  TButton je vlastně typ našeho tlačítka ButtonX. Tlačítko nám totiž necharakterizuje jeho název (ten
  může být libovolný), ale jeho typ.
 Pokud omylem kliknete na jinou událost a vytvoří se již hlavička procedury, nemažte tuto hlavičku
  pomocí tlačítka DEL, pouze ji nechte prázdnou. Tato procedura se totiž zapíše na více míst a počítač
  potom hlásí chyby. Pokud spustíme náš program s takovou prázdnou procedurou, počítač ji sám
  odstraní.
 Pokud nebudete vědět, co která vlastnost v inspektoru objektů znamená, stačí pouze na ni kliknout
  myší a stisknou tlačítko F1. Tím se zobrazí nápověda. (bohužel anglicky)

9. Neřešené programy
- Tyto programy vycházejí z již dříve řešených příkladů

1. Vytvořte program, jehož formulář bude obsahovat tlačítko Button a dva přepínače RadioButton s
   názvy Zvětši a Zmenši. Pokud je zatrženo Zvětši, tak kliknutím na toto tlačítko mu zdvojnásobíme
   výšku a naopak.
2. Vytvořte program, který bude kontrolovat naše heslo. Bude obsahovat tlačítko Button s popisem
   “Kontrola” a komponentu Edit, kam budeme heslo zapisovat. Naše heslo bude “Delphi”. Pokud
   zapíšeme heslo do rámečku a stiskneme tlačítko kontrola, vypíše se na obrazovku zpráva heslo
   souhlasí nebo heslo nesouhlasí. Typ: Pokud v komponentě Edit zapíšete do vlastnosti PasswordChar
   znak *, bude se i tento znak objevovat v Edit místo námi psanými písmeny, i když ve skutečnosti tam
   jsou.
3. Vytvořte program, jehož formulář bude obsahovat komponentu Memo a 2 tlačítka Button s názvy
   Autoexec a Config. Při stisku jednoho z nich se do komponenty Memo zobrazí výpis souboru
   autoexec.bat nebo config.sys.
4. Vytvořte dvoustránkový formulář, ve kterém se budeme přepínat pomocí záložek. Na první straně
   bude tlačítko BitBtn OK a komponenta Edit, na druhé straně pouze tlačítko Button. Při stisku tlačítka
   OK na první straně se popiskem v komponentě Edit přepíše popis tlačítka Button na druhé straně.
   Vytvořte také bublinkovou nápovědu pro tlačítko OK.
5. Vytvořte program, jehož formulář bude obsahovat pouze jedno tlačítko s názvem Zruš a komponentu
   Edit. Kliknutím na toto tlačítko komponentu Edit fyzicky zrušíme (ne pouze zneviditelníme) a hned po
   té jako reakce se vytvoří do našeho formuláře nová komponenta CheckBox, která bude 10 x 10 pixelů
   od horního levého rohu, bude obsahovat popis “Jsem nově vytvoření CheckBox” a bude zatržený.
   Protože tlačítko Button už nebude plnit žádnou funkci, bude zmrazené.
6. Vytvořte program, jehož formulář bude obsahovat 3 komponenty Shape (skupina Additional) a v
   inspektoru objektů ve vlastnosti ShapeX.Brush.Color změňte jejich barvy, aby každá z nich měla jinou
   barvu. Dále vložte další komponentu Shape do našeho fomuláře a roztáhněte ji na větší obdélník. Poté
   obohaťte náš program o funkci Drag and Drop, pomocí které “nasajeme” barvu z jednoho barevného
   čtverce a dále ní “obarvíme” obdélník.
7. Vytvořte program, jehož formulář bude obsahovat komponentu Edit a tlačítko Button s popisem
   Nastav písmo. Při kliknutí na toto tlačítko se nám zobrazí dialog s fontem, kde nastavíme různé
   vlastnosti písma. Po potvrzení tlačítka OK se změní na tento styl nápis v komponentě Edit.
8. Vytvořte program, jehož formulář bude obsahovat 1 tlačítko s popisem “Ulož jako”, 3 RadioButtonové
   přepínací tlačítka s popisy Vlevo, Vpravo a Vystředit a komponentu Memo. Text v Memo bude
   zarovnán podle zatrženého tlačítka. Při kliknutí na tlačítko “Ulož jako” se objeví ukládací dialog se
   standardní příponou ukládání *.txt a umožní nám text z komponenty Memo uložit.
9. Vytvořte program, který bude obsahovat komponentu Memo stále přes celou stranu a horní nabídku
   pouze s nabídkou Úpravy, jejíž položky budou : Přesuň do schránky, Kopíruj do schránky, Přilep ze
   schránky, Označ vše a Smaž. Výběr jedné z položek bude ovládat akci v komponentě Memo. Položky
   by měli mít horké klávesy. Vyzkoušejte také jednu zajímavou věc, že schránka našeho programu umí
   komunikovat i s jinými programy. Zkuste např. pomocí schránky vložit část textu z Memo do Wordu a
   naopak.
10.Vytvořte program, který přehraje soubory *.wav a *.avi.
te program, který přehraje soubory *.wav a *.avi.

								
To top