3.2//EN"> Úvod

Takže vás vítám u čtvrtého dílu našeho-vašeho seriálu o programování v PowerD. Tentokrát zabředneme do tajů struktur, nejdůležitějšího rysu pokročilých programovacích jazyků, pak si řekneme něco o konstantách a jejich definicích a také se konečně naučíme, jak si otevřít okno a to na vlastní obrazovce, prostě samé jednoduché věci, jako vždy. A aby toho nebylo málo, ještě si do toho okénka něco napíšeme a nakreslíme, to jen aby nebyla nuda. A ještě tady mám jednu důležitou věc. Našel jsem konečně adresu, ze které je možné si stáhnout autodocy, což je kompletní dokumentace ke všem systémovým knihovnám a mnoho dalších více-néně užitečných vecí: http://www.amiga.com/3.9/download/NDK3.9.lha.

Struktury

Takže, jak začít... Každý, kdo někdy programoval něco složitějšího se zajisté dostal do problémů s počtem proměnných, prostě jich bylo tolik, že jste se v tom přestávali orientovat, no a struktury... ty to dělají ještě složitější... Nééé, dělám si srandu! Ono to teda je složitější, než obyčejné proměnné, ale zase to spoustu věcí usnadní, vše vysvětlím. Jednoduchý příklad. Třeba máte tři proměnné "x", "y" a "z". Ano, to je moc hezké. Ale mi z nich chceme mít jen jedinou proměnnou, která se bude jmenovat "souradnice", a která bude obsahovat ony hodnoty "x", "y" a "z". Jak to ale jen provést? Snadné! Prostě si napíšeme strukturu, která se bude jmenovat "souradnice", a ta bude mít tři položky "x", "y" a "z". Nojo, to se snadno řekne, ale jak si tu strukturu mám vytvořit? Třeba takhle:

OBJECT souradnice
  x,y,z

Takže tímto jsme si vytvořili strukturu "souradnice", která má ty tři položky. Tím to ale nekončí, struktura sama o sobě nic neznamená, jen říká programovacímu jazyku, jak má zacházet s proměnnou, jejíž typ je právě tahle struktura. (nějaké typy jsme probírali minule). Takže si ještě musíme vytvořit proměnnou, jenž bude používat tuto strukturu:

DEF xyz:souradnice

Tak, teď máme proměnnou, která se jmenuje "xyz" a je typu "souradnice", což je právě ta naše struktura. A nyní zbývá vysvětlit, jak se dostat k jejím položkám "x", "y" a "z". Opět je to snadné:

xyz.x:=0
xyz.y:=1
xyz.z:=2

Těmito řádky jsme si uložili do daných položek dané hodnoty, snad není třeba vysvětlovat, kteráže hodnota přišla do které položky. Nyní si říkáte, že je použití struktur vlastně zbytečné, protože akorát přibylo spoustu psaní navíc. A máte pravdu. Ale jen částečně. Co když budete potřebovat vytvořit další souřadnice? Třeba úhlové souřadnice? S proměnnými byste potřebovali další tři proměnné, třeba "x2", "y2" a "z2", nám ale stačí připsat jen:

DEF uhel:souradnice

A můžeme vesele používat jednu strukturu na a více proměnných. Už to začíná znít zajímavěji, že? Ty rejpavejší z vás jistě napadne, co asi znamená to samotné "xyz", či "uhel". To je prosím adresa paměti, ve které se nacházejí položky dané struktury. Teď vysvetlím blíže, jak to vlastně v počítači s tou pamětí je. Řekněmě, že máme 1 kilobajt RAM (HAHAHA), nám to ale stačí. Procesor počítače do ní musí moct nějak přistupovat, a tak má tato paměť nějakou počáteční adresu, třeba nula. Takže na adrese 0 začíná naše paměť. A proto, že je tato paměť veliká pouhý kilobajt, což se rovná 1024 bajtů, tak tato paměť končí na adrese 1024. Kdyby byl začátek paměti na adrese 500, tak by byl její konec na adrese 1524. To je snad pochopitelné. A teď k naší ukázce:

DEF xyz:souradnice

Proměnná xyz je obsažena na nějaké nedůležité adrese v paměti počítače. Proměnná xyz zabírá 12 bajtů paměti, to znamená, že tato proměnná končí na adrese "xyz+12". Dvanáct proto, protože "xyz" obsahuje tři položky, a každá zabírá v paměti 4 bajty, což je jeden LONG. Řekněmě, že proměnná "xyz" bude ukazovat na adresu třeba 512. Z toho by vám mělo být jasné, že na adrese 512 leží položka "x", na adrese 516 leží položka "y" a na adrese 520 leží položka "z". Takže tato proměnná zabírá pole 12 bajtů, a to od 512 do 524. Jasné?

Určitě je vám jasné, že struktury mohou být o značně rozsáhlé, možnostem se meze nekladou. A právě proto také existují "ukazatele na adresu". To je obyčejná proměnná, která jediné co obsahuje je nějaká adresa:

DEF uhel:PTR TO souradnice

Jak je vidět, jediný rozdíl je v tom "PTR TO" což nám říká, že tato proměnná si nebude alokovat žádnou paměť pro své položky, ale že bude pouze obsahovat adresu, která by měla být adresou paměti, ve které se nalézá obsah struktury "souradnice". Toto je velice výhodné, pokud chcete používat strukturu, která již v paměti je. Takže pokud budeme chtít přistupovat do paměti, která je alokována pro proměnnou "xyz", tak nám stačí napsat:

uhel:=&xyz

což zkopíruje adresu proměnné "xyz" do proměnné "uhel". A pak stačí, když napíšete:

uhel.x:=3
uhel.y:=4
uhel.z:=5

a tím změníte obsah proměnné "xyz". Je ale nutné dávat pozor, jestli je adresa v proměnné správná, protože pokud je třeba nula, může dojít k pádu systému, pokud se pokusíte na takovou adresu zapisovat.

Konstanty

Teď z trochu jiného soudku. Konstanty jsou obyčejná čísla, která jsou ale pojmenovaná. To je jejich jediná výhoda, ale je to velmi důležitá výhoda. Když třeba nevíte kolik je vám let, tak si to zjistěte, a vytvořte si konstantu třeba:

CONST MUJ_VEK=24

Tak a teď si už nemusíte pamatovat svůj věk, stačí, když víte, že ho máte v konstantě "MUJ_VEK", a pokud ho budete potřebovat použít, tak snadno místo vašeho věku napište "MUJ_VEK" a kompilátor si místo něj již dosadí hodnotu 24. Opravdu snadné, že? AmigaOS je plné konstant, a i vy se jich spousty naučíte používat.

Okno

Tak. Teď už víte téměř vše, co je potřeba k otevření okna, a co nevíte, to vám ještě sdělím. Tak předně, otevírání okna již není taková primitivní záležitost, je to sice snadné, ale už o tom musíte něco vědět. A já vám to řeknu :) Především potřebujete konstanty, které vám pomohou s nastavením a otevřením okna. Ty se nalézají v modulu dmodules:intuition/intuition.m, schválně si ho najděte, a podívejte se na něj! Nebojte, žádný strach, je jich tam spousta, já vím, a taky je tam hromada struktur, ale není to tak složité, jak se může zdát. My použijeme pouze pár konstant a jeden objekt (strukturu). Tento modul si do svého zdrojového kódu vpravíme pomocí následující řádky:

MODULE 'intuition/intuition'

Teď můžete používat všechny konstanty a objekty (atd.), které jsou v modulu obsaženy, pokud byste je použili předtím, než byste tento modul načetli, došlo by při kompilaci k chybě, protože by vaše konstanta nebyla známá.

Teď si nadefinujeme proměnnou, která bude ukazatelem na okno, které si otevřeme. Tento objekt se jmenuje "Window", schválně se na ni podívejte ve výše zmíněném modulu, a uvidíte, že obsahuje například své rozměry a dalši zajímave věci. Ty nám jsou ale k ničemu, dokud nebude okno otevřené.

DEF okno:PTR TO Window

Jako v každém programu si vytvoříme "main" proceduru, a hned se vrhneme na první řádek, který nám otevře okno:

PROC main()
  okno:=OpenWindowTags(NIL,
    WA_Left,20,
    WA_Top,20,
    WA_Width,150,
    WA_Height,150,
    WA_Title,'Moje prvni okno :)',
    WA_Flags,WFLG_CLOSEGADGET|WFLG_DEPTHGADGET|WFLG_DRAGBAR,
    WA_IDCMP,IDCMP_CLOSEWINDOW,
    TAG_END)

No dobře, není to jen jeden řádek, je jich hned několik, ale v podstatě je to jen jeden řádek roztažený na vícero, aby se v tom člověk lépe vyznal. Tady doporučuji vyhledat funkci "OpenWindow" v autodocech (intuition), protože tam jsou popsány do detalu všechny konstanty, které jsou pro otevření okna potřeba. Já vysvětlím jen ty, co používáme tady. Toho prvního "NIL" si moc nevšímejte, to je zde použite vlastně jen kvůli zpětné kompatibilitě, ale nesmíte na něj zapomenout. Pak následují tagy. Tag je obyčejná struktura, která má dvě hodnoty, první udává typ té hodnoty, a druhá udává tu hodnotu samotnou. První hodnota je vždy konstanta, hruhá může obsahovat prakticky cokoliv. Takže jdeme na to. První řádek obsahuje "WA_Left,20,". "WA_Left" je tedy ten tag, neboli "co znamená ta následující hodnota", pak následuje čárka a ta hodnota. Tady je to číslo "20". A protože WA_Left udává levou vzdálenost okna od levého okraje obrazovky, bude tedy tato souřadnice 20. Hodnoty WA_Top, WA_Width a WA_Height asi nemá smysl popisovat blíže, než jen, že obsahuji vzdálenost vršku okna od vršku obrazovky, šířku okna a výšku okna. Takže již máme udány rozměry okna, které jsou 150x150 pixelů, a jeho pozici, což je 20,20 pixelů pro souřadnice x,y. Za WA_Title musí následovat název okna ohraničený apostrofy, takže název našeho okna bude "Moje prvni okno :)". Do teď to byly snadné a předvídatelné věci, ale teď začíná potřeba jistých znalostí, aby vám bylo jasné, jak pokračovat, protože rozměry a název opravdu nestačí. WA_Flags zapíná různé volby okna, já popíši pouze ty zde přítomné, ostatní najdete v autodocech u funkce OpenWindow. Abych blíže vysvětlil flagy, tak každý flag je konstanta, která obsahuje jeden bit. Tento bit má pouze pro každý flag jinou pozici, a protože konstanty jsou 32 bitové, muže existovat maximálně 32 flagů jednoho typu. Protože flagy jsou bity, používáme k jejich sloučení bitový součet, neboli bitové OR (NEBO), jenž se v PowerD značí operátorem "|", takže na řádku s WA_Flags si můžete všimnout, že bitově sčítáme tři flagy, a sice WFLG_CLOSEGADGET, WFLG_DEPTHGADGET a WFLG_DRAGBAR. Než vysvětlím tyto tři konstanty (flagy), vysvětlím bitové sčítání. Vezměně si třeba tři binarní čísla %10000, %00100 a %00001. Pokud je bitově sečteme, dostaneme výsledek %10101, takže bitové sčítání znamená, že vezmeme všechny jedničky všech činitelů, a překopírujeme je do výsledku. Nyní tedy k těm vlastním flagům. WFLG_CLOSEGADGET nám říká, že chceme, aby okno mělo zavírací tlačítko v levém horním rohu. WFLG_DEPTHGADGET nám říká to samé o tlačítku v pravém horním rohu na přesouvání okna vpřed/vzad. A WFLG_DRAGBAR nám sděluje, že budeme moci okno přesunout chytnutím za titulní lištu.

A teď nám zbývá poslední důležitá věc. Musíme nastavit, na co bude toto okno reagovat. Defaultně nereaguje na nic, takže pokud chcete, aby vám reagovalo třeba na zmačknutí klávesy, či tlačítka myši, ale třeba i při vsunutí nebo vyndání diskety, tak to se nastavuje pomocí IDCMP flagů, a tagu WA_IDCMP. Způsob je úplně stejný, jako v případě WA_Flags, jen se tam používají jiné konstanty. V této ukázce používám pouze jediný flag IDCMP_CLOSEWINDOW, kterýžto mi reaguje pouze na zavření okna, takže pokud zmáčknu zavírací tlačítko, naše okno na to zareaguje. Ale abyste pochopili, co znamená to "zareaguje", musím se ponořit hlouběji do systému. V systému se hojně pouzívá portů, a zpráv, které tyto porty přijímají a vysílají. Třeba okno má svůj vlastní port, který dostává zprávy například při pohybu myši, při mačkání kláves a při dalších akcích. Tag WA_IDCMP je vlastně takový filtr, který nám odfiltruje ty zprávy, které nás nezajímají, a tím nám velmi usnadní zpracování svých zpráv, protože se nebudeme muset zajímat, které zprávy nám zajímají, a které ne. Jak bude náš program reagovat na reakci okna si ukážeme dále. Ještě nám zbývá poslední část definice okna, a tím je ukončení této definice, to se provádí pomocí tagu TAG_END, jenž nám ukončuje pole tagů.

Teď musíme vzít v úvahu, že se okno z jakéhokoliv důvodu nepodařilo otevřít, v takovém případě s oknem nesmíme pracovat, protože by mohlo dojít k pádu systému. Pokud se nám okno nepodaří otevřít, bude proměnná "okno" obsahovat pouze nulu, takže pokud je okno otevřené, platí, že proměnná "okno" se nerovná nule (neboli NIL):

  IF okno<>NIL

U podmínky IF se automaticky počítá s podmínkou "<>0", takže tuto část můžeme klidně vynechat, a místo toho použít zkrácené:

  IF okno

Nyní si ukážeme, jak reagovat na akci okna. V našem případě reaguje okno pouze na své zavření, což znamená, že pokud nám okno zareaguje na cokoliv, můžeme ukončit program, protože to "cokoliv" může být pouze zavření okna, neboť jsme si tak nastavili filtr:

    WaitPort(okno.UserPort)

Tato funkce čeká, dokud port okna nebude obsahovat nějakou zprávu, jakmile se v něm nějaká zpráva objeví, bude program pokračovat dále (více o této funkce se dozvíte v autodocech k exec.library). Zde je vidět první důvod toho, proč jsme proměnnou okno definovali jako "PTR TO Window", protože jinak by byla položka "UserPort" neznámá, a my bysme na port tohoto okna nemohli tak snadno přistoupit. Pokud byste si nastavili třeba i IDCMP_MOUSEBUTTONS, program by pokračoval i při zmáčknutí tlačítka myši.

A teď nám akorát zbývá zavřít okno, a ukončit program:

    CloseWindow(okno)
  ENDIF
ENDPROC

Pokud vás mate to "ENDIF" tak to je tam od toho "IF", které nám sděluje, že pokud proměnná "okno" bude rovna nule, musí program pokračovat až za tímto ENDIF, takže akorát korektně ukončíme program.

No, vidíte, nebylo to zase tak těžké, spoustu věcí si osvojíte časem, a taky si žačnete hrát se složitejším zpracováním zpráv, to si ale vysvětlíme někdy příště. Teď si ještě do okna něco napíšeme a nakreslíme, nejdřív si ale musíme nastavit správnou barvu, zatím zvolíme barvu č. 1, což by měla být v systému barva černá:

  SetAPen(okno.RPort,1)

Zkuste zapřemýšlet, kam umístit tento řádek... Ano správně, tento řádek musí být v programu tam, kde máme jistotu, že je okno otevřené, což znamená, že to musí být někde mezi řádky s tím "IF okno" a se zavřením tohoto okna "CloseWindow(okno)", a taky chceme, aby to, co tam nakreslíme, bylo vidět, než okno zavřeme, takže to musí být mezi tím "IF" a funkcí "WaitPort", protože po této funkci dojde k zavření okna tak rychle, že bysme si žádného vykreslení ani nevšimli. Z toho všeho vyplývá, že nám zbývá jedíná možnost, kam všechny tyhle vykreslovací funkce namačkat, a sice hned za řádek s podmínkou "IF":

  Move(okno.RPort,30,30)
  Draw(okno.RPort,120,40)

Tento příkaz nám přesune grafický kurzor na souřadnice 30,30 okna, což nám zařizuje funkce Move, o níž se můžete dozvědět více v autodocech k graphics.library. Funkce Draw nám z aktuální pozice grafického kurzoru vykreslí čáru v barvě, kterou jsme nastavili pomocí funkce SetAPen, tato cára bude končit na souřadnicích 120,40 okna, bude to tedy podlouhlá, mírně šikmá čára. Nyní si vykreslíme malou elipsu:

  SetAPen(okno.RPort,2)
  DrawEllipse(okno.RPort,75,75,10,20)

Tato funkce nám nakreslí malou elipsu ve středu okna (souřadnice 75,75), která bude mít dva poloměry, jeden do šířky, jenž bude 10 pixelů, a jeden do výšky, jenž bude 20 pixelů. A jak jste si zajisté všimli, je barva této elipsy nastavena na barvu č. 2, což by měla být bílá barva. A ještě jeden grafický element, a tím bude modrý čtvereček vpravo dole:

  SetAPen(okno.RPort,3)
  RectFill(okno.RPort,130,130,140,140)

Tento kvádr začíná na souřadnicích 130,130 a končí na souřadnicích 140,140, je tedy vpravo dole. U této funkce nesmíte zaměnit levé-horní a pravé-dolní souřadnice. Více se dozvíte opět v autodocech k graphics.library. A poslední věc, kterou si do okna nakreslíme, je text:

  Move(okno.RPort,10,100)
  Text(okno.RPort,'Ahoj!',5)

Opět si přesuneme soouřadnice, a to do bodu 10,100 a na nich si vykreslíme text "Ahoj!", kterýžto má pět znaků, a tento počet musíme zadat jako další argument. Barva bude stejná, jako u čtverečku. Abych ještě nezapoměl na vysvětlení toho "okno.RPort", tak tam je to podobné, jako u "okno.UserPort", protože do okna se samo o sobě nedá nic kreslit, zato se dá kreslit do rastportu okna, a právě to "okno.RPort" nám říká, do kterého rastportu budeme kreslit, takže budeme kreslit do rastportu okna, jenž je definováno proměnnou "okno".

Tak, toto by nám při zkompilování a spuštění mělo otevřít okno, něco do něj nakreslit, a až to okno zavřeme, tak to ukončí program:

MODULE 'intuition/intuition'

DEF okno:PTR TO Window

PROC main()
  okno:=OpenWindowTags(NIL,
    WA_Left,20,
    WA_Top,20,
    WA_Width,150,
    WA_Height,150,
    WA_Title,'Moje prvni okno :)',
    WA_Flags,WFLG_CLOSEGADGET|WFLG_DEPTHGADGET|WFLG_DRAGBAR,
    WA_IDCMP,IDCMP_CLOSEWINDOW,
    TAG_END)

  IF okno

    SetAPen(okno.RPort,1)
    Move(okno.RPort,30,30)
    Draw(okno.RPort,120,40)

    SetAPen(okno.RPort,2)
    DrawEllipse(okno.RPort,75,75,10,20)

    SetAPen(okno.RPort,3)
    RectFill(okno.RPort,130,130,140,140)

    Move(okno.RPort,10,100)
    Text(okno.RPort,'Ahoj!',5)

    WaitPort(okno.UserPort)
    CloseWindow(okno)
  ENDIF
ENDPROC

Obrazovka

Takže okno máme, ale teď si ho ještě chceme otevřít na vlastní obrazovce, to je vlastně jednoduchá záležitost, jen si musíme uvědomit, co, a kde máme připsat do stávajícího prográmku. tak předně si tu obrayovku musíme otevřít, potom musíme říct oknu, že se má otevřít právě na této obrazovce, a nakonec ji musíme zase bezpečně zavřít.

Abysme mohli pracovat s obrazovkou, musíme si nejdřív otevřít modul na práci se screeny, takže si otevřeme modul intuition/screens.m, a rovnou si vytvoříme proměnnou, do které ukazatel na obrazovku po jejím otevření uložíme:

MODULE 'intuition/screens'

DEF obrazovka:PTR TO Screen

Tyto řádky by měli být vloženy za jejich oknové ekvivalenty. Nyní si musíme nadefinovat a otevřít obrazovku:

  obrazovka:=OpenScreenTags(NIL,
    SA_Width,320,
    SA_Height,240,
    SA_Depth,3,
    SA_Title,'Moje prvni obrazovka :)',
    SA_LikeWorkbench,TRUE,
    TAG_END)

Jak vydíte, vypadá to dost podobně, jako definice okna, jen se používají jiné konstanty, které začínají předponou "SA_" a ne "WA_", je tam ale i spousta věcí, které u oken nenajdete, a naopak. Pěkně popořádku, tato funkce má stejnou syntaxi argumentů, jako OpenWindowTags, takže zde také používáme tagy. Na prvních dvou řádcích tagů si nastavujeme rozměry obrazovky, tedy ta naše bude 320x240 pixelů veliká. Na dalším řádku nastavujeme její barevnou hloubku v bitech, takže pokud zadáme 1, bude mít obrazovka 2 barvy, pokud 2, tak 4 barvy, pokud 3 (náš případ), tak 8 barev, pokud 8 tak 256 barev, a pokud 24, tak přes 16 miliónů barev. Tady ale dávejte pozor na to, co vaše Amiga (či emulace) zvládá, pokud byste zadali hloubku, kterou Amiga nezvládne, prostě nedojde k otevření obrazovky. Na AGA amigách lze zvolit maximální hloubku 8 bitů, neboli 256 barev. Na grafických kartách to může být 15/16, 24 či až 32 bitů. Na dalším řádku je název obrazovky, a na dalším řádku je zapnuta volba, která nám říká, že chceme, aby obrazovka byla stejná, jako Workbench, až na to, co jsme si nastavili sami. To je výhodné zvláště, pokud chcete, aby váš program korektně otevíral obrazovku jak na ECS/AGA strojích, tak i na grafických kartách. Takže to má své velmi důležité výhody, ale ne vždy to lze použít, protože pokud používáte na Workbenchi (či Ambientu) nějaké vysoké rozlišení, bude naše obrazovka jen malý obdélníček v levém horním rohu na vašem monitoru. Jedna možnost je vypustit definici rozměrů, neboť pokud je nezadáme, bude nová obrazovka stejně veliká, jako Workbench (či Ambient), což může být v některých případech výhodné, ale také né pokaždé, takže nám nezbývá, než si nastavit vlastní obrazovkový mód, který je ale jiný pro každý grafický systém, a tím pádem by váš program korektně fungoval pouze na jediném grafickém systému, jako AGA/CGFX/P96. K tomuto zjištění se používá funkce graphics.library BestMoseIDA, ale to sem zatím nepatří, takže se budete muset spokojit s prográmkem GetModeID, který si otevře okno na výběr rozlišení a počtu barev (na grafických kartách) a dle vaší volby napíše do shellu hexadecimální kód módu obrazovky, jaký jste si vybrali, a ten pak připíšete k definici obrazovky. Pro rozlišení PAL 320x256 tento program napíše 21000, takže vy si do definice obrazovky přidáte rádek s:

    SA_DisplayID,$21000,

Majitelé grafických karet používající grafický systém Picasso96 si nejspíše zvolí obrazovkový mód 320x240x8bitů což by měl být kód 50001000, si tam vloží řádek s:

    SA_DisplayID,$50001000,

A majitelé grafických karet běžících pod systémem cybergraphics si tam vloží ekvivalent těchto kódů pro jejich systém, já pod tímto systémem bohužel nefunguji, takže nemůžu říci přesný kód.

Tak, obrazovku máme otevřenou, ale nemůžeme si nikdy být jisti, že se to opravdu povedlo, takže jako u okna, i tedy musíme otestovat, lestli se opravdu otevřela:

  IF obrazovka

Snad je vám jasné, že těch několik řádků, na kterých si definujeme obrazobvku musí být před defenicí otevření okna, a test, zda je obrazovka otevřená musí být bezprostředně za jejím otevřením. Nyní si musíme upravit definici okna tak, aby se otevřelo právě na této obrazovce, a je to opět velmi jednoduché, stačí nám k tomu přidání jediného řádku do definice okna a sice:

    WA_CustomScreen,obrazovka,

Tento řádek vložte kamkoliv do definice, a rázem se bude okno otevírat na nové obrazovce. Teď nám zbývá už jen korektně zavřít obrazovku. To provedeme příkazem CloseScreen (jak taky jinak), ale musíme dát pozor, aby byla obrazovka prázdná, protože jinak se nezavře, a zůstane otevřená, a nepoužitelná. Takže tuto funkce zavoláme až za zavřením okna:

    CloseScreen(obrazovka)
  ENDIF

To "ENDIF" je tam od toho IF, které by ukončilo program, pokud by se nepovedlo obrazovku otevřít. Takže celý výsledný program je:

MODULE 'intuition/intuition'
MODULE 'intuition/screens'

DEF okno:PTR TO Window
DEF obrazovka:PTR TO Screen

PROC main()
  obrazovka:=OpenScreenTags(NIL,
    SA_Width,320,
    SA_Height,240,
    SA_Depth,3,
    SA_Title,'Moje prvni obrazovka :)',
    SA_LikeWorkbench,TRUE,
    SA_DisplayID,$21000,            // AGA/PAL
    TAG_END)

  IF obrazovka

    okno:=OpenWindowTags(NIL,
      WA_Left,20,
      WA_Top,20,
      WA_Width,150,
      WA_Height,150,
      WA_Title,'Moje prvni okno :)',
      WA_Flags,WFLG_CLOSEGADGET|WFLG_DEPTHGADGET|WFLG_DRAGBAR,
      WA_IDCMP,IDCMP_CLOSEWINDOW,
      WA_CustomScreen,obrazovka,
      TAG_END)

    IF okno

      SetAPen(okno.RPort,1)
      Move(okno.RPort,30,30)
      Draw(okno.RPort,120,40)

      SetAPen(okno.RPort,2)
      DrawEllipse(okno.RPort,75,75,10,20)

      SetAPen(okno.RPort,3)
      RectFill(okno.RPort,130,130,140,140)

      Move(okno.RPort,10,100)
      Text(okno.RPort,'Ahoj!',5)

      WaitPort(okno.UserPort)
      CloseWindow(okno)
    ENDIF
    CloseScreen(obrazovka)
  ENDIF
ENDPROC

Tak, to by mělo pro tento tutoriál stačit. Příště si povíme něco o souborech a prací s nimi, něco málo o requesterech, a taky si řekneme něco o polích. Pokud máte nějaké dotazy, či připomínky, napište mi na mail mark@tbs-software.com.