11. diel - Matematické funkcie a funkcie, práca s Shell, animovaná ryba

OK, je na čase pokračovať! Ak neviete v čom, pozrite sa na koniec 9.časť. Už viete? Dobre, tak ideme na to! Ak ste si nevypracovali príklad na konci deviatky, tak si ho stiahnite!

Teraz už ho máte, tak sa pusťme do vkladanie objektov: Najprv umiestnime len jeden (Button) na panel VyberNastroje, pomenujeme ho Vlozi, Caption = "Vložiť z ..." (bez "), Left = 4, Top = 72, Height = 20 a Width = 48. Vytvorte 2 premenné. Import: TBitmap; a Importujese: Boolean;

A teraz už vyplňte procedúru OnClick u vloženého tlačidlá:

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

Do procedúry OnCreate pripíšte:

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

Do procedúry PlochaMouseDown napíšte (napríklad na koniec):

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

A teraz ešte dorobíme dôležitú (ale nie príliš nutnú) vec. Do procedúry PlochaMouseMove pripíšte zase treba na koniec:

{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 vkladať obrázky. Dobré, nie?

Čo je na rade? Oboznámite vás s niekoľkými mojimi aj inými zásadami:

1. : Na čo sú hŕbu okien? Jedno bohato stačí. To, čo by ste urobili zobrazením okna možno vykonať zobrazením panelu.
2. : Pre prehľadnosť programu je dobré používať stromovú štruktúru = prvá beginovou časť úplne vľavo, pred druhou urobiť napríklad medzeru (alebo 2) a tie ďalšie opäť posunúť o rovnaký počet medzier. Proste ako som to robil ja.
3. : Robte si poznámky, až budete chcieť niečo opraviť, bude sa vám lepšie hľadať miesto, kde by chyba mohla byť.
4. : Ak vytvárate vlastnú premenné, snažte sa urobiť je čo najvýstižnejšie a najkratšie (napr. Obraz. Importujese nie je práve najlepší príklad)
5. : Tiež môžete dodržať písania veľkých písmen (ale je to jedno) na začiatku slova zložené procedúry, premenné pod. (Pr .: IntToStr = Integer To String (Integer na string). Importujese opäť nie je dobrý príklad)

Tak, to boli všeobecné rady a teraz ideme ďalej. Naučím vás pár základných výpočtov s Realom. Pre niektorých možno bude treba pripísať hore do uses Math. A tu to máte:

• DĚLENO = / Cislo
  • Krát = * Cislo
  • MINUS = - Cislo
  • Plus = + Cislo
  • Druhy mocniny = sqr (Cislo)
  • Druhy odmocniny = sqrt (Cislo)
  • XTÁ mocniny = Power (Cislo, X)
  • XTÁ odmocniny = Power (Cislo, 1 / X)
  • NEKONEČNO = Infinity
  • MINUS NEKONEČNO = NegInfinity
  • ZAOKROUHLENÍ = RoundTo (Cislo, PocetMist);
  • TANGENS = tan (Cislo)
  • SINUS = sin (Cislo)
  • COSINUS = cos (Cislo)

(Tieto funkcie fungujú iba s radiány)

• RADIÁNY NA STUPŇA = RadToDeg (Cislo)
  • STUPNĚ NA Radian = DegToRad (Cislo)

pokračovanie nabudúce

A teraz si zase pohráme s niečím iným. Najprv vám vysvetlím jednu vec, o ktorej som vám nepovedal a vďaka jednému dotazu, ktorý ma na to upozornil, vám teraz poviem, ako zistiť pozíciu skladby v MediaPlayer.
Je to jednoduché. Stačí tri položky (nie sú v Object Inspector):

• Length - Určí vám dĺžku skladby.
• Position - Určí vám, vzdialenosť práve prehrávaného úseku od začiatku skladby.
• TimeFormat - V čom sú udávané hornej položky? V tom, čo si nastavíte v TimeFormat. Jediné, čo mi fungovalo, bolo tfMilliseconds - všetko bude v milisekundách.

A tým by som prebral jednu vecičku. Teraz druhú: Dlho sme neprebrali žiadny objekt, tak tu pre vás jeden mám. Je v položke Samples tretí zľava:

SpinButton

Keď vložíte SpinEdit, tak tie 2 sipecka sú akoby SpinButton. Čo nájdete v Object Inspector (Properties):

• DownGlyph - nastavíte obrázok na dolnom tlačidle
• UpGlyph - nastavíte obrázok na hornom tlačidle

A čo máme v položke Events ?:

• OnDownClick - spustí sa po kliknutí na dolné tlačidlo
• OnUpClick - spustí sa po kliknutí na horné tlačidlo

A to je k SpinButtonu všetko!

Poďme sa teraz venovať tvoreniu vlastných procedúr a pod ... Áno, už to viete, ale nie úplne! Čo treba urobiť procedúru, do ktorej zadáte číslo a ona vám ho zvýši o 10 a výsledok napíše ako Caption pri okne Okno? OK. Sú 2 možnosti. Jednu už viete:

Vytvoríte si premennú treba Cislo: Integer; a potom vložíte procedúru. Ako jej vložiť síce už viete, ale nie so všetkými možnosťami. Ak procedúru nechcete predpísať nad private, môžete potom napísať iba napr. Procedure PridejDeset; Nesmiete však napísať procedure TOkno.PridejDeset ;. V opačnom prípade naopak musíte. Aký je v týchto dvoch prípadoch rozdiel? Ak procedúru predpíšete pre (v našom prípade) TOkno, budú ostatné okná programu túto procedúru tiež použiť. Inak nie. (Všimnite si, že keď vytvoríte odkaz na iné okno (Okno2.Show;) a program chcete spustiť, spýta sa vás či chcete do Okná pridať informácie o Okno2. Čiže či do uses pas súboru Unit1 chcete pridať Unit2. A keď kliknete na Yes , naozaj v programe pribudne 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 čo ten druhý spôsob? Ten sa zaobíde bez vytvorenia premenné Cislo. Túto napíšeme potrebné pre všetky okná (teda nad private). Napíš procedure PridejDeset (Cislo: Integer); OK, to nepoznáte, že? Práve sme predpísali procedúru, ktorú keď budeme chcieť použiť, musíme zadať aj informáciu v zátvorke. Napr .: PridejDeset (15); V tom prípade bude lokálne (pre našej procedúru) premenná Cislo mať hodnotu 15. A túto premennú môžeme kdekoľvek v procedúre PridejDeset použiť. Takže aké to bude v našom prípade ?:

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

Aký je v tom rozdiel? To druhé zaberá menej miesta v operačnej pamäti. Teraz už len kdekoľvek napíšete:

Cislo := 8;
PridejDeset;

v prvom prípade a

PridejDeset(8);

v druhom. Takže aj pár riadkov si ušetríte

Teraz mi dovoľte, aby som vám vysvetlil, čo je FUNKCIE. Nie tá matematická, ale v Delphi: Rozdiel medzi funkciou a procedúrou je nasledujúci. Procedúra môže dostať údaje, s ktorými pracuje a niečo vykoná. Funkcia dostane údaje, ale na rozdiel od procedúry vráti výsledok. Čiže je to vlastne niečo medzi premennou a procedúrou. Najlepšie bude ukázať to na príklade: Opäť chceme ľubovoľné číslo zvýšiť o 10. Procedúru už máme (TOkno.PridejDeset (Cislo: Integer)) a tak už len funkciu. Tá neurobí priamo to, čo sme zadali. Tá nám iba vráti výsledok. Funkcia si opäť môžete a nemusíte nadpísať (s rovnakými podmienkami). My si ju teraz napíš (predpíšeme):

function ZvyseniODeset(Cislo : Integer) : Integer;

Pozeráte, čo? Vysvetlím to. Funkcia sa volá ZvyseniODeset (nemôže sa volať rovnako ako druhá procedúra). Cislo je Integer, ktorý budeme zadávať a ktorý sa zvýši o 10. A to na konci nám hovorí, akého typu bude vrátená premenná z funkcie. Teraz funkciu vyplníme:

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

Opäť tápate? No, ZvyseniODeset je tá vrátená premenná (je vždy taká, aký je názov funkcie. Alebo môžete namiesto názvu funkcie použiť premennú result, výsledok je rovnaký) a Cislo musíte zadať tam, kde funkciu použijete. Samozrejme si môžete pre funkciu vytvoriť ďalšie lokálne premenné. Rovnako ako u procedúry:

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

Tu je to zrovna na nič, ale vidíte, ako na to! A ako funkciu použiť? Môžete ju použiť rovnako, ako procedúru:

ZvyseniODeset(8);

Ale takto napísaná by bola na nič a navyše by bolo zbytočné použiť funkciu. A my jej využiť chceme:

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

A je to. Zvýšenie o desať je vlastne Integer. Ešte chvíľku si s funkciou a procedúrou pohráme, nie?

Zadania

Vypočítať obsah pravouhlého trojuholníka.

Řešení1 - Pomocou funkcie

Pre zjednodušenie si teraz nebudeme funkciu predpisovať. Takže kamkoľvek (medzi begin a end.) Do programu (nie dovnútra procedúry ani funkcie, ale to snáď viete) píš:

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

Teraz len niekam napíšeme napr .:

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

A máte obsah trojuholník s odvesnami 15 a 8 vypísaný v Labelu1.

Řešení2 - pomocou procedúry

Pre zjednodušenie si opäť nebudeme tentokrát procedúru predpisovať. Ak tvrdíte, že je to úplne niečo iné, nemáte pravdu. My totiž donútime, aby nám procedúra vrátila (nepriamo) číslo. Ukončime reči pusťme sa do písania (opäť "kamkoľvek"):

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

Ako to funguje? V zátvorke máme zadanej najprv zadávané premenné. Ak chceme aj výstupný premenné (tie čo sa vypočítajú), oddelíme je od prvých bodkočiarkou (;) a napíšeme pred nich var. A dokonca to má výhodu oproti funkciu. Akú? Môžeme mať viac výsledkov (napríklad obvod i obsah). Ako ale túto procedúru použiť? Musíme mať samozrejme premennú, do ktorej sa dosadí výsledok. Takže si niekam (buď do procedúry, kde ObsahPrTr použijeme, alebo na začiatok k ostatným premenným) napíš napr .: Obsah: real; Ale real to musí byť! Musia byť rovnakého typu, ako tá v procedúre, to je snáď jasné! A potom už len napíšete:

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

V tom je zase nevýhoda. Zápis bude vždy minimálne na dva riadky. Tak a to, si myslím, by už s premennými, procedúrami a funkciami stačilo!

ShellTreeView

Keď už sme tentoraz raz zavítali do Samples, prečo si neukázať ešte viac položiek? Štvrtý sprava by mal byť ShellTreeView. Proste stromové zobrazenie priečinkov na vašom PC. V Properties v Object Inspector toho má celkom dosť:

• AutoContextMenu - nastavíte, či Delphi smie automaticky priradiť menu vyvolané kliknutím pravým tlačidlom myši
• AutoRefresh - je dobré ho nastaviť na TRUE. Strom sa vám potom bude automaticky Aktualizovať.
• ChangeDelay - počet milisekúnd (tisícin sekundy), ktorý uplynie medzi zmenenými a doplnenými adresy a spustením procedúry OnChange
• Color - farba pozadia
• Indent - horizontálna vzdialenosť medzi vetvami stromu
• ObjectTypes - nastavíte, čo sa v strome zobrazí otFolders = zložky

  otNonFolders = súbory

  otHidden = skryté zložky a súbory

• otFolders = zložky
• otNonFolders = súbory
• otHidden = skryté zložky a súbory
• Root - od ktorého miesta v PC bude strom začínať
• ShowButtons - TRUE - zobrazí sa pluska a mínusu na rozbalenie a zabalené adresára. FALSE - nezobrazí
• ShowLines - zobrazí sa spojové čiary?
• ShowRoot - zobrazí sa čiara ik začiatku stromu?
• UseShellImages - nastavíte, či sa majú zobrazovať Windowsovské malé ikonky u adresár (a súborov)

A ako zistíte výsledný adresár (adresu)? Položkou Path, ktorá nie je v menu. Pr .: MediaPlayer1.Fi­leName: = ShellTreeWiev1­.Path;

ShellComboBox

A čo máme v Samples ďalej? Pozrite sa napravo od ShellTreeWiev a nájdete ShellComboBox.

Otvorte si nejakú zložku. A ShellComboBox je rámček hore, ktorý vám hovorí, kde sa nachádzate. V Properties v Object Inspector má skoro rovnaké veci, ako ShellTreeWiev, takže vám poviem ešte o jednom objekte.

ShellListView

Otvorte si nejakú zložku. A ShellListWiev je to biele, čo vidíte dole a čo obsahuje všetky ikony. A ShellListWiev už má pár vecí v OI navyše:

• AllocBy - Dobre radím: Nemanipulujte s tým! Zmeníte číslo a počet ikoniek sa obmedzí na ono číslo. Ale keď vrátite pôvodnú 0, nebude sa zobrazovať nič : D
• ChangeDelay - počet milisekúnd (tisícin sekundy), ktorý uplynie medzi zmenenými a doplnenými adresy a spustením procedúry OnChange
• Color - tu je jedine vhodné meniť farbu. Fungujú tu priehľadné ikony aj písmo, na rozdiel od predošlých 2 objektov.
• Gridlines - nastavíte, či sa majú zobrazovať čiary tabuľky pri zobrazení detailov
• IconOptions - nastavenie ikon Arrangement = iaTop-vyplní sa ako otvorená zložka, iaLeft-vyplní sa ako plocha

  WrapText = majú sa zalamovať riadky dlhých názvov súborov?

• Arrangement = iaTop-vyplní sa ako otvorená zložka, iaLeft-vyplní sa ako plocha
• WrapText = majú sa zalamovať riadky dlhých názvov súborov?
• Multiselect - možné vybrať viac ako 1 súbor?
• Sorted - TRUE- budú zložky pri sebe a súbory tiež. FALSE- zoradia sa podľa názvu ( "zložka nesložka")
• WievStyle - čiže zobrazenia (ako vo windows) vsIcon = veľké ikony

  vsList = zoznam

  vsReport = podrobnosti

  vsSmallIcon = malé ikony

• vsIcon = veľké ikony
• vsList = zoznam
• vsReport = podrobnosti
• vsSmallIcon = malé ikony

A teraz ešte 3 veci, z ktorých sú vždy 2 u každého z troch objektov:

• ShellComboBox - priraďte SCB, ktoré sa bude meniť súčasne sa zvoleným objektom
• ShellTreeWiev - priraďte STW, ktoré sa bude meniť súčasne so zvoleným objektom
• ShellListWiev - priraďte SLW, ktoré sa bude meniť súčasne so zvoleným objektom

Takže vložíte potrebné ShellComboBox a ShellListWiew, prepojíte je a máte vlastne neúplné okno na prezeranie zložiek ...

Program

Je čas na príklad. Ukážem vám, ako sa dá krásne vyrobiť animovaná rybka. Bude čiernobiela, bude hýbať plutvami, pôjde meniť jej pozície v okne, jej veľkosť a bohužiaľ nebude príliš úsporne napísaná - to však nevadí. Hlavne že funguje. Niektoré časti programu pôjde nahradiť inými príkazy, ale to už nechám na vás. Napr. Alpha: = (Alfa * pi) / 180; je rovnaké, ako Alpha: = DegToRad (Alfa) ;, ale vtedy som ten príkaz ešte naznal. Jo, aj ja sa pri tvorbe návodu učím

Tak sa pusťme do vkladanie objektov: niečím budeme musieť meniť veľkosť. K tomu poslúži SpinEdit, nazvný ErSet a umiestnený kdekoľvek. MINVALUE tak nastavte na 12 a maxvalue treba na 600, väčšiu rybu by robiť nemalo zmysel! Ak máte väčšie rozlíšenie, lidnatý si maxvalue zväčšite. A Value pre začiatok nastavte potrebné na 60. Urobíme ešte tlačidlo na potvrdenie hodnoty (išlo by použiť procedúru OnChange u SpinEditu, ale pomiatla by sa, keby ste zmazali hodnotu a chceli jej prepísať inú). Button sa bude volať OK, Caption bude rovnaký a ostatné je opäť na vás. Na polohu rybky bude stačiť kliknutie na okno, ktoré som pomenoval Okno, takže nie je potrebný žiadny objekt. Posledné, čo vložíme bude Timer zvaný Time s intervalom 66, ktorý bude zabezpečovať pohyb plutiev.

A tu máte zdrojový tex (súboru 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čne možno rybku presúvať. Kliknite a poloha stredu rybieho tela sa
zmení na miesto, kam ste klikli. Opäť Invalidate a program je hotový! A
zdroj si môžete aj o kúsok nižšie stiahnuť. (OK, tí, čo
sa nevyznali v rovniciach z toho asi moc nemajú, ale čo narobiť? na niečom
som počítanie ukázať musel
A čo teraz? (Žiadna Deli) Vyrobte nejaký program ...

 

Mal si s čímkoľvek problém? Stiahni si vzorovú aplikáciu nižšie a porovnaj ju so svojím projektom, chybu tak ľahko nájdeš.