Lekce 11 - Matematické funkce a funkce, práce s Shell, animovaná ryba

OK, je na čase pokračovat! Pokud nevíte v čem, koukněte se na konec 9.části. Už víte? Dobře, tak jdeme na to! Pokud jste si nevypracovali příklad na konci devítky, tak si ho stáhněte!

Teď už ho máte, tak se pusťme do vkládání objektů: Nejprve umístíme pouze jeden (Button) na panel VyberNastroje, pojmenujeme ho Vlozit, Caption="Vložit z..." (bez "), Left=4, Top= 72, Height=20 a Width=48. Vytvořte 2 proměnné. Import: TBitmap; a Importujese : Boolean;

A teď už vyplňte proceduru OnClick u vloženého tlačítka:

{Vložení obrázku}
 if Open.Execute then
 begin
   Import.LoadFromFile(Open.FileName);
   Importujese := True;
 end;

Do procedury OnCreate připište:

{Nastavení TBitmap Import:}
 Import := TBitmap.Create;
 Importujese := False;

Do procedury PlochaMouseDown napište (třeba na konec):

{Vložení obrázku:}
 if Importujese then
 begin
   Obraz.Canvas.Draw(X,Y,Import);
   Plocha.Canvas.Draw(X,Y,Import);
   Importujese := False;
 end;

A teď ještě doděláme důležitou (ale ne příliš nutnou) věc. Do procedury PlochaMouseMove připište zase třeba na konec:

{Zobrazení velikosti Importu:}
 if Importujese then
 begin
   Plocha.Canvas.Draw(0,0,Obraz);
   Plocha.Canvas.Rectangle(X, Y, X + Import.Width, Y+ Import.Height);
 end;

A můžete vkládat obrázky. Dobré, ne?

Co je na řadě? Obeznámím vás s několika mými i jinými zásadami:

1. : K čemu jsou spousty oken? Jedno bohatě stačí. To, co byste udělali zobrazením okna lze provést zobrazením panelu.
2. : Pro přehlednost programu je dobré používat stromovou strukturu = první beginovou část úplně vlevo, před druhou udělat třeba mezeru (nebo 2) a ty další opět posunout o stejný počet mezer. Prostě jako jsem to dělal já.
3. : Dělejte si poznámky, až budete chtít něco opravit, bude se vám lépe hledat místo, kde by chyba mohla být.
4. : Pokud vytváříte vlastní proměnné, snažte se udělat je co nejvýstižnější a nejkratší (např. Obraz. Importujese není zrovna nejlepší příklad)
5. : Také můžete dodržet psaní velikých písmen (ale je to jedno) na začátku slova složené procedury, proměnné apod. (Př.: IntToStr=Integer To String (Integer na string). Importujese opět není dobrý příklad)

Tak, to byly všeobecné rady a teď jedeme dál. Naučím vás pár základních výpočtů s REALem. Pro některé možná bude třeba připsat nahoru do uses Math. A tady to máte:

-DĚLENO = / Cislo
-KRÁT = * Cislo
-MINUS = - Cislo
-PLUS = + Cislo
-DRUHÁ MOCNINA = sqr(Cislo)
-DRUHÁ ODMOCNINA = sqrt(Cislo)
-XTÁ MOCNINA = Power(Cislo, X)
-XTÁ ODMOCNINA = Power(Cislo, 1/X)
-NEKONEČNO = Infinity
-MINUS NEKONEČNO = NegInfinity
-ZAOKROUHLENÍ = RoundTo(Cislo, PocetMist);
-TANGENS = tan(Cislo)
-SINUS = sin(Cislo)
-COSINUS = cos(Cislo)

(tyto funkce fungují pouze s radiány)

-RADIÁNY NA STUPNĚ = RadToDeg(Cislo)
-STUPNĚ NA RADIÁNY = DegToRad(Cislo)

Pokračování příště

A teď si zase pohrajeme s něčím jiným. Nejprve vám vysvětlím jednu věc, o které jsem vám neřekl a díky jednomu dotazu, který mne na to upozornil, vám nyní řeknu, jak zjistit pozici skladby v MediaPlayeru.
Je to jednoduché. Stačí tři položky (nejsou v Object Inspectoru):

• Length - Určí vám délku skladby.
• Position - Určí vám, vzdálenost právě přehrávaného úseku od začátku skladby.
• TimeFormat - V čem jsou udávány horní položky? V tom, co si nastavíte v TimeFormat. Jediné, co mi fungovalo, bylo tfMilliseconds - vše bude v milisekundách.

A tím bych probral jednu věcičku. Teď druhou: Dlouho jsme neprobrali žádný objekt, tak tu pro vás jeden mám. Je v položce Samples třetí zleva:

SpinButton

Když vložíte SpinEdit, tak ty 2 šipečky jsou jakoby SpinButton. Co naleznete v Object Inspectoru (Properties):

• DownGlyph - nastavíte obrázek na dolním tlačítku
• UpGlyph - nastavíte obrázek na horním tlačítku

A co máme v položce Events?:

• OnDownClick - spustí se po kliknutí na dolní tlačítko
• OnUpClick - spustí se po kliknutí na horní tlačítko

A to je k SpinButtonu vše!

Pojďme se teď věnovat tvoření vlastních procedur apod... Ano, už to umíte, ale ne úplně! Co třeba udělat proceduru, do které zadáte číslo a ona vám ho zvýší o 10 a výsledek napíše jako Caption u okna Okno? OK. Jsou 2 možnosti. Jednu už umíte:

Vytvoříte si proměnnou třeba Cislo: Integer; a poté vložíte proceduru. Jak jí vložit sice už víte, ale ne se všemi možnostmi. Pokud proceduru nechcete předepsat nad private, můžete potom napsat pouze např. procedure PridejDeset; Nesmíte však napsat procedure TOkno.PridejDeset;. V opačném případě naopak musíte. Jaký je v těchto dvou případech rozdíl? Pokud proceduru předepíšete pro (v našem případě) TOkno, budou ostatní okna programu tuto proceduru také použít. Jinak ne. (Všimněte si, že když vytvoříte odkaz na jiné okno (Okno2.Show;) a program chcete spustit, zeptá se vás zda chcete do Okna přidat informace o Okno2. Neboli jestli do uses pas souboru Unit1 chcete přidat Unit2. A když kliknete na Yes, opravdu v programu přibyde uses

Unit2:
implementation
uses Unit2;
{$R *.dfm}
No ale zpět k proceduře PridejDeset. Dejme tomu, že ji napíšete pouze
pro Okno:
procedure PridejDeset;
begin
  Cislo := Cislo*10;
  Okno.Caption := IntToStr(Cislo);
end;

A co ten druhý způsob? Ten se obejde bez vytvoření proměnné Cislo. Tuto napíšeme třeba pro všechna okna (tedy nad private). Nadepíšeme si procedure PridejDeset(Cislo : Integer); OK, to neznáte, že? Právě jsme předepsali proceduru, kterou když budeme chtít použít, musíme zadat i informaci v závorce. Např.: PridejDeset(15); V tom případě bude lokální (pro naší proceduru) proměnná Cislo mít hodnotu 15. A tuto proměnnou můžeme kdekoli v proceduře PridejDeset použít. Takže jaké to bude v našem případě?:

procedure TOkno.PridejDeset(Cislo : Integer);
begin
  Cislo := Cislo*10;
  Okno.Caption := IntToStr(Cislo);
end;

Jaký je v tom rozdíl? To druhé zabírá méně místa v operační paměti. Teď už jen kdekoli napíšete:

Cislo := 8;
PridejDeset;

v prvním případě a

PridejDeset(8);

v druhém. Takže i pár řádků si ušetříte

Teď mi dovolte, abych vám vysvětlil, co je FUNKCE. Ne ta matematická, ale v Delphi: Rozdíl mezi funkcí a procedurou je následující. Procedura může dostat údaje, s kterými pracuje a něco provede. Funkce dostane údaje, ale na rozdíl od procedury vrátí výsledek. Neboli je to vlastně něco mezi proměnnou a procedurou. Nejlepší bude ukázat to na příkladu: Opět chceme libovolné číslo zvýšit o 10. Proceduru už máme (TOkno.Pridej­Deset(Cislo : Integer)) a tak už jen funkci. Ta neudělá přímo to, co jsme zadali. Ta nám pouze vrátí výsledek. Funkce si opět můžete a nemusíte nadepsat (se stejnými podmínkami). My si jí nyní nadepíšeme (předepíšeme):

function ZvyseniODeset(Cislo : Integer) : Integer;

Koukáte, co? Vysvětlím to. Funkce se jmenuje ZvyseniODeset(ne­může se jmenovat stejně jako druhá procedura). Cislo je Integer, který budeme zadávat a který se zvýší o 10. A to na konci nám říká, jakého typu bude vrácená proměnná z funkce. Nyní funkci vyplníme:

function TOkno.ZvyseniODeset(Cislo : Integer) :
Integer;
begin
  ZvyseniODeset := Cislo + 10;
end;

Opět tápete? No, ZvyseniODeset je ta vrácená proměnná (je vždy taková, jaký je název funkce. Nebo můžete místo názvu funkce použít proměnnou result, výsledek je stejný) a Cislo musíte zadat tam, kde funkci použijete. Samozřejmě si můžete pro funkci vytvořit další lokální proměnné. Stejně jako u procedury:

function TOkno.ZvyseniODeset(Cislo : Integer) :
Integer;
var
  Vysledek : Integer;
begin
  Vysledek := Cislo + 10;
  ZvyseniODeset := Vysledek;
end;

Tady je to zrovna na nic, ale vidíte, jak na to! A jak funkci použít? Můžete ji použít stejně, jako proceduru:

ZvyseniODeset(8);

Ale takto napsaná by byla na nic a navíc by bylo zbytečné použít funkci. A my jí využít chceme:

Okno.Caption := IntToStr(ZvyseniODeset(8));

A je to. Zvyseni o deset je vlastně Integer. Ještě chvilku si s funkcí a procedurou pohrajeme, ne?

Zadání

Vypočítat obsah pravoúhlého trojúhelníku.

Řešení1 - Pomocí funkce

Pro zjednodušení si teď nebudeme funkci předepisovat. Takže kamkoli (mezi begin a end.) do programu (ne dovnitř procedury ani funkce, ale to snad víte) pište:

function ObsahPT(a : real, b :real) : real;
begin
  ObsahPT := a*b/2;
end;

Teď jenom někam napíšeme příkaz např.:

Label1.Caption := FloatToStr(ObsahPT(15, 8));

A máte obsah troúhelníka s odvěsnami 15 a 8 vypsaný v Labelu1.

Řešení2 - pomocí procedury

Pro zjednodušení si opět nebudeme tentokrát proceduru předepisovat. Jestli tvrdíte, že je to úplně něco jiného, nemáte pravdu. My totiž donutíme, aby nám procedura vrátila (nepřímo) číslo. Ukončeme řeči pusťme se do psaní (opět "kamkoli"):

procedure ObsahPrTr(a : real, b : real; var S : real);
begin
  S := a*b/2;
end;

Jak to funguje? V závorce máme zadané nejprve zadávané proměnné. Pokud chceme i výstupní proměnné (ty co se vypočítají), oddělíme je od prvních středníkem (;) a napíšeme před ně var. A dokonce to má výhodu oproti funkci. Jakou? Můžeme mít víc výsledků (třeba obvod i obsah). Jak ale tuto proceduru použít? Musíme mít samozřejmě proměnnou, do které se dosadí výsledek. Takže si někam (buď do procedury, kde ObsahPrTr použijeme, nebo na začátek k ostatním proměnným) nadepíšeme např.: Obsah : real; Ale real to musí být! Musí být stejného typu, jako ta v proceduře, to je snad jasné! A pak už jenom napíšete:

ObsahPrTr(15, 8, Obsah);
Label1.Caption := FloatToStr(Obsah);

V tom je zase nevýhoda. Zápis bude vždy minimálně na dva řádky. Tak a to, si myslím, by už s proměnnými, procedurami a funkcemi stačilo!

ShellTreeView

Když už jsme tentokrát jednou zavítali do Samples, proč si neukázat ještě víc položek? Čtvrtý zprava by měl být ShellTreeView. Prostě stromové zobrazení složek na vašem PC. V Properties v Object Inspectoru toho má celkem dost:

• AutoContextMenu - nastavíte, zda Delphi smí automaticky přiřadit menu vyvolané kliknutím pravým tlačítkem myši
• AutoRefresh - je dobré ho nastavit na TRUE. Strom se vám pak bude automaticky Aktualizovat.
• ChangeDelay - počet milisekund (tisícin sekundy), který uběhne mezi změněním adresy a spuštěním procedury OnChange
• Color - barva pozadí
• Indent - vodorovná vzdálenost mezi větvemi stromu
• ObjectTypes - nastavíte, co se ve stromu zobrazí
  • otFolders = složky
  • otNonFolders = soubory
  • otHidden = skryté složky a soubory
• Root - od kterého místa v PC bude strom začínat
• ShowButtons - TRUE - zobrazí se pluska a mínuska na rozbalení a zabalené adresáře. FALSE - nezobrazí
• ShowLines - zobrazí se spojové čáry?
• ShowRoot - zobrazí se čára i k začátku stromu?
• UseShellImages - nastavíte, zda se mají zobrazovat Windowsovské malé ikonky u adresářu(a souborů)

A jak zjistíte výsledný adresář (adresu)? Položkou Path, která není v menu. Př.: MediaPlayer1.Fi­leName := ShellTreeWiev1­.Path;

ShellComboBox

A co máme v Samples dále? Podívejte se napravo od ShellTreeWiev a najdete ShellComboBox.

Otevřete si nějakou složku. A ShellComboBox je rámeček nahoře, který vám říká, kde se nacházíte. V Properties v Object Inspectoru má skoro stejné věci, jako ShellTreeWiev, takže vám řeknu ještě o jednom objektu.

ShellListView

Otevřete si nějakou složku. A ShellListWiev je to bílé, co vidíte dole a co obsahuje všechny ikony. A ShellListWiev už má pár věcí v O.I. navíc:

• AllocBy - Dobře radím: Nemanipulujte s tím! Změníte číslo a počet ikonek se omezí na ono číslo. Ale když vrátíte původní 0, nebude se zobrazovat nic
• ChangeDelay - počet milisekund (tisícin sekundy), který uběhne mezi změněním adresy a spuštěním procedury OnChange
• Color - tady je jedině vhodné měnit barvu. Fungují zde průhledné ikony i písmo, na rozdíl od předešlých 2 objektů.
• GridLines - nastavíte, zda se mají zobrazovat čáry tabulky při zobrazení detailů
• IconOptions - nastavení ikon
  • Arrangement = iaTop-vyplní se jako otevřená složka , iaLeft-vyplní se jako Plocha
  • WrapText = mají se zalamovat řádky dlouhých názvů souborů?
• MultiSelect - lze vybrat více než 1 soubor?
• Sorted - TRUE- budou složky u sebe a soubory také. FALSE- seřadí se podle názvu ("složka nesložka")
• WievStyle - neboli zobrazení (jako ve windows)
  • vsIcon = velké ikony
  • vsList = seznam
  • vsReport = podrobnosti
  • vsSmallIcon = malé ikony

A teď ještě 3 věci, ze kterých jsou vždy 2 u každého ze tří objektů:

• ShellComboBox - přiřaďte S.C.B., které se bude měnit současněse zvoleným objektem
• ShellTreeWiev - přiřaďte S.T.W., které se bude měnit současně se zvoleným objektem
• ShellListWiev - přiřaďte S.L.W., které se bude měnit současně se zvoleným objektem

Takže vložíte třeba ShellComboBox a ShellListWiew, propojíte je a máte vlastně neúplné okno na prohlížení složek...

Program

Je čas na příklad. Ukážu vám, jak se dá krásně vyrobit animovaná rybka. Bude černobílá, bude hýbat ploutvemi, půjde měnit její pozice v okně, její velikost a bohužel nebude příliš úsporně napsaná - to však nevadí. Hlavně že funguje. Některé části programu půjde nahradit jinými příkazy, ale to už nechám na vás. Např. Alpha := (Alfa*pi)/180; je stejné, jako Alpha := DegToRad(Alfa);, ale tenkrát jsem ten příkaz ještě naznal. Jo, i já se při tvorbě návodu učím

Tak se pusťme do vkládání objektů: Nečím budeme muset měnit velikost. K tomu poslouží SpinEdit, nazvný ErSet a umístěný kdekoli. MinValue nastavte na 12 a MaxValue třeba na 600, větší rybu by dělat nemělo smysl! Máte-li větší rozlišení, lidně si MaxValue zvětšte. A Value pro začátek nastavte třeba na 60. Uděláme ještě tlačítko na potvrzení hodnoty (šlo by použít proceduru OnChange u SpinEditu, ale pomátla by se, kdybyste smazali hodnotu a chtěli jí přepsat jinou). Button se bude jmenovat OK, Caption bude stejný a ostatní je opět na vás. Na polohu rybky bude stačit kliknutí na okno, které jsem pojmenoval Okno, takže není třeba žádný objekt. Poslední, co vložíme bude Timer zvaný Time s Intervalem 66, který bude zajišťovat pohyb ploutví.

A zde máte zdrojový tex (souboru Okno_f.pas):

    unit Okno_f;
    interface
    uses
      Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
    Dialogs, StdCtrls, Spin, ExtCtrls;
    type
      TOkno = class(TForm)
        ErSet: TSpinEdit;
        Time: TTimer;
        OK: TButton;
         procedure FormPaint(Sender: TObject);
        procedure TimeTimer(Sender: TObject);
        procedure FormCreate(Sender: TObject);
        procedure OKClick(Sender: TObject);
        procedure FormMouseDown(Sender: TObject; Button:
    TMouseButton; Shift: TShiftState; X, Y: Integer);

//Zde jste si mohli všimnout procedur, které použijeme a objektů, které jsem vám už napsal.

      private
        { Private declarations }
      public
        { Public declarations }
           Sx, Sy, r, Alfa, Hxm, Dxm, Pxm,
        Hy, Dy, Py, Hxp, Dxp, Pxp : real;
        minus : Boolean;
      end;

// To bylo několik realů, které budeme potřebovat a jeden Boolean.

    var
      Okno: TOkno;


    // A můžeme pokročit k samotným procedurám.


    implementation
    {$R *.dfm}
    procedure TOkno.FormPaint(Sender: TObject);
    var
      s, b, h, v, f, e, Vx, Vy, Ux, Uy, Lx, Rx, Ly, Ry, Oxm, Oxp, Oy : real;
    begin
      Vx := Sx;
      Ux := Sx;
      Vy := Sy - 11*r/6;
      Uy := Sy + r/2;
      Lx := Sx - r/10;
      Rx := Sx + r/10;
      Ly := Sy - r*sqrt(99/100);
      Ry := Ly;
      Oxm := Sx - 2*r/5;
      Oxp := Sx + 2*r/5;
      Oy := Sy - r/3;
      s := r/8;
      b := r/4;
      h := 2*r/6;
      v := r/4;
      f := r/6;

// Zde jsme dopočítali nové lokální proměnné (realy).

      Canvas.Pen.Width := Round(sqrt(sqr((r-50)/50)));
      Canvas.Brush.Style := bsClear;
      Canvas.Ellipse(Round(Sx - r), Round(Sy - r), Round(Sx + r), Round(Sy + r));
      Canvas.Ellipse(Round(Ux - h), Round(Uy - v), Round(Ux + h), Round(Uy + v));
      Canvas.Ellipse(Round(Ux - h), Round(Uy - f), Round(Ux + h), Round(Uy + f));

// Teď jsme upravili barvy a nakreslili tělo ryby (S) a ústa (U).

      Canvas.MoveTo(Round(Lx), Round(Ly));
      Canvas.LineTo(Round(Vx), Round(Vy));
      Canvas.LineTo(Round(Rx), Round(Ry));

// To byla horní ploutev.

      Canvas.Brush.Style := bsSolid;
      Canvas.Brush.Color := clWhite;
      Canvas.Ellipse(Round(Oxm - b), Round(Oy - b), Round(Oxm + b), Round(Oy + b));
      Canvas.Ellipse(Round(Oxp - b), Round(Oy - b), Round(Oxp + b), Round(Oy + b));
    //Bělma očí...
      Canvas.Brush.Color := clBlack;
      Canvas.Ellipse(Round(Oxm - s), Round(Oy - s), Round(Oxm + s), Round(Oy + s));
      Canvas.Ellipse(Round(Oxp - s), Round(Oy - s), Round(Oxp + s), Round(Oy + s));
      Canvas.Brush.Style := bsClear;
    end;
  //  ...A panenky! Tím jsme dodělali hlavní kostru ryby. Teď už jenom ploutve. A to bude horší!

  procedure TOkno.TimeTimer(Sender: TObject);
    var
      e, Alpha : real;
    begin
      if minus then
      Alfa := Alfa - 2 else
      Alfa := Alfa + 2;
      e := 2*r/3;
      if Alfa > 89 then
      minus := True else
      if Alfa < 1 then
      minus := False;
   // Takže Alfa je úhel ve stupních, ke kterému přidáme, nebo ubereme (to pokud je minus True) dvojku.
      Canvas.Pen.Color := Okno.Color;
      Canvas.MoveTo(Round(Hxm), Round(Hy));
      Canvas.LineTo(Round(Pxm), Round(Py));
      Canvas.LineTo(Round(Dxm), Round(Dy));
      Canvas.MoveTo(Round(Hxp), Round(Hy));
      Canvas.LineTo(Round(Pxp), Round(Py));
      Canvas.LineTo(Round(Dxp), Round(Dy));
  //  Nastavili jsme barvu na barvu okna a překreslili předchozí ploutve.
      Alpha := (Alfa*pi)/180;
   // To byl onen zběsilý převod na radiány a teď výpočet:
      Hxm := Sx - r*sqrt(3/4);
      Dxm := Sx - r*sqrt(5/9);
      Pxm := Sx - r*sqrt(95/144) - e*cos(Alpha);
      Hxp := Sx + r*sqrt(3/4);
      Dxp := Sx + r*sqrt(5/9);
      Pxp := Sx + r*sqrt(95/144) + e*cos(Alpha);
      Hy := Sy + r/2;
      Dy := Sy + 2*r/3;
      Py := Sy + 7*r/12 + sin(Alpha)*e;
 //   Nyní známe polohy ploutví a můžeme je nakreslit:
      Canvas.Pen.Color := clBlack;
      Canvas.MoveTo(Round(Hxm), Round(Hy));
      Canvas.LineTo(Round(Pxm), Round(Py));
      Canvas.LineTo(Round(Dxm), Round(Dy));
      Canvas.MoveTo(Round(Hxp), Round(Hy));
      Canvas.LineTo(Round(Pxp), Round(Py));
      Canvas.LineTo(Round(Dxp), Round(Dy));
    end;
 //   Ryba je skoro hotová. Jen jsme ještě nikde nezadali nějaké údaje.
 //   Spustíte-li teď program, nebude fungovat tak, jak má...
    procedure TOkno.FormCreate(Sender: TObject);
    var
      e : real;
    begin
      Sy := 120;
      Sx := 120;
      r := 60;
      e := 40;
      Alfa := 46;
      Hxm := Sx - r*sqrt(3/4);
      Dxm := Sx - r*sqrt(5/9);
      Pxm := Sx - r*sqrt(95/144) - cos(Alfa)*e;
      Hxp := Sx + r*sqrt(3/4);
      Dxp := Sx + r*sqrt(5/9);
      Pxp := Sx + r*sqrt(95/144) + cos(Alfa)*e;
      Hy := Sy + r/2;
      Dy := Sy + 2*r/3;
      Py := Sy + 7*r/12 + sin(Alfa)*e;
      minus := False;
    end;
//    Konečně jsme dosadili dostatek údajů. Teď už ryba bude fungovat, ale
  //  nepůjde přesouvat a zvětšovat.
    procedure TOkno.OKClick(Sender: TObject);
    begin
      r := ErSet.Value;
      Invalidate;
    end;
  //  Změněním poloměru (r) rybího těla se změní i ostatní parametry.
  //  Invalidate spustí proceduru FormPaint.
    procedure TOkno.FormMouseDown(Sender: TObject; Button:
    TMouseButton; Shift: TShiftState; X, Y: Integer);
    begin
      Sx := X;
      Sy := Y;
      Invalidate;
    end;
    end.

Konečně lze rybku přesouvat. Klikněte a poloha středu rybího těla se
změní na místo, kam jste kliknuli. Opět Invalidate a program je hotov! A
zdroj si můžete i o kousek níže stáhnout. (OK, ti, co
se nevyznali v rovnicích z toho asi moc nemají, ale co nadělat? Na něčem
jsem počítání ukázat musel
A co teď? (žádná Deli) Vyrobte nějaký program ...

 

Měl jsi s čímkoli problém? Stáhni si vzorovou aplikaci níže a porovnej ji se svým projektem, chybu tak snadno najdeš.