PureBasic
Průvodce programováním pro začátečníky
PureBasic – Průvodce programováním pro začátečníky
autor: Gary Willoughby
Copyright © 2006 Gary Willoughby. Tato kniha a všechny přiložené zdrojové materiály, jako jsou diagramy, fotografie a zdrojové kódy v PureBasicu, se šíří pod licencí Creative Commons Uveďte původ – Neužívejte komerčně – Zachovejte licenci (Attribution Non-Commercial Share Alike). Další podrobnosti najdete zde: http://creativecommons.org/about/licenses/
PureBasic je registrovaná ochranná známka společnosti Fantaisie Software. Na PureBasic a všechny nástroje a součásti obsažené v balíku PureBasic se vztahuje Copyright © 2006 Fantaisie Software.
Fantaisie Software 10, rue de Lausanne 67640 Fegersheim France www.purebasic.com
Vydalo v roce 2006 nakladatelství Aardvark Global Publishing.
Redakce
Gary Willoughby
Historie vydání
Červenec 2006 – první vydání
Prohlášení o vyloučení odpovědnosti
Přestože při přípravě této knihy a programů v ní obsažených byla učiněna veškerá opatření, autor ani vydavatel nepřebírají žádnou odpovědnost za chyby, opomenutí ani za škody vzniklé v důsledku použití zde uvedených informací či programů. Autor ani vydavatel neodpovídají za nahodilé ani následné škody, které vzniknou v souvislosti s poskytnutím, funkcí či použitím programů, souvisejících pokynů a/nebo tvrzení o zvýšení produktivity, nebo které z nich vyplynou. Všechny zde uvedené informace jsou považovány za přesné ke dni vydání, ale protože PureBasic je jazyk, který se neustále zdokonaluje a vyvíjí, mohou některé informace časem zastarat. Aktuální novinky a informace o PureBasicu najdete na www.purebasic.com.
Ochranné známky
V celé této knize se objevují názvy chráněné ochrannými známkami. Místo toho, aby vydavatel vypisoval tyto názvy a subjekty, které ochranné známky vlastní, nebo vkládal ke každé zmínce symbol ochranné známky, prohlašuje, že tyto názvy používá pouze pro redakční účely a ve prospěch vlastníka ochranné známky, bez úmyslu tuto ochrannou známku porušit.
Věnování
Věnováno mé přítelkyni Saře Jane Gostickové a jejímu psovi ‘Stelle’ za to, že snášely mnoho osamělých večerů, zatímco jsem psal tuto knihu, a za povzbuzení (a kuřecí večeře), kterého se mi od ní vždy dostává.
Poděkování
Děkuji Fredovi a týmu PureBasicu za jazyk PureBasic – jen tak dál, je to skvělé! Děkuji Paulu Dixonovi za vysvětlení některých podrobností o binárním kódování čísel s plovoucí desetinnou čárkou. Děkuji Timu Harterovi za pomoc s výběrem datových typů PureBasicu, které by nejlépe nahradily typy Win32 API, a za ukázku, jak z paměti získávat různé řetězce pomocí různých typů ukazatelů na řetězce ve Win32 API.
„S velkou mocí musí přijít i velká zodpovědnost!“ --Ben Parker (strýc Spidermana)
Příklady kódu obsažené v této knize si můžete zdarma stáhnout z adresy
www.pb-beginners.co.uk
ISBN 1-4276-0428-2 19/7/2006
Předmluva
O této knize
Tato kniha nabízí rychlý úvod do programovacího jazyka PureBasic. Obliba PureBasicu za posledních několik let výrazně vzrostla; používá se k mnoha účelům, například k rychlé tvorbě prototypů softwaru, k vývoji komerčních aplikací a her či internetových CGI aplikací, a někteří lidé v něm píší jen drobné pomocné programy. Tuto knihu jsem psal s ohledem na úplné začátečníky. Každý musí někde začít a já věřím, že PureBasic je fantastický první skok do světa programování. Protože se PureBasic používá stále šířeji, mnoho lidí s ním začíná a zjišťuje, že občas potřebuje postrčit správným směrem nebo vysvětlit určitou funkci či zvláštnost. Tato kniha má provést začátečníky jejich prvními krůčky a zkušeným programátorům poskytnout rychlý přehled o jazyce.
Rozsah této knihy
Přestože tato kniha pokrývá základy jazyka PureBasic, její rozsah jsem udržel poměrně úzký, aby noví uživatelé nebyli zahlceni informacemi. Text se místy odkazuje na pojmy a syntaxi zjednodušeně, aby mohl posloužit jako odrazový můstek k pokročilejším textům nebo jako doplněk k existující nápovědě PureBasicu.
Nebudu například příliš mluvit o tom, jak snadné je v PureBasicu přímo používat DirectX nebo OpenGL, jinak by tato kniha byla třikrát tlustší. A přestože se později v knize hovoří o tématech, jako jsou ukazatele, vlákna a Win32 API, nečekejte příliš mnoho efektních příkladů, protože tato pokročilá témata jsem pouze nastínil.
PureBasic posouvá laťku nejen toho, jaký by měl být jazyk Basic, ale i toho, jaké by měly být všechny jazyky. Čistá, přehledná syntaxe, malé zkompilované spustitelné soubory a fantasticky aktivní komunita programátorů. Doufám, že vám tato kniha poskytne jasnou představu o hlavních vlastnostech PureBasicu i o cílech a filozofii, které stály za jeho vznikem, a že ve vás probudí chuť učit se dál.
Navzdory omezenému rozsahu této knihy si myslím, že pro vás bude skvělou první knihou o PureBasicu, která vám zároveň dá pevné základy programování obecně, pokud byste později přešli k jiným jazykům. Naučíte se vše, co potřebujete, abyste mohli začít psát užitečné samostatné programy. Až knihu dočtete, budete znát nejen základy samotného jazyka, ale také to, jak tyto znalosti uplatnit při každodenních úkolech. Budete také lépe připraveni pustit se do pokročilejších témat, až na ně narazíte.
Struktura této knihy
Velká část této knihy je navržena tak, aby vás s PureBasicem seznámila co nejrychleji, a je uspořádána tak, že hlavní vlastnosti jazyka představuje postupně, jednu část po druhé. Každá kapitola je poměrně samostatná, ale pozdější kapitoly, zejména ty pokročilejší, využívají myšlenky představené dříve. Když se například dostaneme ke grafickým uživatelským rozhraním a grafice, budu předpokládat, že už rozumíte procedurám a strukturám.
Část I: Jádro jazyka
Tato část knihy je přímočarým výkladem hlavních vlastností jazyka postupujícím od základů nahoru – typů, procedur, struktur a podobně. Většina uvedených příkladů není jako samostatné programy nijak zvlášť užitečná; slouží k předvedení a vysvětlení právě probíraného tématu.
Kapitola 1, Začínáme
Zde začneme stručným úvodem do PureBasicu a historie tohoto jazyka. Následuje přehled toho, jak spustit program v PureBasicu z IDE (vývojového prostředí) a k čemu slouží debugger (ladicí program).
Kapitola 2, Datové typy
V této kapitole nejprve vyjmenuji a vysvětlím všechny dostupné vestavěné datové typy, jako jsou řetězce, číselné typy a konstanty. Ke všem vestavěným datovým typům uvádím zásady jejich použití a také informace o spotřebě paměti a tam, kde to má smysl, i o číselných mezích.
Kapitola 3, Operátory
Zde vysvětlím základní způsoby, jak proměnným skutečně přiřazovat hodnoty, a popíšu, jaké operátory jsou potřeba k výpočtům s daty. Všechny operátory jsou podrobně vysvětleny a doprovázeny diagramy a příklady. Představím zde také příkaz ‘Debug’, protože patří k nejužitečnějším příkazům jazyka PureBasic a jeho význam byste měli pochopit hned zkraje.
Kapitola 4, Podmíněné příkazy a cykly
V této kapitole vysvětlím, jak PureBasic zachází s booleovskými hodnotami, představím příkazy ‘If’ a ‘Select’ a vysvětlím a předvedu cykly. Nechybí příklady ani podrobné vysvětlení.
Kapitola 5, Další datové struktury
Tato kapitola ukazuje, jak vytvářet a používat další způsoby ukládání a organizace dat, jako jsou uživatelem definované struktury, pole a spojové seznamy. I zde jsou uvedeny podrobné výklady a příklady.
Kapitola 6, Procedury a podprogramy
Procedury a podprogramy jsou nezbytnou součástí programování v jakémkoli jazyce, protože pomocí nich lze spouštět úseky kódu (u procedur navíc s proměnnými parametry) z libovolného místa běžícího programu. To programování usnadňuje, protože celý program lze rozdělit na snadno zvládnutelné části a tento modulární kód pak lze znovu a znovu používat.
Kapitola 7, Používání vestavěných příkazů
Tato kapitola předvádí některé z nejčastěji používaných vestavěných příkazů. Nejde o úplnou referenční příručku ani průvodce každým jednotlivým příkazem každé knihovny, ale získáte z ní dobrý základ toho, jak a kdy vestavěné knihovny používat. Vysvětluji zde také handly (Handles) a ID, které jsou obojí snadno pochopitelné, ale občas se snadno zaměňují.
Kapitola 8, Dobrý programátorský styl
Tato kapitola vám poskytne návod na dobré programátorské postupy, které se používají v celé této knize, a nabídne přehled jednoduchého ošetřování chyb. Při programování v jakémkoli jazyce jsou chyby vždy problémem, ať už jde o obyčejný překlep, nebo o chybu v samotném jazyce. Kapitola se také zabývá tím, jak si můžete dávat lépe pozor, abyste chyby nezanášeli, jak a proč byste měli svůj program na chyby testovat a jak reagovat, když nějakou najdete.
Část II: Grafická uživatelská rozhraní
Téměř každý dnešní program má nějaké uživatelské rozhraní a zde vám ukážu, jak ho vytvořit. Na základě myšlenek a příkladů tvorby konzolové aplikace se nakonec naučíte sestavovat okenní aplikace spolu se standardními ovládacími prvky (gadgety), jako jsou nabídky, tlačítka a grafika.
Kapitola 9, Tvorba uživatelských rozhraní
Zde vám ukážu, jak si můžete sestavit vlastní uživatelská rozhraní. Začnu vysvětlením a předvedením konzolových aplikací a poté přejdu k tvorbě nativních okenních rozhraní. Popíšu také události a na příkladech ukážu, jak reagovat, když je ve vašem rozhraní zjištěna nějaká událost. Krátce zde představím i přiložený vizuální návrhář formulářů.
Část III: Grafika a zvuk
Grafika a zvuk hrají v téměř každém dnešním počítačovém systému důležitou roli. Tato část se zabývá přehráváním zvuků, způsoby zobrazování grafiky na obrazovce a manipulací s touto grafikou, ať už ve 2D, nebo ve 3D.
Kapitola 10, 2D grafika
Tato kapitola představuje dvourozměrnou grafiku, jako jsou čáry a tvary, a způsob, jakým se kreslí na obrazovku. Zabývá se také sprity (obrázky, které lze zobrazovat a s nimiž lze manipulovat) a vysvětluje obrazovky (screens) a dvojité bufferování.
Kapitola 11, 3D grafika
Trojrozměrnou grafiku v PureBasicu zajišťuje engine OGRE. Přehled a několik příkladů ukazuje, co je s tímto enginem možné. Engine OGRE se stále vyvíjí a teprve se plně začleňuje do PureBasicu, ale i tak s ním lze dosáhnout pěkných výsledků.
Kapitola 12, Zvuk
Tato kapitola se zabývá používáním zvuku v PureBasicu a tím, jak načítat a přehrávat známé zvukové formáty.
Část IV: Pokročilá témata
Poslední část se zabývá věcmi, které by začátečník považoval za velmi pokročilé. Témata, která obsahuje, nemusíte znát, abyste mohli psát plně funkční a užitečné programy, ale lze jimi dosáhnout věcí, které běžnými postupy dosáhnout nelze. Tato část vám má povzbudit chuť po poznání, abyste lépe porozuměli PureBasicu i programování obecně.
Kapitola 13, Za hranicemi základů
Zde se probírá pokročilá správa paměti pomocí ukazatelů. Vysvětleny jsou direktivy kompilátoru a nechybí ani návod, jak vytvořit DLL. Je zde také oddíl o rozhraní Windows API (Windows Application Programming Interface).
Část V: Přílohy
Toto je závěrečná část knihy; končí přílohami, které čtenáře odkazují na užitečné stránky na internetu, nabízejí užitečné tabulky a obsahují obsáhlý slovníček slov a pojmů.
Předpoklady
Doufám, že umíte zacházet s počítačem – o tom, jak používat myš nebo co je to ikona, tu příliš řeč nebude. Tato kniha však předpokládá, že jste v programování úplný začátečník, a to nejen v PureBasicu, ale obecně.
Abyste mohli začít programovat ještě dnes, budete potřebovat jen trochu času a kopii PureBasicu, kterou získáte na www.purebasic.com
IJádro jazyka
V této části se budeme věnovat samotnému jazyku PureBasic. Nazývám ji „Jádro jazyka“, protože se zaměříme na to podstatné z programování v PureBasicu: na jeho vestavěné typy, příkazy a výrazy. Až dočtete tuto část a prostudujete si příklady, budete připraveni psát programy sami.
Slovo „jádro“ je v názvu použito záměrně, protože tato část není vyčerpávajícím popisem každého drobného detailu PureBasicu. I když některé věci cestou možná přeskočím, základy, které se zde naučíte, vám budou velmi dobře sloužit, až narazíte na něco neznámého. Pro zájemce je zde také zmínka o historii a filozofii vývoje PureBasicu.
1Začínáme
Tato první kapitola začíná stručnou historií PureBasicu a poté se rychle podívá na to, jak spouštět programy v PureBasicu. Jejím hlavním cílem je připravit vás na kompilování a spouštění programů v PureBasicu na vašem vlastním počítači, abyste mohli souběžně pracovat s příklady a návody uvedenými v této knize. Cestou si probereme různé způsoby, jak lze v PureBasicu kompilovat – právě tolik, abyste mohli začít.
Podíváme se také na přiložené IDE (vývojové prostředí), které je součástí standardní instalace PureBasicu. Novým uživatelům se může zdát trochu odstrašující, ale po krátkém přehledu a malém návodu už bude vypadat mnohem méně hrozivě.
Historie PureBasicu
PureBasic vznikl v roce 1995 jako rozšíření sady příkazů pro BlitzBasic poté, co autor PureBasicu Frédéric Laboureur narazil na mnohá omezení BlitzBasicu při programování aplikace nazvané ‘TheBoss’, výkonného spouštěče aplikací pro Commodore Amiga. Rozšíření pojmenované ‘NCS’ (NewCommandSet) bylo celé napsáno v assembleru procesoru 68000, protože v té fázi vývoje Blitzu musely být všechny nové příkazy psány v assembleru. Fredův postup byl zpočátku dost pomalý, protože kvalitní dokumentace k programování v assembleru se sháněla těžko a online fóra pro programování zásuvných modulů do BlitzBasicu tehdy samozřejmě neexistovala.
Vývoj ‘NCS’ pokračoval asi rok a Fred za svou práci sklízel velmi pozitivní ohlasy; během ní se také důkladně seznámil s programováním a laděním v assembleru. Byl rovněž ohromen tím, jak neuvěřitelných věcí lze se starým procesorem 68000 dosáhnout, je-li všechno správně naprogramováno.
Zhruba v té době se začaly objevovat procesorové karty pro Amigu založené na procesorech IBM PowerPC, které představovaly velmi výkonnou alternativu k procesoru Motorola 68000. Byly velmi rychlé a prodávaly se za poměrně nízkou cenu, a to i ve srovnání se špičkovými procesory 68060. S příchodem těchto nových čipů lidé chtěli nativní verzi Blitzu, která by je podporovala, protože to byl v té době nesmírně oblíbený jazyk; všichni však věděli, že veškerý vývoj pro platformu Amiga byl pozastaven ve prospěch počítačů PC s procesory Intel x86. Naskytla se tak příležitost vytvořit nový jazyk, který by byl logickou náhradou a vylepšením BlitzBasicu a zároveň by plně podporoval procesory 680x0 a PowerPC.
Na scénu přichází PureBasic!
Prvotní návrh a první verze PureBasicu vznikly v roce 1998. Hlavním rozdílem mezi PureBasicem a tehdejšími „běžnými“ kompilátory bylo to, že od samého začátku obsahoval „virtuální procesor“ (který ve skutečnosti používal mnemotechnické zkratky assembleru 680x0), díky němuž bylo možné vytvářet různé druhy výstupu v assembleru (nebo v jakémkoli jiném jazyce), aniž by bylo nutné měnit jádro kompilátoru. Jakmile byl počáteční návrh hotov a začalo se programovat, věci se rozběhly velmi rychle. Fred zasvětil veškerý svůj čas programování kompilátoru a hodně se přitom naučil, mimo jiné i jazyk C, aby nakonec mohl vytvořit plně přenositelný kompilátor.
První verze PureBasicu byla původně vydána pro Amigu a (přestože byla plná chyb) obsahovala integrovaný a plně multiplatformní editor, integrovaný debugger (ladicí program) a obrovskou vnitřní sadu příkazů, převzatou – jak jste jistě uhodli – přímo z dřívějšího balíku ‘NCS’ pro Blitz.
Během ladění a testování chyb Fred také studoval jiné programovací jazyky, aby získal pevné základy i v dalších oblastech a měl co nejlepší podklady pro lepší a informovanější rozhodnutí o vnitřním návrhu a o tom, jak by měl PureBasic v budoucnu růst a rozšiřovat se.
Ve čtvrtém roce Fredova studia informatiky už byla Amiga považována za mrtvou platformu a mnozí Fredovi spolužáci se ho ptali, proč nepracuje na verzi pro Windows. Fred se samozřejmě bránil tím, že převést PureBasic na nový systém by byla hračka – ale musel to dokázat!
Větší kolbiště
Fred se začal učit programovat Microsoft DirectX a Win32 API (viz kapitola 13), a to kompletně v assembleru – obrovský úkol! Přitom zjistil, že pro někoho, kdo přichází od procesorů Motorola 680x0, je Intel x86 noční můrou na pochopení i na programování, protože tento čip je navržen úplně jinak. Dokonce i způsob uložení čísel v paměti byl obrácený! Po třech měsících vývoje a po založení jeho nové společnosti Fantaisie Software vznikl nový web a PureBasic pro Windows byl konečně vydán. Používání a testování PureBasicu přibývalo a Fred dostával mnoho povzbudivých a nadšených e-mailů, které ještě posílily jeho odhodlání vyvinout co nejlepší jazyk.
Po mnoha letech pečlivého vývoje se kolem Freda zformoval tým, který mu pomáhá s vývojem a testováním nových verzí. Tento tým tvoří zkušení programátoři, weboví designéři a autoři dokumentace, kteří všichni sdílejí stejnou vizi jazyka.
Po obrovském úspěchu verze pro Windows bylo dalším logickým krokem podporovat další operační systémy. Brzy tedy přibyla podpora Linuxu a Mac OS a stále více ohromené veřejnosti byly představeny nativní verze PureBasicu. Všechny verze podporují nativní rozhraní pro programování aplikací (API) příslušných operačních systémů a všechny používají nativní grafická uživatelská rozhraní, aby programy měly vzhled a chování odpovídající danému systému.
Vývoj verze pro Commodore Amiga byl zastaven v roce 2002, kdy mnoha uživatelům začalo být jasné, že samotná Amiga ztrácí půdu pod nohama ve prospěch PC a že ji nakonec (až na zarputilé nadšence) všichni považují za mrtvou platformu. Verze pro Windows, Linux a Mac OS se dodnes neúnavně vyvíjejí a podporují!
Verze 4 je nejnovějším vtělením PureBasicu a byla téměř celá přepsána od začátku. Důvodem je usnadnění budoucích vylepšení a dalšího multiplatformního vývoje. PureBasic v4 přinesl také obrovská vylepšení jazyka, z nichž téměř všechna jsou popsána v této knize.
Filozofie vývoje PureBasicu
Filozofie vývoje PureBasicu se v mnoha ohledech mírně liší od filozofie jiných jazyků. Zde je přehled některých cílů a zásad vývoje PureBasicu.
Po prvním zakoupení licence PureBasicu jsou všechny budoucí aktualizace doživotně zdarma. Všechny programy zkompilované v PureBasicu lze komerčně prodávat bez jakýchkoli dalších poplatků či licenčních odměn. Všechny programy by se měly kompilovat do co nejmenší velikosti souboru a nesmějí obsahovat žádný nabubřelý kód. Žádný zkompilovaný program by neměl záviset na běhových knihovnách (runtimes) a měl by být zcela „samostatným“ spustitelným souborem.
Výše uvedený výčet je sám o sobě velkým tahákem a je v rozporu s mnoha vývojovými filozofiemi konkurenčních firem. Dokážete si představit, že by vám Microsoft doživotně poskytoval nové verze VB.NET zdarma? Já také ne.
Filozofií vývoje PureBasicu je vytvořit programovací prostředí, jehož používání je zábavné a zároveň účelné. Jde především o to, dát uživatelům možnost vytvářet programy, které potřebují, co nejjednodušším způsobem. Všechny dosavadní nové verze přinesly opravy chyb, nové příkazy a také zcela nová IDE a Visual Designer (vizuální návrhář, VD); oběma posledním se věnují pozdější části této knihy. Budoucí aktualizace tedy nepřinášejí jen opravy chyb, ale také rozšíření sady příkazů jazyka spolu s užitečnými nástroji a aktualizacemi samotného vývojového prostředí.
První pohled na IDE
Integrované vývojové prostředí (Integrated Development Environment) PureBasicu se skládá z editoru zdrojového kódu, vizuálního návrháře formulářů a kompilátoru. Vizuálnímu návrháři formulářů se budeme věnovat později v kapitole 9 (První pohled na nový Visual Designer), takže zde zmíním pouze editor zdrojového kódu a kompilátor. V komunitě PureBasicu se editoru zdrojového kódu obvykle říká „IDE“, zatímco vizuální návrhář formulářů dostal pochybné označení „VD“. Je to hlavně proto, aby se ve fórech při kladení otázek nebo účasti v diskusi nemusely psát dlouhé názvy, a proto se této konvence budu držet i zde.

Obr. 1 — IDE, jak vypadá v systému Microsoft Windows.
IDE (obr. 1) je celé napsáno v PureBasicu a je hlavním nástrojem pro psaní programů v PureBasicu, takže si projděme hlavní rozhraní editoru. Nahoře je panel nabídek, který zpřístupňuje příkazy nabídek; pod ním je přizpůsobitelný panel nástrojů, do kterého lze umístit mnoho různých ikon, z nichž každá spouští předem určený příkaz nabídky. Pod panelem nástrojů vlevo je hlavní podokno editoru, kam se zadává veškerý kód v PureBasicu. Vpravo od podokna editoru je další uživatelsky přizpůsobitelné podokno, které může obsahovat prohlížeč procedur, prohlížeč proměnných, průzkumník souborů atd. Ve výchozím nastavení se také jako podokno připojené k dolnímu okraji podokna editoru zobrazuje protokol chyb; ten lze vypnout a zapnout příkazem nabídky (Menu:Debugger->Error Log->Show Error Log, tj. zobrazit protokol chyb). Pod podokny je stavový řádek, který ukazuje, na jakém řádku a sloupci právě editujete, a zobrazuje rychlou nápovědu.
Tento editor je „front-endem“ (uživatelskou nadstavbou) vlastního kompilátoru PureBasicu. Jakmile je kód zadán do podokna editoru a stisknete tlačítko ‘Compile/Run’ (kompilovat/spustit) na panelu nástrojů (klávesová zkratka: F5), kód se předá kompilátoru, který z něj vytvoří spustitelný soubor. K psaní zdrojového kódu pro PureBasic lze použít jakýkoli editor prostého textu, ale doporučuji používat oficiální editor, protože byl od základu napsán výhradně pro podporu kompilátoru PureBasicu. Nejen to – jiné editory vyžadují určitou konfiguraci, aby soubor správně předávaly kompilátoru PureBasicu, což je pro některé uživatele na začátku trochu příliš složité.
Jak spouštět programy v PureBasicu
Dobře, pusťme se do toho a naučme se spouštět programy. Než jsou programy v PureBasicu zkompilovány, jsou to jen obyčejné textové soubory (obvykle s příponou ‘*.pb’), které obsahují samotný kód v PureBasicu. K tomu, aby se z těchto textových souborů zkompiloval spustitelný program, stačí je předat ke zpracování kompilátoru. Lze to udělat mnoha způsoby, například:
V IDE: Stiskněte klávesovou zkratku ‘F5’ pro ‘Compile/Run’. Stiskněte tlačítko ‘Compile/Run’ na panelu nástrojů. Zvolte příkaz nabídky ‘Compiler->Compile/Run’. Zvolte příkaz nabídky ‘Compiler->Create Executable...’ (vytvořit spustitelný soubor).
Z příkazové řádky: Zadejte příkaz ‘PBCompiler filename’, kde ‘filename’ je název textového souboru.
Po přečtení výše uvedeného výčtu se může zdát, že existuje mnoho různých způsobů, jak dosáhnout téhož výsledku, ale některé z nich se mírně liší a je třeba je vysvětlit podrobněji.
První tři výše zmíněné způsoby v IDE vedou ke stejnému výsledku a kterýkoli z nich můžete použít, když právě píšete a testujete aktuální program (nezáleží na tom, který). Účel těchto tří příkazů vyplývá už z jejich názvu: ‘Compile/Run’.
Po jejich zvolení se textový soubor okamžitě zkompiluje do dočasného spustitelného souboru nazvaného ‘purebasic0.exe’ ve složce ‘/PureBasic/Compilers’ a tento spustitelný soubor se poté spustí. To se hodí, když potřebujete okamžitě vidět, jak váš program běží, aniž byste museli zkompilovanému spustitelnému souboru zadávat skutečný název. Pokud tento dočasný program ještě běží, zatímco kompilujete a spouštíte jiný program, vytvoří se nový dočasný soubor nazvaný ‘purebasic1.exe’ a tak dále. Pokud však první program při použití způsobu ‘Compile/Run’ již skončil, kompilátor u dočasných souborů znovu použije stará čísla a jako dočasný název bude dál používat ‘purebasic0.exe’. Tím je zajištěno, že se ve složce ‘/PureBasic/Compilers’ nenahromadí obrovské množství dočasných spustitelných souborů.
Poslední způsob v IDE, tedy příkaz nabídky ‘Compiler->Create Executable...’, slouží pro situaci, kdy je veškerý vývoj aktuálního programu hotov a jste připraveni zkompilovat a nasadit svůj spustitelný soubor. Po zvolení tohoto příkazu nabídky se zobrazí dialogové okno, které vás vyzve k zadání názvu a umístění výsledného spustitelného souboru programu.
Způsob s příkazovým řádkem Windows (Command Prompt) je určen pro pokročilejší uživatele a umožňuje ručně zadávat příkazy, kterými se textový soubor předá kompilátoru PureBasicu jako parametr. Spolu s názvem souboru lze předat i další parametry, které kompilaci dále přizpůsobí. O těchto dalších parametrech pojednáme později v kapitole 13 (Pokročilá nastavení kompilátoru).
To je vše, co ke zkompilování a spuštění vašeho prvního programu potřebujete. Po zadání příkazů do podokna editoru stačí stisknout ‘F5’ a jdete na to!
Debugger
Debugger (ladicí program) PureBasicu je nástroj, který řídí běh programu, na kterém pracujete. Během běhu programu kontroluje a sleduje všechny proměnné, parametry procedur atd. Je to druhý pár očí, který dohlíží na váš kód, upozorňuje na chyby a pomáhá předcházet možným pádům programu, jako je dělení nulou, nepovolený přístup mimo meze pole a chyby přetečení dat. Lze ho také použít jako brzdu, která program v libovolném okamžiku zastaví, abyste viděli, jaké hodnoty proměnné skutečně mají. Běh programu lze zastavit a posouvat krok za krokem, a tak najít případné chyby či podivné chování. To může být velmi užitečné zejména tehdy, když program upadne do nekonečného cyklu nebo si nejste jisti, jakou hodnotu určitá proměnná v daném okamžiku obsahuje.
Debugger lze kdykoli zapnout a vypnout stisknutím tlačítka ‘Enable Debugger’ (zapnout debugger) na panelu nástrojů nebo zvolením příkazu nabídky (Menu:Debugger->Enable Debugger). Při vývoji programu s vypnutým debuggerem buďte opatrní – pokud problém není rozpoznán a nechá se proběhnout, můžete svůj počítač shodit.
Poznámka ke struktuře programu
Struktura programu v PureBasicu je docela snadno pochopitelná. Kompilátor zpracovává textový soubor odshora dolů. Tak jednoduché to je. Příkazy zapsané v horní části souboru se zpracují dříve než ty zapsané pod nimi, přesně jako byste soubor četli sami. Pokud debugger narazí na problém, kompilace se zastaví a ohlásí se chyba. Vezměme si jako příklad tento pseudokód:
1 PRINT "THIS LINE IS EXECUTED FIRST"
2 PRINT "THIS LINE IS EXECUTED SECOND"
3 PRINT "THIS LINE IS EXECUTED THIRD"
Výstupem tohoto příkladu v pseudokódu by byly tři řádky textu zobrazené v pořadí, v jakém byly zapsány (1–3). Přesně takto kompilátor textový soubor zpracovává. Je důležité tomu porozumět a zapamatovat si to, protože jinak narazíte na chyby, například když se pokusíte přistupovat k souboru, který ještě nebyl otevřen. To vše se zdá docela samozřejmé, ale možná na to někdy narazíte, zvlášť až začnete používat procedury (ty budou podrobně vysvětleny v kapitole 6). Struktura programu zahrnuje víc než jen tento malý úryvek, ale to vyjde najevo během vaší další cesty, až budu podrobněji rozebírat používání příkazů a procedur.
Seznámení s nápovědou PureBasicu
S každou instalací PureBasicu se nainstaluje i kompletní nápověda (soubor nápovědy). Tato nápověda je fantastickou referenční příručkou k celému jazyku PureBasic, ale pro nové uživatele může být trochu odrazující, protože některé věci nejsou vysvětleny úplně. Kdyby byly, byl by to velmi rozsáhlý dokument, který by se navíc špatně tiskl. I tak je ale neocenitelným zdrojem pro vyhledávání klíčových slov a kontrolu syntaxe a pěkně se integruje s IDE. Kdykoli osobně vytvářím program v IDE PureBasicu, rád mám nápovědu neustále otevřenou, abych mezi nimi mohl rychle přepínat. Tento jednoduchý zvyk vám může ušetřit hodiny drahocenného času.
Integrace s IDE
Kdykoli při tvorbě programu v IDE můžete stisknout na klávesnici klávesu ‘F1’, čímž spustíte nápovědu PureBasicu. Pokud navíc při stisku ‘F1’ stojí kurzor v IDE na některém klíčovém slově PureBasicu, nápověda se přenese do popředí a toto klíčové slovo v ní bude zvýrazněno, takže dostanete vysvětlení daného příkazu. Tato integrace IDE s nápovědou je neocenitelná, jakmile začnete programovat rychleji.
Vyzkoušejme si to na malém příkladu – napište do IDE (přesně) toto:
OpenConsole()
Print("Press enter to exit")
Input()
End
Po spuštění tento malý program otevře okno konzole a vypíše do něj řádek textu, který uživatele informuje, že pro ukončení musí stisknout ‘enter’; mezitím čekáme na vstup. Po stisknutí klávesy Enter program úhledně ukončíme.
Pokud umístíte blikající kurzor IDE na kterékoli klíčové slovo použité v tomto programu a stisknete ‘F1’, nápověda se přenese do popředí a otevře se na stránce, která daný příkaz popisuje. Umístěte například blikající kurzor kamkoli do klíčového slova ‘OpenConsole()’ a stiskněte ‘F1’. Jako mávnutím kouzelného proutku se objeví stránka nápovědy k ‘OpenConsole()’!
Chcete-li se dozvědět více o používání vestavěné nápovědy PureBasicu, nahlédněte do kapitoly 7 (Používání nápovědy PureBasicu).
2Datové typy
Úvod máme za sebou, a tak můžeme tuto kapitolu začít něčím podstatnějším, totiž datovými typy. Jak možná víte, počítačové programy pracují s daty a zpracovávají je. Datové typy jsou popisy „nádob“, v nichž jsou tato data uložena. V této kapitole vám ukážu všechny dostupné vestavěné datové typy a podrobně vysvětlím, jak a kdy je používat.
Abyste se co nejrychleji pustili do práce, zařadil jsem do kapitoly spoustu příkladů a vše vysvětluji srozumitelnou, obyčejnou řečí.
Vestavěné datové typy
Na datové typy (někdy se jim říká jen „typy“) se můžete dívat jako na způsob, jak uloženým datům přidělit popis. Základní myšlenkou typování dat je dát nějaký užitečný význam něčemu, co je nakonec jen řada binárních číslic. Ať jde o text, nebo o čísla, popis dat pomocí typů usnadňuje jejich pochopení, zpracování i získávání. Data jsou uložena v operační paměti (RAM) počítače, dokud je program nepotřebuje. Kolik paměti RAM zabírá uložení jednotlivých dat, závisí na tom, jaký datový typ se použije.
Čísla
Prvními datovými typy, které si představíme, jsou typy číselné. Čísla můžete použít k uložení čehokoli od data přes délku až po výsledek zdlouhavého výpočtu. Cokoli, k čemu ve skutečném světě používáte čísla, můžete uložit i do číselných typů PureBasicu.
Čísla mají v PureBasicu dvě podoby: celá čísla a čísla s plovoucí desetinnou čárkou. Celá čísla jsou čísla bez desetinné čárky a mohou být kladná i záporná. Zde je několik příkladů celých čísel:
16543 -1951434 100 -1066 0
Čísla s plovoucí desetinnou čárkou (neboli „floaty“) jsou naproti tomu čísla, která desetinnou čárku obsahují, a rovněž mohou být kladná i záporná. Zde je několik příkladů čísel s plovoucí desetinnou čárkou:
52.887 -11.0005 1668468.1 -0.000004 0.0
PureBasic vám pro programování nabízí sedm číselných datových typů; každý z nich zabírá jiné množství paměti RAM a všechny mají různé číselné rozsahy. Číselné typy jsou popsány na obr. 2.
| Typ | Přípona | Využití paměti (RAM) | Číselný rozsah |
|---|---|---|---|
Byte |
.b |
1 bajt (8 bitů) |
-128 až 127 |
Char (Ascii) |
.c |
1 bajt (8 bitů) |
0 až 255 |
Char (Unicode) |
.c |
2 bajty (16 bitů) |
0 až 65535 |
Word |
.w |
2 bajty (16 bitů) |
-32768 až 32767 |
Long |
.l |
4 bajty (32 bitů) |
-2147483648 až 2147483647 |
Quad |
.q |
8 bajtů (64 bitů) |
-9223372036854775808 až 9223372036854775807 |
Float |
.f |
4 bajty (32 bitů) |
Neomezený* |
Double |
.d |
8 bajtů (64 bitů) |
Neomezený* |
Obr. 2: Číselné typy PureBasicu — * Podrobně to bude vysvětleno v kapitole 13 (Podrobněji o číselných datových typech).
Číselné rozsahy
Na obr. 2 vidíte, že mnoho typů má omezený číselný rozsah, což přímo souvisí s množstvím paměti RAM, které je danému typu přiděleno. Velikost přidělené paměti i názvy číselných typů jsou víceméně stejné jako v jazyce C. V C sice najdete mnohem více typů, než je uvedeno zde, ale PureBasic se snaží o jednoduchost, ne o to, aby vám stovky pokročilých typů motaly hlavu. Začátečníkovi stačí zapamatovat si číselné rozsahy jednotlivých typů a pochopit, že je nelze překročit. Abych vysvětlil, proč paměť přidělená jednotlivým typům ovlivňuje jejich číselný rozsah, musel bych popsat, jak se čísla ukládají do paměti RAM ve dvojkové soustavě; to najdete v kapitole 13 (Podrobněji o číselných datových typech).
Pokud hodnota překročí rozsah číselného datového typu, „přeteče“ a pokračuje od jeho dolní hranice. Pokud například přiřadíte proměnné typu Byte hodnotu ‘129’, překročí tato hodnota číselný rozsah typu Byte a přeteče na ‘-127’.
Řetězce
Posledním standardním datovým typem PureBasicu je řetězec (String). Řetězce jsou tak důležitým a užitečným datovým typem, že je implementuje téměř každý existující programovací jazyk.
Jak už název napovídá, řetězce jsou jednoduše řetězce znaků. Na rozdíl od čísla se řetězec musí zapsat určitým způsobem, aby byl jako řetězec rozpoznán. Tím způsobem je uzavření řetězce do dvojitých uvozovek. Zde je několik příkladů této syntaxe:
"abcdefghijklmnopqrstuvwxyz" "Mary had a little lamb" "123456789"
Všimněte si, že poslední z těchto tří řetězců je tvořen číslicemi. Díky dvojitým uvozovkám kolem něj je však rozpoznán jako řetězec, nikoli jako číslo. Takto definovaným řetězcům se také říká literální řetězce.
Řetězce jsou pravděpodobně nejsnáze pochopitelným datovým typem, protože se s nimi velmi snadno pracuje. Stačí nezapomenout na dvojité uvozovky kolem znaků a máte řetězec.
| Typ | Přípona | Využití paměti (RAM) | Omezení počtu znaků |
|---|---|---|---|
String |
.s |
4 bajty (32 bitů) |
Neomezeno |
String |
$ |
4 bajty (32 bitů) |
Neomezeno |
Řetězec pevné délky |
.s{ length } |
4 bajty (32 bitů) |
Určuje uživatel* |
Řetězec pevné délky |
${ length } |
4 bajty (32 bitů) |
Určuje uživatel* |
Obr. 3: Řetězcové typy PureBasicu — * Parametr ‘length’ určuje maximální délku řetězce.
Řetězce se mohou skládat z libovolných znaků znakové sady ASCII včetně řídicích znaků (úplný seznam znaků ASCII najdete v příloze B (Užitečné tabulky)) s výjimkou znaku null, protože ten označuje konec řetězce. Řetězcům, jejichž konec je vyznačen znakem null, se říká „řetězce ukončené nulou“.
Proměnné a konstanty
Abyste mohli v programu ukládat a zpracovávat data, musíte k jejich uložení použít správný datový typ, ale potřebujete také způsob, jak tato data v paměti snadno najít. Proměnné a konstanty tento problém jednoduše řeší: přiřazují určitému kousku dat jasný, popisný název, aby se k nim dalo později snadno přistupovat. Zjednodušeně řečeno, proměnné odkazují na data, jejichž hodnota se může měnit, kdežto konstanty na data, která se nikdy a za žádných okolností nezmění.
Proměnné
Název proměnné je obvykle svázán s určitou oblastí paměti RAM o určité velikosti (dané jejím datovým typem) a veškeré operace s proměnnou pracují s touto přidruženou oblastí paměti. Proměnné můžete pojmenovat, jak chcete, ale mnoho lidí dává přednost co nejvýstižnějším názvům, z nichž je patrné, jakou hodnotu proměnná ve skutečnosti obsahuje. Proměnné jsou stavebními kameny každého počítačového programu, protože uchovávají data, se kterými lze pracovat, na která lze odkazovat a která lze nakonec zobrazit. Pro uspořádání a ukládání dat jsou proměnné nezbytné.
Dobře, pojďme si s PureBasicem trochu pohrát. Otevřete IDE PureBasicu a vytvořme si vlastní proměnnou. Syntaxe pro vytvoření proměnné je velmi jednoduchá. Napíšete název proměnné, za něj příponu typu, která určí, jakého typu proměnná bude, a za ni operaci, kterou s ní chcete provést. Touto operací je především přiřazení hodnoty.
V následujícím příkazu přiřazujeme názvu ‘NumberOfLinesOfCode’ hodnotu ‘1’ pomocí operátoru rovná se (=), přičemž jako datový typ používáme Byte.
NumberOfLinesOfCode.b = 1
Podívejte se na tento příkaz trochu blíže. Uvidíte, že název proměnné neobsahuje mezery, a to je velmi důležité. Žádná proměnná nikdy neobsahuje mezery! Pokud potřebujete slova v názvu proměnné oddělit, aby se lépe četla, můžete použít podtržítka, například takto:
Number_Of_Lines_Of_Code.b = 1
Proměnnou můžete pojmenovat libovolně, platí však několik pravidel. Názvy proměnných nesmějí začínat číslicí a nesmějí obsahovat žádné operátory (úplný seznam operátorů najdete na obr. 15). Nejsou povoleny ani speciální znaky, jako jsou znaky s diakritikou (ß, ä, ö, ü). Přípona ‘.b’ připojená na konec názvu proměnné sděluje kompilátoru, že tato proměnná bude typu Byte, a bude tedy zabírat odpovídající množství paměti a podléhat odpovídajícímu číselnému rozsahu. Na obr. 2 jsou uvedeny všechny přípony, které potřebujete pro číselné typy, a na obr. 3 přípony potřebné pro řetězcové typy. Pokud příponu typu nepoužijete, například takto:
NumberOfLinesOfCode = 1
je proměnná deklarována jako Long, protože to je výchozí typ PureBasicu. Je důležité to vědět, protože když u proměnné zapomenete příponu, vytvoříte proměnnou typu Long, což může vést k chybám. PureBasic umožňuje výchozí typ změnit pomocí klíčového slova ‘Define’, a to takto:
Define.b
NumberOfLinesOfCode = 1
TodaysDate = 11
Klíčové slovo ‘Define’ dostane vlastní příponu a každá proměnná uvedená za ním je deklarována jako proměnná tohoto nově určeného typu. Obě výše uvedené proměnné jsou například deklarovány jako Byte, protože klíčové slovo ‘Define’ má na konci příponu ‘.b’. Pokud toto klíčové slovo v programu nepoužijete, zůstává výchozím typem Long.
Chcete-li deklarovat několik proměnných pro pozdější použití, ale zatím jim nechcete přiřadit hodnotu, můžete použít i tuto syntaxi:
Define.w Day, Month, Year
Tento kód přepne výchozí typ na Word a deklaruje tři proměnné ‘Day’, ‘Month’ a ‘Year’ jako Word, a protože jim nebyla přiřazena žádná hodnota, dostanou hodnotu nula (0). Zde je příklad, který v kódu PureBasicu ukazuje vytvoření proměnných všech typů:
ByteVariable.b = 123
CharVariable.c = 222
WordVariable.w = 4567
LongVariable.l = 891011
QuadVariable.q = 9223372036854775807
FloatVariable.f = 3.1415927
DoubleVariable.d = 12.53456776674545
StringVariableOne.s = "Test String One"
StringVariableTwo$ = "Test String Two"
StringVariableThree.s{6} = "abcdef"
StringVariableFour${3} = "abc"
Všimněte si, že poslední čtyři proměnné jsou řetězce, ale každá je definována trochu jinou příponou. První dvě jsou řetězce neomezené délky, zatímco poslední dvě jsou definovány jako řetězce pevné délky. Každý z těchto typů lze definovat pomocí dvou přípon. Těmito dvěma příponami jsou ‘.s’ a ‘$’. Obě jsou ve všech ohledech totožné, jen přípona ‘$’ je starší styl, zachovaný kvůli puristům Basicu, kteří mají rádi starou řetězcovou příponu. V jednom programu lze používat obě, ale tyto dvě přípony nejsou vzájemně zaměnitelné. Například tyto dvě proměnné jsou různé:
StringVariable.s = "Test String One"
StringVariable$ = "Test String Two"
I když mají stejný název, kvůli odlišným příponám jde o dvě zcela různé proměnné. Nevěříte? Můžete si to vyzkoušet pomocí klíčového slova ‘Debug’.
StringVariable.s = "Test String One"
StringVariable$ = "Test String Two"
Debug StringVariable.s
Debug StringVariable$
V tomto příkladu se klíčové slovo ‘Debug’ používá k vypsání hodnot obou proměnných do okna Debug Output (výstup ladění). Napište tento příklad do IDE a stiskněte tlačítko ‘Compile/Run’ (F5). V okně Debug Output se objeví dva řádky s hodnotami obou proměnných, které jsme předali příkazu ‘Debug’. Toto klíčové slovo je pravděpodobně nejpoužívanějším klíčovým slovem celého jazyka PureBasic, protože během vývoje programu slouží k testování hodnot a k vypisování dalšího užitečného textu do okna Debug Output. Při vytváření výsledného spustitelného souboru se všechny příkazy ‘Debug’ z programu odstraní, takže spustitelný soubor zůstane malý.
U proměnných je třeba si všimnout ještě jedné věci: nerozlišují velikost písmen. To znamená, že na velkých a malých písmenech nezáleží, což je pro jazyk Basic standardní chování. Podívejte se na tento příklad:
TestVariable.s = "Test String One"
testvariable = "Test String Two"
TeStVaRiAbLe = "Test String Three"
Debug tEsTvArIaBlE
Zdá se, že zde přiřazuji hodnoty třem různým proměnným, ve skutečnosti však opakovaně přiřazuji hodnotu téže proměnné, jen pokaždé píšu její název s jinou velikostí písmen. Jak vidíte, velikost písmen nemá pro proměnnou žádný význam, protože tento příklad vypíše text ‘Test String Three’. Tento příklad také ukazuje další vlastnost proměnných v PureBasicu: jakmile je proměnná deklarována s určitým datovým typem, zůstane jí tento datový typ přiřazen po celou dobu běhu programu. Jakmile je například proměnná deklarována jako řetězec, nemůžete do ní už nikdy uložit celé číslo ani číslo s plovoucí desetinnou čárkou. Ukážu vám špatný příklad:
StringVariable.s = "Test String One"
StringVariable = 100
Tento příklad se nikdy nezkompiluje, a pokud se o to pokusíte, dostanete od IDE zdvořilou zprávu, že do řetězcové proměnné nelze zapsat číselnou hodnotu. Následující příklad bude fungovat:
StringVariable.s = "Test String One"
StringVariable = "One Hundred"
Protože proměnná ‘StringVariable’ byla původně deklarována jako řetězec, lze jí od té doby přiřazovat jako hodnoty pouze řetězce. Když její hodnotu změníme na ‘One Hundred’, funguje vše bez problémů, protože měníme řetězec za řetězec. Shrňme si tedy hlavní pravidla pro proměnné.
1) Proměnné nesmějí obsahovat mezery. 2) Názvy proměnných nesmějí začínat číslicí, ale mohou číslice obsahovat. 3) Názvy proměnných nesmějí obsahovat žádné operátory (viz obr. 15). 4) Názvy proměnných nesmějí obsahovat žádné speciální znaky ani znaky s diakritikou (ß, ä, ö, ü). 5) Pokud proměnná nemá příponu, je jejím výchozím datovým typem Long. 6) Jakmile je proměnná deklarována, její datový typ nelze za běhu programu nikdy změnit. 7) Jakmile je proměnná deklarována, můžete ji volně používat bez přípony, kompilátor si její typ pamatuje.
Konstanty
Konstanty se podobají proměnným v tom, že poskytují snadný způsob, jak odkazovat na data, a mohou se jmenovat, jak chcete, tím však podobnost končí. Konstanty se používají, když chcete určitému kousku dat dát název a víte, že se jeho hodnota nikdy nezmění. Podívejte se na tento příklad:
#DAYS_IN_THE_YEAR = "365"
Víme, že počet dní v běžném roce se nikdy nezmění, a proto jej můžeme vyjádřit konstantou. Kdybychom se pokusili změnit její hodnotu jako u proměnné, dostali bychom chybu. IDE si postěžuje, že konstanta s tímto názvem již byla deklarována, a kompilaci zastaví.
Na konstantách je dobré, že nezabírají žádnou paměť, protože se jako takové nikdy nekompilují — před kompilací jsou v kódu nahrazeny svými počátečními hodnotami. Podívejte se na tento příklad:
#DAYS_IN_THE_YEAR = "365"
Debug "There are " + #DAYS_IN_THE_YEAR + " days in the year."
Než se tento příklad zkompiluje do programu, vypadá pro kompilátor ve skutečnosti takto:
Debug "There are 365 days in the year."
protože konstanta je nahrazena hodnotou, která jí byla přiřazena, v tomto případě ‘365’, a teprve pak se kód zkompiluje.
Pro všechny konstanty platí naprosto stejná pravidla pojmenování jako pro proměnné, s výjimkou přípon: konstanty je nepoužívají bez ohledu na to, jaký typ dat jim přiřadíte, protože pro ně není třeba přidělovat paměť. Všechny konstanty se deklarují pomocí předpony, nikoli přípony. Touto předponou je znak mřížky (#).
Výčty konstant
Pokud potřebujete blok konstant, kterým jsou přiřazeny číselné hodnoty postupně jedna za druhou, můžete použít klíčové slovo ‘Enumeration’.
Enumeration
#ZERO
#ONE
#TWO
#THREE
EndEnumeration
Debug #ZERO
Debug #ONE
Debug #TWO
Debug #THREE
V okně Debug Output uvidíte, že každá konstanta má hodnotu o jedna vyšší než ta předchozí, počínaje ‘0’. Pokud chcete výčet začít jiným číslem než ‘0’, můžete u klíčového slova ‘Enumeration’ použít nepovinný číselný parametr, například takto:
Enumeration 10
#TEN
#ELEVEN
#TWELVE
EndEnumeration
Debug #TEN
Debug #ELEVEN
Debug #TWELVE
Nyní vidíte, že konstanta ‘#TEN’ má hodnotu ‘10’ a od ní se hodnoty ostatních zvyšují. Za číselný parametr můžete dokonce přidat klíčové slovo ‘Step’, kterým změníte přírůstek uvnitř bloku výčtu. Podívejte se na tento příklad:
Enumeration 10 Step 5
#TEN
#FIFTEEN
#TWENTY
EndEnumeration
Debug #TEN
Debug #FIFTEEN
Debug #TWENTY
Nyní se hodnoty konstant zvyšují o ‘5’, počínaje ‘10’.
Pokud kdykoli uvnitř bloku výčtu přiřadíte konstantě hodnotu, nastavíte tím novou hodnotu, od níž bude výčet pokračovat. Například takto:
Enumeration 5
#FIVE
#ONE_HUNDRED = 100
#ONE_HUNDRED_AND_ONE
#ONE_HUNDRED_AND_TWO
EndEnumeration
Debug #FIVE
Debug #ONE_HUNDRED
Debug #ONE_HUNDRED_AND_ONE
Debug #ONE_HUNDRED_AND_TWO
Zde vidíte, že po řádku ‘#ONE_HUNDRED = 100’ jsou všechny další konstanty číslovány od ‘100’.
Výčty konstant se nejčastěji používají při programování grafických uživatelských rozhraní (viz kapitola 9), kde každé okno nebo gadget (ovládací prvek) potřebuje vlastní ID. Výčty konstant jsou skvělým způsobem, jak tato ID zajistit, a bloky výčtu vám ušetří veškerou námahu s přiřazováním postupně se zvyšujících hodnot velkému počtu konstant.
3Operátory
Operátory slouží k přiřazování hodnot proměnným a ke zpracování dat, která tyto proměnné obsahují. V této kapitole vám představím všechny operátory, které PureBasic podporuje, a ke každému uvedu krátký příklad popisující jeho funkci a použití. Najdete zde také řadu diagramů, které ukazují, jak pokročilejší operátory pracují s daty na binární úrovni. Vysvětlím i prioritu (přednost) operátorů a upozorním vás na některé zvláštnosti vyhodnocování výrazů v PureBasicu.
Úvod do operátorů
Operátory jsou sada funkcí, které umějí provádět aritmetické operace s číselnými daty, booleovské operace s pravdivostními hodnotami a řetězcové operace pro práci s textovými řetězci. Některé operátory se označují jako přetížené operátory, což znamená, že je lze použít na více než jeden typ dat a mohou plnit různé funkce. Například operátor rovná se (=) lze použít k přiřazení hodnoty proměnné i jako operátor rovnosti, který zjišťuje, zda se dvě proměnné nebo hodnoty rovnají.
= (rovná se)
Toto je pravděpodobně nejsnáze vysvětlitelný operátor, přestože jej lze použít dvěma způsoby. Zaprvé jím lze přiřadit hodnotu proměnné, a to takto:
LongVariable.l = 1
Zadruhé jím lze porovnat dva výrazy, proměnné nebo hodnoty na rovnost, například takto:
LongVariable.l = 1
If LongVariable = 1
Debug "Yes, LongVariable does equal 1"
EndIf
S klíčovým slovem ‘If’ se zde setkáváte poprvé, ale nemějte obavy. Toto klíčové slovo umožňuje ve vašich programech provést kód v závislosti na tom, zda je splněna určitá podmínka. V tomto případě platí: pokud se ‘LongVariable’ rovná ‘1’, vypíše se do okna Debug Output (výstup ladění) nějaký text.
+ (plus)
Operátor plus je další často používaný operátor a slouží ke spojování (zřetězení) řetězců i ke sčítání čísel. Nejprve příklad sčítání čísel:
NumberOne.l = 50
NumberTwo.l = 25
NumberThree.l = NumberOne + NumberTwo
Debug NumberThree
Číslo vypsané do okna Debug Output by mělo být ‘75’, protože jsme hodnotu ‘NumberOne’ sečetli s ‘NumberTwo’ (50+25), výslednou hodnotu (75) uložili do proměnné ‘NumberThree’ a tu pak vypsali do okna Debug Output. Totéž lze zapsat i takto:
NumberOne.l = 50 + 25
Debug NumberOne
Pokud potřebujete číselnou proměnnou jen zvětšit o jinou hodnotu nebo výraz, můžete při použití operátoru plus s čísly využít zkrácený zápis:
NumberOne.l = 50
NumberOne + 25
Debug NumberOne
Jakmile je proměnné ‘NumberOne’ přiřazena počáteční hodnota, můžeme k ní pomocí operátoru plus přičíst další hodnotu, takže do okna Debug Output se nyní vypíše číslo ‘75’.
Zde je příklad spojování řetězců pomocí operátoru plus:
StringOne.s = "Mary had a"
StringTwo.s = " little lamb"
StringThree.s = StringOne + StringTwo
Debug StringThree
Slovo zřetězit v podstatě znamená spojit do řetězu, a přesně to s těmito dvěma řetězci děláme. Spojíme ‘StringOne’ a ‘StringTwo’, výsledný řetězec uložíme do ‘StringThree’ a tuto hodnotu pak vypíšeme do okna Debug Output. Jiný způsob vypadá takto:
StringOne.s = "Mary had a" + " little lamb"
Debug StringOne
Pokud potřebujete k existující proměnné jen připojit text, můžete zkrácený zápis použít i u operátoru plus s řetězci:
StringOne.s = "Mary had a"
StringOne + " little lamb"
Debug StringOne
Funguje to podobně jako zkrácený zápis u čísel, jen se místo číselného sečtení druhý řetězec připojí k existující řetězcové proměnné.
- (minus)
Operátor minus funguje přesně opačně než operátor sčítání: místo sčítání odečítá. Na rozdíl od operátoru sčítání neumí operátor minus pracovat s řetězci. Zde je příklad operátoru minus v akci:
NumberOne.l = 50
NumberTwo.l = 25
NumberThree.l = NumberOne - NumberTwo
Debug NumberThree
Do okna Debug Output by se měl vypsat text ‘25’, což je ‘NumberOne’ zmenšené o ‘NumberTwo’. I zde lze použít zkrácený zápis, pokud potřebujete proměnnou zmenšit o určitou hodnotu:
NumberOne.l = 50
NumberOne - 10
Debug NumberOne
Zde se proměnné ‘NumberOne’ přiřadí hodnota ‘50’ a pak se ‘NumberOne’ pomocí operátoru minus zmenší o ‘10’. Nová hodnota ‘NumberOne’ (40) se pak vypíše do okna Debug Output.
* (násobení)
Operátor násobení slouží k vynásobení dvou hodnot a stejně jako operátor minus neumí pracovat s řetězci. Použití tohoto operátoru předvádí následující příklad:
NumberOne.l = 5
NumberTwo.l = 25
NumberThree.l = NumberOne * NumberTwo
Debug NumberThree
Ladicí výstup by měl být ‘125’, protože v tomto příkladu jsme vynásobili ‘NumberOne’ hodnotou ‘NumberTwo’ (5*25=125). I zde lze použít zkrácený zápis pro vynásobení proměnné zadaným číslem.
NumberOne.l = 50
NumberOne * 3
Debug NumberOne
Zde se proměnné ‘NumberOne’ přiřadí hodnota ‘50’ a pak se ‘NumberOne’ pomocí operátoru násobení vynásobí ‘3’. Nová hodnota ‘NumberOne’ (150) se pak vypíše do okna Debug Output.
/ (dělení)
Operátor dělení je další matematický operátor, který funguje jen s čísly, nikoli s řetězci. Z předchozích příkladů jste pravděpodobně už odhadli, jak se používá, ale přesto uvádím příklad jeho použití:
NumberOne.l = 100
NumberTwo.l = 2
NumberThree.l = NumberOne / NumberTwo
Debug NumberThree
Zde se proměnné ‘NumberOne’ přiřadí hodnota ‘100’ a proměnné ‘NumberTwo’ hodnota ‘2’. Pak vydělíme ‘NumberOne’ (100) hodnotou ‘NumberTwo’ (2) a výsledek (50) uložíme do ‘NumberThree’. Hodnotu ‘NumberThree’ pak vypíšeme do okna Debug Output. Stejně jako dříve lze použít zkrácený zápis pro vydělení proměnné zadaným číslem:
NumberOne.l = 50
NumberOne / 5
Debug NumberOne
Zde se proměnné ‘NumberOne’ přiřadí hodnota ‘50’ a pak tuto hodnotu pomocí operátoru dělení vydělíme ‘5’. Výsledek uložený v ‘NumberOne’ (10) pak vypíšeme do okna Debug Output.
& (bitové AND)
Bitové operátory jsou skupinou operátorů, které pracují s čísly na binární úrovni. Pokud se v binární soustavě a ve způsobu, jakým PureBasic čísla binárně ukládá, příliš nevyznáte, nahlédněte do kapitoly 13 (Podrobněji o číselných datových typech), kde je vše podrobně vysvětleno. Bitové operátory nelze používat s čísly typu float ani s řetězci.
Bitový operátor ‘&’ zkoumá dvě hodnoty bit po bitu a zjišťuje, zda jsou oba bity pravdivé. Pokud jsou při porovnání oba bity pravdivé (1), vrátí operátor pravdu (1), jinak vrátí nepravdu (0). To platí pro všechny bity obou porovnávaných čísel. Pro lepší vysvětlení zde uvádím diagram.

Obr. 4: Operátor ‘&’ (bitové AND) &
Na obr. 4 vidíte, že čísla, která se vyhodnocují operátorem ‘&’, jsou ‘77’ a ‘117’. Po dokončení výpočtu dostaneme výsledek ‘69’. Abyste pochopili, jak se k této hodnotě dospěje, musíte procházet jednotlivé sloupce bitů shora dolů. Podíváte-li se na sloupec zcela vpravo (to je sloupec odpovídající ve dvojkové soustavě hodnotě ‘1’), jsou oba bity obou čísel v tomto sloupci nastaveny na ‘1’, takže operátor ‘&’ vrátí hodnotu ‘1’ (což je v PureBasicu pravda). Posuneme-li se o sloupec doleva, vidíme, že oba bity obou čísel jsou ‘0’, takže operátor ‘&’ vrátí ‘0’ (nepravda). Pamatujte, že při použití operátoru ‘&’ musí být oba bity ‘1’, aby operátor vrátil ‘1’, jinak vrátí ‘0’.
Tento operátor se uplatní na všechny sloupce bitů zprava doleva a po dokončení se vrátí výsledné číslo. V tomto případě je hodnotou vrácenou tímto výpočtem ‘69’. Zde je příklad, který převádí obr. 4 do kódu:
NumberOne.b = 77
NumberTwo.b = 117
NumberThree.b = NumberOne & NumberTwo
Debug NumberThree
V tomto malém příkladu se dvěma proměnným přiřadí čísla, která se mají vyhodnotit operátorem ‘&’, a proměnná ‘NumberThree’ obsahuje výsledek tohoto výpočtu. Hodnota ‘NumberThree’ se pak vypíše do okna Debug Output; v tomto případě by to mělo být ‘69’. Stejně jako ostatní operátory má i bitový operátor ‘&’ zkrácený zápis pro případ, kdy potřebujete na jedinou proměnnou použít ‘&’ s nějakým číslem:
NumberOne.b = 77
NumberOne & 117
Debug NumberOne
Zde se proměnné ‘NumberOne’ přiřadí hodnota ‘77’ a na dalším řádku na ‘NumberOne’ použijeme ‘&’ s hodnotou ‘117’. Tato hodnota se pak vypíše do okna Debug Output.
Obr. 5 ukazuje porovnání dvou bitů a výsledek, který vrací operátor ‘&’.
| Levá strana | Pravá strana | Výsledek |
|---|---|---|
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
0 |
1 |
1 |
1 |
Obr. 5: Porovnání bitů operátorem ‘&’ (bitové AND)
| (bitové OR)
Bitový operátor ‘|’ zkoumá dvě hodnoty bit po bitu a zjišťuje, zda je alespoň jedna z nich pravdivá. Pokud je při porovnání dvou bitů jeden z nich nebo oba pravdivé (1), vrátí operátor pravdu (1), jinak vrátí nepravdu (0). To platí pro všechny bity obou porovnávaných čísel.

Obr. 6: Operátor ‘|’ (bitové OR) |
Na obr. 6 vidíte, že čísla, která se vyhodnocují operátorem ‘|’, jsou ‘54’ a ‘102’. Po dokončení výpočtu dostaneme výsledek ‘118’. Abyste pochopili, jak se k této hodnotě dospěje, musíte procházet jednotlivé sloupce bitů shora dolů. Podíváte-li se na sloupec zcela vpravo (to je sloupec odpovídající ve dvojkové soustavě hodnotě ‘1’), jsou oba bity obou čísel v tomto sloupci nastaveny na ‘0’, takže operátor ‘|’ vrátí hodnotu ‘0’ (nepravda). Posuneme-li se o sloupec doleva, vidíme, že oba bity obou čísel jsou ‘1’, takže operátor ‘|’ vrátí ‘1’ (pravda). Podíváte-li se na pátý sloupec zprava, uvidíte, že první číslo má bit nastavený na ‘1’ a druhé číslo bit nastavený na ‘0’. V tomto případě operátor ‘|’ přesto vrátí ‘1’ (pravda), protože stačí, aby byl pravdivý jeden či druhý bit, a operátor vrátí pravdu. Operátor ‘|’ vrátí pravdu vždy, pokud nejsou oba bity ‘0’.
Tento operátor se uplatní na všechny sloupce bitů na obr. 6 zprava doleva a po dokončení se vrátí výsledné číslo. V tomto případě je hodnotou vrácenou tímto výpočtem ‘118’. Zde je příklad, který převádí obr. 6 do kódu:
NumberOne.b = 54
NumberTwo.b = 102
NumberThree.b = NumberOne & NumberTwo
Debug NumberThree
V tomto malém příkladu se dvěma proměnným přiřadí čísla, která se mají vyhodnotit operátorem ‘|’, a proměnná ‘NumberThree’ obsahuje výsledek tohoto výpočtu. Hodnota ‘NumberThree’ se pak vypíše do okna Debug Output; v tomto případě by to mělo být ‘118’. Stejně jako ostatní operátory lze i bitový operátor ‘|’ použít ve zkráceném zápisu, pokud potřebujete na jedinou proměnnou použít ‘|’ s nějakým číslem:
NumberOne.b = 54
NumberOne | 102
Debug NumberOne
Zde se proměnné ‘NumberOne’ přiřadí hodnota ‘54’ a na dalším řádku na ‘NumberOne’ použijeme ‘|’ s hodnotou ‘102’. Tato hodnota se pak vypíše do okna Debug Output.
Obr. 7 ukazuje porovnání dvou bitů a výsledek, který vrací operátor ‘|’.
| Levá strana | Pravá strana | Výsledek |
|---|---|---|
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
1 |
Obr. 7: Porovnání bitů operátorem ‘|’ (bitové OR)
! (bitové XOR)
Bitový operátor ‘!’ zkoumá dvě hodnoty bit po bitu a zjišťuje, zda je pravdivá právě jedna z nich. Pokud je při porovnání dvou bitů pravdivý (1) jen jeden z nich, vrátí operátor pravdu (1), jinak vrátí nepravdu (0). To platí pro všechny bity obou porovnávaných čísel. Pro lepší vysvětlení zde uvádím diagram:

Obr. 8: Operátor ‘!’ (bitové XOR) !
Na obr. 8 vidíte, že čísla, která se vyhodnocují operátorem ‘!’, jsou ‘38’ a ‘74’. Po dokončení výpočtu dostaneme výsledek ‘108’. Abyste pochopili, jak se k této hodnotě dospěje, musíte opět procházet jednotlivé sloupce bitů shora dolů. Podíváte-li se na sloupec zcela vpravo (to je sloupec odpovídající ve dvojkové soustavě hodnotě ‘1’), jsou oba bity obou čísel v tomto sloupci nastaveny na ‘0’, takže operátor ‘!’ vrátí hodnotu ‘0’ (nepravda). Posuneme-li se o sloupec doleva, vidíme, že oba bity obou čísel jsou ‘1’, takže operátor ‘!’ opět vrátí ‘0’ (nepravda). Je to proto, že operátor ‘!’ při porovnání dvou bitů vrátí ‘1’ (pravda) jen tehdy, je-li na ‘1’ nastaven pouze jeden z nich. Jsou-li oba bity nastaveny na ‘1’ nebo oba na ‘0’, vrátí operátor ‘!’ hodnotu ‘0’ (nepravda).
Tento operátor se uplatní na všechny sloupce bitů na obr. 8 zprava doleva a po dokončení se vrátí výsledné číslo. V tomto případě je hodnotou vrácenou tímto výpočtem ‘108’. Zde je příklad, který převádí obr. 8 do kódu:
NumberOne.b = 38
NumberTwo.b = 74
NumberThree.b = NumberOne ! NumberTwo
Debug NumberThree
V tomto malém příkladu se dvěma proměnným přiřadí čísla, která se mají vyhodnotit operátorem ‘!’, a proměnná ‘NumberThree’ obsahuje výsledek tohoto výpočtu. Hodnota ‘NumberThree’ se pak vypíše do okna Debug Output; v tomto případě by to mělo být ‘108’.
Stejně jako ostatní operátory má i bitový operátor ‘!’ zkrácený zápis pro případ, kdy potřebujete na jedinou proměnnou použít ‘!’ s nějakým číslem:
NumberOne.b = 38
NumberOne ! 74
Debug NumberOne
Zde se proměnné ‘NumberOne’ přiřadí hodnota ‘38’ a na dalším řádku na ‘NumberOne’ použijeme ‘!’ s hodnotou ‘74’. Tato hodnota se pak vypíše do okna Debug Output.
Obr. 9 ukazuje porovnání dvou bitů a výsledek, který vrací operátor ‘!’:
| Levá strana | Pravá strana | Výsledek |
|---|---|---|
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
Obr. 9: Porovnání bitů operátorem ‘!’ (bitové XOR)
~ (bitové NOT)
Bitový operátor ‘~’ se vysvětluje snáze, protože jednoduše vrací číslo, jehož bity jsou oproti vstupnímu číslu či výrazu invertovány.
Bitový operátor ‘~’ patří mezi takzvané unární operátory, což znamená, že k vrácení hodnoty používá jedinou hodnotu nebo výraz. Ukazuje to tento kousek kódu:
NumberOne.b = 43
NumberTwo.b = ~NumberOne
Debug NumberTwo
Zde se proměnné ‘NumberOne’ přiřadí hodnota ‘43’, pak vytvoříme proměnnou ‘NumberTwo’ a přiřadíme jí hodnotu ‘NumberOne’ invertovanou na binární úrovni pomocí operátoru ‘~’. Tato hodnota (měla by to být ‘-44’) se pak vypíše do okna Debug Output.

Obr. 10: Operátor ‘~’ (bitové NOT) ~
Na obr. 10 vidíte, že operátor ‘~’ jednoduše invertuje bity zdrojového čísla a vrátí tuto novou hodnotu. Chcete-li lépe pochopit, jak jsou čísla v PureBasicu reprezentována ve dvojkové soustavě, zejména záporná čísla (čísla se znaménkem), přečtěte si kapitolu 13 (Podrobněji o číselných datových typech).
<< (bitový posun doleva)
Operátory bitového posunu se podobají bitovým operátorům v tom, že pracují s čísly na binární úrovni. Jak název napovídá, posouvají všechny bity doleva nebo doprava podle toho, který operátor použijete. Zde je kód, který předvádí použití operátoru ‘<<’:
NumberOne.b = 50
NumberTwo.b = NumberOne << 1
Debug NumberTwo
V tomto příkladu přiřadíme proměnné ‘NumberOne’ hodnotu ‘50’. Pak vytvoříme proměnnou ‘NumberTwo’ a přiřadíme jí hodnotu ‘NumberOne’ bitově posunutou o jedno místo doleva. Výsledná hodnota (měla by to být ‘100’) se pak vypíše do okna Debug Output. Funkci tohoto operátoru lépe pochopíte z obr. 11.
Jak vidíte, výsledná hodnota má jednoduše své binární číslice (bity) posunuty z původní pozice doleva, v tomto případě o jedno místo. Při takovém posunu bitů doleva se zprava doplňují nuly, které vyplní vzniklou mezeru, zatímco bity na levé straně „vypadnou“ z čísla (v tomto případě z typu Byte) a jsou navždy ztraceny.

Obr. 11: Operátor ‘<<’ (bitový posun doleva)
>> (bitový posun doprava)
Operátor ‘>>’ je naprosto stejný jako operátor ‘<<’, jen pracuje opačným směrem. Zde je kód, který předvádí použití operátoru ‘>>’:
NumberOne.b = 50
NumberTwo.b = NumberOne >> 1
Debug NumberTwo
V tomto příkladu přiřadíme proměnné ‘NumberOne’ hodnotu ‘50’. Pak vytvoříme proměnnou ‘NumberTwo’ a přiřadíme jí hodnotu ‘NumberOne’ bitově posunutou o jedno místo doprava. Výsledná hodnota (měla by to být ‘25’) se pak vypíše do okna Debug Output. Funkci tohoto operátoru lépe pochopíte z tohoto diagramu:

Obr. 12: Operátor ‘>>’ (bitový posun doprava)
Jak vidíte, výsledná hodnota má jednoduše své binární číslice (bity) posunuty z původní pozice doprava, v tomto případě o jedno místo. Při takovém posunu bitů doprava je důležité vědět, jakými bity se vyplní mezera, která vznikne na levé straně binárního čísla. Je-li číslo kladné, je bit zcela vlevo (někdy nazývaný nejvýznamnější bit) nastaven na nulu. V takovém případě se mezera vyplní bity nastavenými na nulu. Je-li zdrojové číslo záporné (se znaménkem), je bit zcela vlevo jednička. V takovém případě se mezera vyplní bity nastavenými na jedničku. Bity na pravé straně „vypadnou“ z čísla (v tomto případě z typu Byte) a jsou navždy ztraceny.
< (menší než)
Operátor ‘<’ se používá k porovnání dvou proměnných nebo výrazů. Je-li hodnota na levé straně operátoru menší než hodnota na pravé straně, vrátí tento operátor pravdu (1), jinak vrátí nepravdu (0). Zde je ukázka kódu předvádějící jeho použití:
NumberOne.l = 1
NumberTwo.l = 2
If NumberOne < NumberTwo
Debug "1: NumberOne is less than NumberTwo"
Else
Debug "2: NumberTwo is less than NumberOne"
EndIf
Zde v příkazu ‘If’ testujeme, zda je ‘NumberOne’ menší než ‘NumberTwo’, což samozřejmě je, a proto se provede první příkaz debug. Pokud hodnotu ‘NumberOne’ změníme na ‘3’, a to takto:
NumberOne.l = 3
NumberTwo.l = 2
If NumberOne < NumberTwo
Debug "1: NumberOne is less than NumberTwo"
Else
Debug "2: NumberTwo is less than NumberOne"
EndIf
uvidíme nyní v okně Debug Output, že se provedl druhý příkaz debug, protože ‘NumberOne’ už není menší než ‘NumberTwo’.
> (větší než)
Operátor ‘>’ se používá k porovnání dvou proměnných nebo výrazů. Je-li hodnota na levé straně operátoru větší než hodnota na pravé straně, vrátí tento operátor pravdu (1), jinak vrátí nepravdu (0). Zde je ukázka kódu předvádějící jeho použití:
NumberOne.l = 2
NumberTwo.l = 1
If NumberOne > NumberTwo
Debug "1: NumberOne is more than NumberTwo"
Else
Debug "2: NumberTwo is more than NumberOne"
EndIf
Zde v příkazu ‘If’ testujeme, zda je ‘NumberOne’ větší než ‘NumberTwo’, což samozřejmě je, a proto se provede první příkaz debug. Pokud hodnotu ‘NumberOne’ změníme na ‘0’, a to takto:
NumberOne.l = 0
NumberTwo.l = 1
If NumberOne > NumberTwo
Debug "1: NumberOne is more than NumberTwo"
Else
Debug "2: NumberTwo is more than NumberOne"
EndIf
uvidíme nyní v okně Debug Output, že se provedl druhý příkaz debug, protože ‘NumberOne’ už není větší než ‘NumberTwo’.
<= (menší nebo rovno)
Operátor ‘<=’ se používá k porovnání dvou proměnných nebo výrazů. Je-li hodnota na levé straně operátoru menší nebo rovna hodnotě na pravé straně, vrátí tento operátor pravdu (1), jinak vrátí nepravdu (0). Zde je ukázka kódu předvádějící jeho použití:
NumberOne.l = 0
NumberTwo.l = 1
If NumberOne <= NumberTwo
Debug "1: NumberOne is less than or equal to NumberTwo"
Else
Debug "2: NumberOne is NOT less than or equal to NumberTwo"
EndIf
Zde v příkazu ‘If’ testujeme, zda je ‘NumberOne’ menší nebo rovno ‘NumberTwo’, což samozřejmě je, a proto se provede první příkaz debug. Pokud hodnotu ‘NumberOne’ změníme na ‘1’, vrátí příkaz ‘If’ stále pravdu (1), protože ‘NumberOne’ je stále menší nebo rovno ‘NumberTwo’.
Abychom předvedli provedení druhého příkazu debug, musíme zajistit, aby příkaz ‘If’ dostal od operátoru ‘<=’ výsledek nepravda. Toho snadno dosáhneme tak, že hodnota ‘NumberOne’ NEBUDE menší ani rovna hodnotě ‘NumberTwo’, a to takto:
NumberOne.l = 2
NumberTwo.l = 1
If NumberOne <= NumberTwo
Debug "1: NumberOne is less than or equal to NumberTwo"
Else
Debug "2: NumberOne is NOT less than or equal to NumberTwo"
EndIf
>= (větší nebo rovno)
Operátor ‘>=’ se používá k porovnání dvou proměnných nebo výrazů. Je-li hodnota na levé straně operátoru větší nebo rovna hodnotě na pravé straně, vrátí tento operátor pravdu (1), jinak vrátí nepravdu (0). Zde je ukázka kódu předvádějící jeho použití:
NumberOne.l = 2
NumberTwo.l = 1
If NumberOne >= NumberTwo
Debug "1: NumberOne is more than or equal to NumberTwo"
Else
Debug "2: NumberOne is NOT more than or equal to NumberTwo"
EndIf
Zde v příkazu ‘If’ testujeme, zda je ‘NumberOne’ větší nebo rovno ‘NumberTwo’, což samozřejmě je, a proto se provede první příkaz debug. Pokud hodnotu ‘NumberOne’ změníme na ‘1’, vrátí příkaz ‘If’ stále pravdu (1), protože ‘NumberOne’ je stále větší nebo rovno ‘NumberTwo’.
Abychom předvedli provedení druhého příkazu debug, musíme zajistit, aby příkaz ‘If’ dostal od operátoru ‘>=’ výsledek nepravda. Toho snadno dosáhneme tak, že hodnota ‘NumberOne’ NEBUDE větší ani rovna hodnotě ‘NumberTwo’, a to takto:
NumberOne.l = 0
NumberTwo.l = 1
If NumberOne >= NumberTwo
Debug "1: NumberOne is more than or equal to NumberTwo"
Else
Debug "2: NumberOne is NOT more than or equal to NumberTwo"
EndIf
<> (nerovná se)
Operátor ‘<>’ se používá k porovnání dvou proměnných nebo výrazů a funguje přesně opačně než porovnávací (nikoli přiřazovací) funkce operátoru ‘=’. Pokud se hodnota na levé straně operátoru nerovná hodnotě na pravé straně, vrátí tento operátor pravdu (1), jinak vrátí nepravdu (0). Zde je ukázka kódu předvádějící jeho použití:
NumberOne.l = 0
NumberTwo.l = 1
If NumberOne <> NumberTwo
Debug "1: NumberOne does not equal NumberTwo"
Else
Debug "2: NumberOne does equal NumberTwo"
EndIf
Zde v příkazu ‘If’ testujeme, zda se ‘NumberOne’ nerovná ‘NumberTwo’, což se samozřejmě nerovná, a proto se provede první příkaz debug. Pokud hodnotu ‘NumberOne’ změníme na ‘1’, a to takto:
NumberOne.l = 1
NumberTwo.l = 1
If NumberOne <> NumberTwo
Debug "1: NumberOne does not equal NumberTwo"
Else
Debug "2: NumberOne does equal NumberTwo"
EndIf
uvidíme nyní v okně Debug Output, že se provedl druhý příkaz debug, protože ‘NumberOne’ se nyní rovná ‘NumberTwo’ a operátor ‘<>’ vrací nepravdu.
And (logické AND)
Logické operátory slouží ke kombinování logických výsledků pravda či nepravda, které vracejí porovnávací operátory, a umožňují tak spolehlivější porovnávání hodnot více výrazů.
Operátor ‘And’ slouží ke kontrole dvou výrazů, zda se oba vyhodnotí jako pravda. Podívejte se na tento kousek kódu:
StringOne.s = "The quick brown fox"
NumberOne.l = 105
If StringOne = "The quick brown fox" And NumberOne = 105
Debug "1: Both expressions evaluate to true (1)"
Else
Debug "2: One or both of the expressions evaluate as false (0)"
EndIf
Vidíme zde, že příkaz ‘If’ testuje, zda se řetězcová proměnná ‘StringOne’ rovná ‘The quick brown fox’ a zároveň zda se proměnná typu Long ‘NumberOne’ rovná ‘105’. Protože obojí platí, vrátí operátor ‘And’ pravdu a provede se první příkaz debug. Pokud kterýkoli z výrazů na pravé či levé straně operátoru ‘And’ vrátí nepravdu, vrátí nepravdu i samotný operátor ‘And’. Tento operátor je optimalizován tak, že pokud první z výrazů vrátí nepravdu, vrátí operátor ‘And’ okamžitě nepravdu a další výraz se už vůbec nevyhodnocuje. To se hodí, když chcete psát kód, který běží velmi rychle.
Not (logické NOT)
Operátor ‘Not’ slouží k logické negaci výrazu nebo booleovské hodnoty. Jinými slovy, cokoli se na pravé straně tohoto operátoru vyhodnotí jako pravda, je vráceno jako nepravda, a naopak. Podívejte se na tento příklad:
One.l = 1
Two.l = 2
If Not One = 5
Debug "1: One = 5 is evaluated as true (1)"
Else
Debug "2: One = 5 is evaluated as false (0)"
EndIf
If Not Two = 2
Debug "1: Two = 2 is evaluated as true (1)"
Else
Debug "2: Two = 2 is evaluated as false (0)"
EndIf
Vidíme zde, že první příkaz ‘If’ testuje, zda se proměnná typu Long ‘One’ rovná ‘5’, což neplatí, a výraz tedy vrátí nepravdu. Protože před výrazem ‘One = 5’ stojí operátor ‘Not’, převrátí se návratová hodnota nepravda na pravdu. Opačné hodnoty ukazuje druhý příkaz ‘If’. Výraz v něm vrací pravdu, ale operátor ‘Not’ ji převrátí na nepravdu.
Or (logické OR)
Operátor ‘Or’ slouží ke kontrole dvou výrazů, zda se alespoň jeden z nich vyhodnotí jako pravda. Podívejte se na tento kousek kódu:
StringOne.s = "The quick brown fox"
NumberOne.l = 105
If StringOne = "The quick brown fox" Or NumberOne = 100
Debug "1: One or more expressions evaluate to true (1)"
Else
Debug "2: Both of the expressions evaluate as false (0)"
EndIf
Zde vidíme, že příkaz ‘If’ testuje, zda se řetězcová proměnná ‘StringOne’ rovná ‘The quick brown fox’ nebo zda se proměnná typu Long ‘NumberOne’ rovná ‘100’. Všimněte si, že druhý výraz v příkazu ‘If’ ve skutečnosti vrací nepravdu, protože ‘NumberOne’ se nerovná ‘100’.
Protože jeden z výrazů vrací pravdu, vrátí operátor ‘Or’ pravdu a provede se první příkaz debug. Operátor ‘Or’ vrátí nepravdu jen tehdy, pokud nepravdu vrátí oba výrazy na jeho pravé i levé straně. I tento operátor je optimalizován tak, že pokud první výraz vrátí pravdu, vrátí operátor ‘Or’ okamžitě pravdu a další výraz se už vůbec nevyhodnocuje. To se hodí, když chcete psát kód, který běží velmi rychle.
XOr (logické XOR)
Operátor ‘XOr’ slouží ke kontrole dvou výrazů, zda se jako pravda vyhodnotí právě jeden z nich. Podívejte se na tento kousek kódu:
StringOne.s = "The quick brown fox"
NumberOne.l = 105
If StringOne = "The quick brown fox" XOr NumberOne = 105
Debug "1: Only one expression is true (1)"
Else
Debug "2: The expressions are either both true (1) or both false (0)"
EndIf
Příkaz ‘If’ testuje oba výrazy pomocí operátoru ‘XOr’, aby ověřil, že se jako pravda vyhodnocuje jen jeden z nich. Pokud se oba vyhodnotí jako pravda nebo oba jako nepravda, vrátí samotný příkaz ‘If’ nepravdu a provede se druhý příkaz debug, což je právě tento případ. Kdyby se příklad upravil tak, aby pravdu vracel jen jeden výraz, vrátil by příkaz ‘If’ pravdu a provedl by se první příkaz debug.
% (modulo)
Operátor ‘%’ vydělí číslo na levé straně číslem na pravé straně a vrátí zbytek po tomto dělení. Zde je příklad:
NumberOne.l = 20 % 8
Debug NumberOne
Zde pomocí operátoru ‘%’ dělíme číslo ‘20’ číslem ‘8’. Číslo ‘8’ se do ‘20’ vejde dvakrát a zbude ‘4’. Tento zbytek se přiřadí proměnné ‘NumberOne’. Tuto hodnotu pak vypíšeme do okna Debug Output.
( ) (závorky)
Závorky nejsou samy o sobě skutečným operátorem, protože nikdy nevracejí žádný výsledek. Slouží k určení pořadí provádění vnořených výrazů. Obecně platí, že výraz v závorkách se vyhodnocuje jako první. U vnořených závorek se nejdříve vyhodnotí nejvnitřnější pár, pak další a tak dále, dokud se nedojde k poslednímu. Zde je příklad:
NumberOne.l = 2 * 5 + 3
Debug NumberOne
Zde je hodnota ‘NumberOne’ rovna ‘13’, protože pořadí vyhodnocení je ‘2 * 5’ a pak ‘+ 3’. Pokud přidáme závorky, a to takto:
NumberOne.l = 2 * (5 + 3)
Debug NumberOne
změní se pořadí vyhodnocení na ‘5 + 3’ a pak ‘* 2’, což dá hodnotu ‘16’, která se přiřadí proměnné ‘NumberOne’ a vypíše do okna Debug Output.
Priorita operátorů
Priorita (přednost) operátorů je pojem označující pořadí, v němž se operátory vyhodnocují při kompilaci. Na obr. 13 vidíte pořadí, v jakém se operátory vyhodnocují podle své priority.
Tato priorita je uvedena v levém sloupci: nejnižší číslo (1) znamená, že se tyto operátory vyhodnocují jako první, a čím vyšší číslo, tím později se operátory vyhodnocují.
| Priorita* | Operátory |
|---|---|
1 |
( ) |
2 |
~ |
3 |
<< >> % ! |
4 |
\| & |
5 |
* / |
6 |
+ - |
7 |
> >= < <= = <> |
8 |
And Or Not XOr |
Obr. 13: Priorita operátorů — * Operátory na začátku tohoto seznamu se vyhodnocují jako první.
V tomto příkladu:
Debug 3 + 10 * 2
se operátor násobení vyhodnotí dříve než operátor sčítání, protože má vyšší prioritu, i když se ve výrazu nachází až za operátorem sčítání. Výsledek vypsaný do okna Debug Output by měl být ‘23’.
Chcete-li prioritu operátorů upravit, uzavřete části kódu do závorek, aby se provedly s vyšší prioritou. Pokud bychom například chtěli, aby se jako první provedl operátor sčítání, zapsali bychom výraz takto:
Debug (3 + 10) * 2
Nyní by hodnota vypsaná do okna Debug Output byla ‘26’.
Poznámky k výrazům
Když kompilátor PureBasicu vyhodnocuje výraz, v němž se vyskytují celá čísla i čísla s plovoucí desetinnou čárkou, někdy změní datový typ jednotlivých složek výrazu, aby jej vyhodnotil správně. Obsahuje-li výraz číslo typu float, převede se před vyhodnocením a vrácením výsledku každá část výrazu na float. Obr. 14 ukazuje příklady toho, jak PureBasic za určitých podmínek takové výrazy vyhodnocuje.
Pokud zjistíte, že operátory nebo výrazy vracejí podivné výsledky nebo že vrácené číslo není očekávaného typu, je dobré výraz znovu zkontrolovat a ověřit, zda se na něj neuplatňují tato pravidla kompilátoru.
| Příklad výrazu | Pravidlo vyhodnocení |
|---|---|
a.l = b.l + c.l |
‘b’ i ‘c’ zůstávají před vyhodnocením i během něj typu Long; vrátí se hodnota typu Long a přiřadí se do ‘a’. |
a.l = b.l + c.f |
Protože tento výraz obsahuje float, převede se ‘b’ před vyhodnocením na float. Pak se ‘b’ sečte s ‘c’, výsledný float se převede na Long a přiřadí se do ‘a’. |
a.f = b.l + c.l |
‘b’ i ‘c’ zůstávají před vyhodnocením i během něj typu Long. Výsledná hodnota typu Long vrácená operátorem sčítání se pak převede na float a přiřadí se do ‘a’. |
a.l = b.f + c.f |
‘b’ i ‘c’ zůstávají před vyhodnocením i během něj typu float. Výsledný float vrácený operátorem sčítání se pak převede na Long a přiřadí se do ‘a’. |
Obr. 14: Pravidla vyhodnocování výrazů
| Operátor | Popis |
|---|---|
| = | Rovná se. Lze jej použít dvěma způsoby. První je přiřazení hodnoty výrazu na RHS proměnné na LHS. Druhý způsob nastává, když se výsledek operátoru použije ve výrazu k otestování, zda jsou hodnoty výrazů na LHS a RHS stejné (jsou-li stejné, vrátí operátor rovná se pravdu, jinak vrátí nepravdu). |
| + | Plus. Výsledkem je hodnota výrazu na RHS přičtená k hodnotě výrazu na LHS. Pokud se výsledek tohoto operátoru nepoužije a na LHS je proměnná, přičte se hodnota výrazu na RHS přímo k proměnné na LHS. |
| - | Minus. Odečte hodnotu výrazu na RHS od hodnoty výrazu na LHS. Pokud na LHS žádný výraz není, dává tento operátor zápornou hodnotu výrazu na RHS. Pokud se výsledek tohoto operátoru nepoužije a na LHS je proměnná, odečte se hodnota výrazu na RHS přímo od proměnné na LHS. (Tento operátor nelze používat s řetězci.) |
| * | Násobení. Vynásobí hodnotu výrazu na LHS hodnotou výrazu na RHS. Pokud se výsledek tohoto operátoru nepoužije a na LHS je proměnná, vynásobí se hodnota proměnné přímo hodnotou výrazu na RHS. (Tento operátor nelze používat s řetězci.) |
| / | Dělení. Vydělí hodnotu výrazu na LHS hodnotou výrazu na RHS. Pokud se výsledek tohoto operátoru nepoužije a na LHS je proměnná, vydělí se hodnota proměnné přímo hodnotou výrazu na RHS. (Tento operátor nelze používat s řetězci.) |
| & | Bitové AND. Při používání tohoto operátoru byste měli znát binární čísla. Výsledkem tohoto operátoru je hodnota výrazu na LHS spojená operací AND s hodnotou výrazu na RHS, bit po bitu. Pokud se navíc výsledek operátoru nepoužije a na LHS je proměnná, uloží se výsledek přímo do této proměnné. (Tento operátor nelze používat s řetězci.) |
| | | Bitové OR. Při používání tohoto operátoru byste měli znát binární čísla. Výsledkem tohoto operátoru je hodnota výrazu na LHS spojená operací OR s hodnotou výrazu na RHS, bit po bitu. Pokud se navíc výsledek operátoru nepoužije a na LHS je proměnná, uloží se výsledek přímo do této proměnné. (Tento operátor nelze používat s řetězci.) |
| ! | Bitové XOR. Při používání tohoto operátoru byste měli znát binární čísla. Výsledkem tohoto operátoru je hodnota výrazu na LHS spojená operací XOR s hodnotou výrazu na RHS, bit po bitu. Pokud se navíc výsledek operátoru nepoužije a na LHS je proměnná, uloží se výsledek přímo do této proměnné. (Tento operátor nelze používat s řetězci.) |
| ~ | Bitové NOT. Při používání tohoto operátoru byste měli znát binární čísla. Výsledkem tohoto operátoru je hodnota výrazu na RHS po operaci NOT, tj. výsledek bude mít oproti hodnotě výrazu invertované bity. (Tento operátor nelze používat s řetězci.) |
| < | Menší než. Slouží k porovnání hodnot výrazů na LHS a RHS. Je-li hodnota výrazu na LHS menší než hodnota výrazu na RHS, dává tento operátor výsledek pravda, jinak je výsledkem nepravda. |
| > | Větší než. Slouží k porovnání hodnot výrazů na LHS a RHS. Je-li hodnota výrazu na LHS větší než hodnota výrazu na RHS, dává tento operátor výsledek pravda, jinak je výsledkem nepravda. |
| <= | Menší nebo rovno. Slouží k porovnání hodnot výrazů na LHS a RHS. Je-li hodnota výrazu na LHS menší nebo rovna hodnotě výrazu na RHS, dává tento operátor výsledek pravda, jinak je výsledkem nepravda. |
| >= | Větší nebo rovno. Slouží k porovnání hodnot výrazů na LHS a RHS. Je-li hodnota výrazu na LHS větší nebo rovna hodnotě výrazu na RHS, dává tento operátor výsledek pravda, jinak je výsledkem nepravda. |
| <> | Nerovná se. Slouží k porovnání hodnot výrazů na LHS a RHS. Rovná-li se hodnota výrazu na LHS hodnotě výrazu na RHS, dává tento operátor výsledek nepravda, jinak je výsledkem pravda. |
| And | Logické AND. Slouží k porovnání hodnot výrazů na LHS a RHS. Jsou-li hodnoty výrazů na LHS i RHS obě pravdivé, je výsledkem pravda, jinak je výsledkem nepravda. |
| Or | Logické OR. Slouží k porovnání hodnot výrazů na LHS a RHS. Je-li hodnota výrazu na LHS nebo na RHS pravdivá, je výsledkem pravda, jinak je výsledkem nepravda. |
| Not | Logické NOT. Slouží k logické negaci booleovské hodnoty. Jinými slovy, pokud výraz vrací pravdu, lze ji operátorem Not převrátit na nepravdu. Naopak pokud výraz na RHS tohoto operátoru vrací nepravdu, vrátí Not pravdu. |
| XOr | Logické XOR. Slouží k porovnání hodnot výrazů na LHS a RHS. Pokud se jako pravda vyhodnotí jen jeden z výrazů na LHS nebo RHS, je výsledkem pravda. Jsou-li oba výrazy pravdivé nebo oba nepravdivé, vrátí operátor XOr nepravdu. |
| << | Aritmetický posun doleva. Posune každý bit hodnoty výrazu na LHS doleva o počet míst daný hodnotou výrazu na RHS. Pokud se navíc výsledek tohoto operátoru nepoužije a na LHS je proměnná, posune se hodnota této proměnné o počet míst uvedený na RHS. Při používání tohoto operátoru se pravděpodobně hodí rozumět binárním číslům, i když jej můžete používat tak, jako by každý posun o jedno místo znamenal vynásobení dalším činitelem 2. |
| >> | Aritmetický posun doprava. Posune každý bit hodnoty výrazu na LHS doprava o počet míst daný hodnotou výrazu na RHS. Pokud se navíc výsledek tohoto operátoru nepoužije a na LHS je proměnná, posune se hodnota této proměnné o počet míst uvedený na RHS. Při používání tohoto operátoru se pravděpodobně hodí rozumět binárním číslům, i když jej můžete používat tak, jako by každý posun o jedno místo znamenal vydělení dalším činitelem 2. |
| % | Modulo. Vrací zbytek po celočíselném dělení LHS hodnotou RHS. |
| ( ) | Závorky. Pomocí párů závorek můžete vynutit, aby se část výrazu vyhodnotila jako první nebo v určitém pořadí. Výrazy v závorkách se vyhodnocují dříve než kterákoli jiná část aktuálního výrazu. U vnořených závorek se nejdříve vyhodnotí nejvnitřnější pár a pak postupně další směrem ven. |
Obr. 15: Stručný přehled operátorů — RHS = pravá strana, LHS = levá strana
4Podmíněné příkazy a cykly
V této kapitole vás seznámím s podmíněnými příkazy a cykly. Jsou to klíčové součásti každého programu a pomáhají určovat jeho průběh. Začnu vysvětlením, co jsou booleovské hodnoty a jak s nimi PureBasic zachází. Poté přejdu k podmíněným příkazům, jako jsou ‘If’ a ‘Select’, kterými programu říkáte, jak má pokračovat, když je splněna určitá podmínka. Kapitolu pak zakončím výkladem a ukázkami různých cyklů, které můžete v PureBasicu používat. Jako vždy najdete u všeho podrobné vysvětlení a spoustu příkladů.
Booleovská logika
Nejprve oprášíme dějepis. George Boole byl matematik a filozof, který vynalezl druh algebry, jemuž dnes říkáme booleovská algebra. Logika, na níž tato algebra stojí, byla na počest George Boolea pojmenována booleovská logika. Postupně se stala základem veškeré aritmetiky moderních počítačů. Pozoruhodné je, že ji George Boole vymyslel zhruba sedmdesát let předtím, než vznikl první počítač, který ji používal!
Stručně řečeno, celý systém se točí kolem dvou hodnot: pravdy a nepravdy (True a False). Tyto dvě hodnoty (neboli stavy) se pomocí logických operací testují, a tím se určuje výsledek. Opravdu je to tak jednoduché. Tři nejzákladnější logické operace byly (a stále jsou) AND, OR a NOT. Právě tyto tři operátory tvořily základ Booleovy algebry a byly jedinými operacemi potřebnými k provádění porovnávání či základních matematických výpočtů. (Jak jsou tyto logické operátory implementovány v PureBasicu a jak se používají, si můžete přečíst v kapitole 3.)
PureBasic na rozdíl od některých jazyků, například C++, nemá booleovský datový typ (jak je vidět na obr. 2 a obr. 3). K vyjádření pravdivé či nepravdivé hodnoty proto v PureBasicu používáme čísla: ‘1’ znamená pravdu (True) a ‘0’ nepravdu (False). Pamatujte na to, když testujete, zda je výsledek pravdivý, nebo nepravdivý. Pokud tyto číselné hodnoty používáte k vyjádření pravdy a nepravdy, je dobré místo nich používat vestavěné konstanty PureBasicu, aby byl váš kód později snáze čitelný a srozumitelný.
Zde jsou obě konstanty:
#True
#False
‘#True’ má hodnotu ‘1’ a ‘#False’ má hodnotu ‘0’.
Téměř všechny příkazy v PureBasicu vracejí nějakou hodnotu. Někdy je to výsledek matematické funkce, jindy třeba stav okna, které jste právě vytvořili. Tyto hodnoty se vracejí proto, abyste je v případě potřeby mohli otestovat, a někdy je to dokonce nutné, aby se zajistilo, že určité akce proběhnou. Podívejte se na tento kousek pseudokódu:
if window creation equals True
then draw graphics and buttons on the window
else
tell the user there has been a problem
end the program
Nejde o skutečný kód, který by šel zkompilovat, ale myšlenka je jasná. Testuji zde, zda bylo okno skutečně vytvořeno. Jakmile ověřím, že vytvořeno bylo, mohu do něj kreslit, co potřebuji. Pokud však vytvořeno nebylo, oznámím uživateli, že se něco pokazilo, a program ukončím. Kdybych vytvoření okna netestoval, riskoval bych ošklivý pád programu při pokusu kreslit tlačítka a grafiku na něco, co neexistuje.
To je první letmý pohled na to, jakou cenu mají testy pravdivosti. Zároveň nás to pěkně přivádí k další části, která podrobněji vysvětluje klíčové slovo ‘If’.
Příkaz ‘If’
Klíčové slovo ‘If’ slouží k sestavování příkazů, které ovlivňují průběh programu. Určuje, kterou cestou se program vydá, když nastane nebo je splněna určitá podmínka. Za běhu programu někdy přijdou neobvyklé vstupy nebo dojde k chybám a je příjemné mít možnost nasměrovat program tak, aby si s takovými situacemi poradil, pokud a když nastanou.
Sestavování příkazů ‘If’
Příkaz ‘If’ testuje pravdivou hodnotu. Pokud tuto pravdivou hodnotu obdrží, okamžitě provede kód následující za prvním řádkem příkazu ‘If’. Pokud ji neobdrží, provede jiný, samostatný kousek kódu, který následuje hned za klíčovým slovem ‘Else’ dále v příkazu. Podívejme se na příklad.
a.l = 5
If a = 5
Debug "A true value was found"
Else
Debug "No true value was found"
EndIf
Zde operátor ‘If’ testuje, zda se proměnná ‘a’ rovná ‘5’. Rovná se, takže výsledkem je pravda a provede se první řádek za klíčovým slovem ‘If’. Kdyby toto porovnání vrátilo nepravdu, provedl by se kód za klíčovým slovem ‘Else’. Příkaz ‘If’ musíte zakončit klíčovým slovem ‘EndIf’, které vymezuje jeho konec.
První, čeho si při seznamování s příkazy ‘If’ všimněte, je výraz, který následuje bezprostředně za klíčovým slovem ‘If’. Tento výraz se testuje, zda se vyhodnotí jako pravda. Může to být jednoduchá proměnná, ale i velmi dlouhý výraz. Klíčové slovo ‘Else’ je navíc zcela nepovinné a použil jsem ho zde jen proto, aby byl příklad úplný. Mohli bychom ho úplně vynechat a výše uvedený příklad přepsat takto:
a.l = 5
If a = 5
Debug "A true value was found"
EndIf
Jedinou nevýhodou tohoto kratšího příkladu je, že při nepravdivém výsledku nedává žádnou zpětnou vazbu. Žádné pravidlo neříká, že musíte v příkazu ‘If’ použít klíčové slovo ‘Else’, ale někdy je kvůli úplnosti dobré mít způsob, jak nepravdivý výsledek ošetřit.
Podívejme se na jednoduchý příkaz ‘If’, který testuje, zda má proměnná nějakou hodnotu.
Beads.l = 5
If Beads
Debug "The variable has a value"
Else
Debug "The variable does not have a value"
EndIf
Zde jsem jako testovaný výraz za klíčovým slovem ‘If’ použil jen jednu proměnnou. Testuje se, zda vrací nějakou hodnotu, což v tomto případě dělá. Hodnota není ‘0’, takže se považuje za pravdu (viz rámeček „Všechno je pravda?“) a provede se příslušný kousek kódu. Zkuste změnit hodnotu ‘Beads’ na ‘0’ a spusťte program znovu, abyste viděli nepravdivý výsledek.
Podívejme se na složitější příklad výrazu uvnitř příkazu ‘If’. Pokud potřebujete plně porozumět všem operátorům použitým v tomto výrazu, přečtěte si znovu kapitolu 3.
Value1.l = 10
Value2.l = 5
Value3.l = 1
If Value1 >= 10 And (Value2 / 5) = Value3
Debug "The expression evaluates as true"
Else
Debug "The expression evaluates as false"
EndIf
Tento příkaz ‘If’ testuje, zda je ‘Value1’ větší nebo rovno ‘10’ a zároveň zda se ‘Value2’ dělené ‘5’ rovná ‘Value3’. Jak vidíte, testované výrazy mohou být poměrně složité a mohou velmi přesně určovat, jaké hodnoty testujete.
Klíčové slovo ‘ElseIf’
Dalším klíčovým slovem, které lze v příkazu ‘If’ použít, je ‘ElseIf’. Jak název napovídá, ‘ElseIf’ je kombinací ‘Else’ a ‘If’. Stejně jako ‘Else’ rozšiřuje příkaz ‘If’ tak, aby se provedl jiný kousek kódu, pokud se původní výraz za ‘If’ vyhodnotí jako nepravda. Na rozdíl od ‘Else’ však alternativní kód provede jen tehdy, když se jako pravda vyhodnotí podmíněný výraz za ‘ElseIf’. Zmateni? Zde je příklad:
NumberOfBeads.l = 10
If NumberOfBeads < 5
Debug "The variable has a value below '5'"
ElseIf NumberOfBeads > 5
Debug "The variable has a value above '5'"
Else
Debug "The variable has a value of '5'"
EndIf
Zde testujeme hodnotu proměnné ‘NumberOfBeads’. První ‘If’ testuje, zda je tato hodnota menší než ‘5’. Protože výsledkem je nepravda, program přejde k části ‘ElseIf’. Řádek ‘ElseIf’ vrátí pravdu, protože ‘NumberOfBeads’ je větší než ‘5’.
Příkaz ‘ElseIf’ je skvělý způsob, jak rozšířit ‘If’ o kontrolu více hodnot, a v jednom příkazu ‘If’ můžete použít neomezený počet kontrol ‘ElseIf’. Jedinou nevýhodou je, že při velkém počtu takových příkazů se může trochu zkomplikovat rozhodování, v jakém pořadí je zapsat. Když je potřeba velké množství kontrol, bývá někdy vhodnější příkaz ‘Select’.
Přeskakování částí příkazu
Pokud kdykoli během provádění příkazu ‘If’ některá jeho část vrátí pravdu, zbytek příkazu ‘If’ se přeskočí a neprovede. Kvůli tomuto chování je při navrhování příkazu ‘If’ potřeba jisté opatrnosti.
Poslední příklad ukázal toto přeskakování v praxi: část ‘Else’ se zcela přeskočí, protože část ‘ElseIf’ vrátí pravdu.
Příkaz ‘Select’
Příkazy ‘Select’ přímo doplňují příkazy ‘If’. Umožňují totiž spojit několik testů téže proměnné nebo výrazu do jediného bloku příkazů. Přestože jsou příkazy ‘If’ ve svém oboru velmi mocné, když se věci začnou komplikovat a je potřeba otestovat velké množství podmínek, je někdy lepší použít ‘Select’. Ukážu vám příklad správné syntaxe a vysvětlím jeho použití.
Days.l = 2
Select Days
Case 0
Debug "0 Days"
Case 1
Debug "1 Day"
Case 2
Debug "2 Days"
Default
Debug "Over 2 Days"
EndSelect
Příkaz ‘Select’ začíná klíčovým slovem ‘Select’, které v podstatě vybírá výraz nebo proměnnou k testování, v tomto případě proměnnou ‘Days’. Následující klíčová slova ‘Case’ jsou větve, které se mohou provést, pokud se hodnota ‘Days’ rovná proměnné nebo výrazu uvedenému za daným ‘Case’. V našem příkladu to znamená, že má-li proměnná ‘Days’ hodnotu ‘0’, provede se kód bezprostředně za ‘Case 0’, má-li hodnotu ‘1’, provede se kód bezprostředně za ‘Case 1’, a tak dále.
Všimněte si, že na posledním místě, kde by normálně bylo ‘Case’, stojí jiné klíčové slovo, ‘Default’. Kód za ním se provede, pokud všechny ostatní větve ‘Case’ vrátí nepravdu – podobně jako ‘Else’ v příkazu ‘If’.
Kontrola více hodnot
Příkazy ‘Select’ dokážou kontrolovat spoustu různých hodnot a lze je úhledně uspořádat tak, aby vznikl přehledný a stručný kód. Aby byl tento čistý a elegantní způsob testování mnoha hodnot co nejpohodlnější, může příkaz ‘Select’ při definování svých větví ‘Case’ využívat několik zkratek. Zde je příklad:
Weight.l = 12
Select Weight
Case 0
Debug "No Weight"
Case 1, 2, 3
Debug "Light"
Case 4 To 15
Debug "Medium"
Case 16 To 30
Debug "Heavy"
Default
Debug "Massive"
EndSelect
Zde vidíte zkratky, kterými lze zadat rozsah případů. Klíčovým slovem ‘To’ určíte rozsah, nebo můžete v jednom ‘Case’ uvést několik čísel oddělených čárkami. Při zadávání rozsahů pomocí ‘To’ musí být druhé číslo vždy větší než první. V tomto příkladu jsem použil čísla, ale lze je nahradit výrazy nebo proměnnými, a tak přesněji ošetřit možné hodnoty, kterých může vybraná proměnná nebo výraz nabývat.
Zde je další zábavný příklad s příkazem ‘Select’, tentokrát v konzolovém programu:
If OpenConsole()
PrintN("1. Official PureBasic Home")
PrintN("2. Official PureBasic Forums")
PrintN("3. PureArea.net")
PrintN("")
PrintN("Enter a number from 1 To 3 and press Return: ")
Destination.s = Input()
Select Destination
Case "1"
RunProgram("http://www.purebasic.com")
Case "2"
RunProgram("http://forums.purebasic.com")
Case "3"
RunProgram("http://www.purearea.net")
EndSelect
EndIf
End
V tomto příkladu jsem použil několik nových příkazů, které ještě neznáte, ale myslím, že tento jednoduchý program pěkně předvádí jedno z možných použití příkazu ‘Select’. Nové příkazy vysvětlím o něco později, ale myslím, že podle jejich výstižných názvů odhadnete, co se děje.
Hlavní, čeho si na tomto příkladu všimnout, je, že příkaz ‘Select’ testuje proměnnou ‘Destination’. Této proměnné se přiřadí řetězcová hodnota, kterou po stisknutí klávesy Enter vrátí příkaz ‘Input()’. Větve ‘Case’ jsou pak rovněž definovány pomocí řetězců, aby správně odpovídaly hodnotě proměnné. Příkazem ‘Select’ či ‘Case’ lze testovat jakýkoli typ PureBasicu nebo jakýkoli typ, který je výsledkem výrazu.
Mimochodem, v tomto posledním příkladu také vidíte, že jsem příkazem ‘If’ otestoval, zda ‘OpenConsole()’ vrátí pravdu a správně otevře okno konzole.
Cykly
Abyste mohli nepřetržitě přijímat a zpracovávat data, potřebujete cykly. Všechny programy s grafickým uživatelským rozhraním používají cykly k vykreslování rozhraní a k neustálému sledování vstupu od uživatele. Například IDE PureBasicu používá ve svém kódu mnoho cyklů, aby sledovalo stisky kláves a kliknutí myší, aktualizovalo zobrazení a podobně. Cykly jsou také skvělým způsobem, jak zpracovávat velké množství dat v polích nebo spojových seznamech – procházíte je prvek po prvku.
Cykly ‘For’
Prvním cyklem, o kterém budu mluvit, je pravděpodobně nejznámější a možná i nejpoužívanější ze všech – cyklus ‘For’. Tyto cykly, někdy nazývané cykly ‘For/Next’, jsou skvělým způsobem, jak procházet data, když potřebujete zvyšující se proměnnou, kterou můžete použít jako počítadlo nebo jako index jednotlivých prvků procházeného pole. Pro začátek zde je příklad.
For x.l = 1 To 10
Debug x
Next x
V tomto příkladu sestavujeme cyklus pomocí klíčového slova ‘For’. Bezprostředně za tímto klíčovým slovem musí následovat uživatelem definovaná proměnná typu Long, kterou jsem v tomto příkladu nazval ‘x’. Hodnota přiřazená proměnné ‘x’ je počáteční hodnotou cyklu; zde jsem jí přiřadil ‘1’. Za tímto přiřazením následuje klíčové slovo ‘To’, které definuje rozsah, takže jsem zadal ‘10’ jako horní mez, které má ‘x’ během cyklu dosáhnout. Tím je začátek cyklu hotov a zbývá jen určit jeho konec. To uděláme řádkem ‘Next x’. Tento poslední řádek říká kompilátoru, že po každém jednotlivém kroku cyklu má přejít na další hodnotu ‘x’ z rozsahu uvedeného na prvním řádku a pak cyklus spustit znovu.
Kód mezi těmito dvěma řádky se v cyklu opakuje tolikrát, kolik kroků je mezi počáteční a koncovou hodnotou zadaného rozsahu. Jakmile hodnota ‘x’ dosáhne horní meze uvedené za klíčovým slovem ‘To’, cyklus skončí a program pokračuje normálně dál.
Když výše uvedený příklad spustíte, všimnete si, že okno Debug Output (výstup ladění) zobrazuje různé hodnoty, kterých ‘x’ během cyklu nabývá. Uvidíte, že se cyklus zopakuje desetkrát, protože proměnná ‘x’ se pokaždé zvýší podle zadaného rozsahu.
Zde je další příklad, jak cyklem snadno projít pole.
Dim Names.s(3)
Names(0) = "Gary"
Names(1) = "Sara"
Names(2) = "Stella"
Names(3) = "MiniMunch"
For x.l = 0 To 3
Debug Names(x)
Next x
Protože ke všem hodnotám pole se přistupuje pomocí indexů a tyto indexy vždy začínají od nuly, jsou cykly ‘For’ báječné pro provádění operací se všemi prvky pole s použitím jen malého množství kódu. Jak vidíte z posledního příkladu, k vypsání hodnot všech prvků pole do okna Debug Output stačí tři řádky kódu, bez ohledu na velikost pole. Větší pole potřebuje jen větší rozsah na prvním řádku definice cyklu ‘For’.
Cykly ‘For’ lze sestavovat i pomocí výrazů:
StartVar.l = 5
StopVar.l = 10
For x = StartVar - 4 To StopVar / 2
Debug x
Next x
a pokud potřebujete zpracovávat vícerozměrná pole, lze cykly samozřejmě i vnořovat:
Dim Numbers.l(2, 2)
Numbers(0, 0) = 1
Numbers(0, 1) = 2
Numbers(0, 2) = 3
Numbers(1, 0) = 4
Numbers(1, 1) = 5
Numbers(1, 2) = 6
Numbers(2, 0) = 7
Numbers(2, 1) = 8
Numbers(2, 2) = 9
For x = 0 To 2
For y = 0 To 2
Debug Numbers(x, y)
Next y
Next x
Pokud mají proměnné počítadel různé názvy, můžete vnořit tolik cyklů ‘For’, kolik chcete. Díky své jedinečné nastavitelnosti jsou cykly ‘For’ mocné a nesmírně užitečné, když potřebujete kód opakovat uživatelem určený počet krát.
Až dosud jste viděli, jak cykly ‘For’ při každém průchodu zvyšují proměnnou počítadla o ‘1’, ale velikost kroku lze nastavit ručně pomocí nepovinného klíčového slova ‘Step’. Zde je další příklad:
For x.l = 0 To 10 Step 2
Debug x
Next x
Všimněte si, že klíčové slovo ‘Step’ se objevuje na prvním řádku cyklu ‘For’. Toto klíčové slovo lze použít pouze v cyklu ‘For’ a v cyklu jedině na tomto místě. Hned za klíčovým slovem ‘Step’
uvedete hodnotu, o kterou se má proměnná počítadla při každém průchodu cyklem zvýšit. V tomto případě jsem použil číslo ‘2’, takže se proměnná ‘x’ při každém průchodu zvýší o ‘2’. Pokud tento příklad spustíte a podíváte se do okna Debug Output, uvidíte, že vypsané hodnoty jsou vesměs násobky ‘2’.
Cykly ‘ForEach’
Tento typ cyklu se od všech ostatních liší tím, že funguje pouze se spojovými seznamy. Syntaxe je velmi podobná cyklu ‘For’, jen není potřeba nastavovat proměnnou počítadla. Zde je jednoduchý příklad.
NewList Shopping.s()
AddElement(Shopping())
Shopping() = "Bunch of bananas"
AddElement(Shopping())
Shopping() = "Tea bags"
AddElement(Shopping())
Shopping() = "Cheese"
ForEach Shopping()
Debug Shopping()
Next
V tomto příkladu po definování spojového seznamu a přidání několika prvků použiji cyklus ‘ForEach’ k vypsání obsahu seznamu do okna Debug Output. Jak vidíte, syntaxe je velmi přehledná a velmi jednoduchá. Cyklus začíná klíčovým slovem ‘ForEach’, za nímž následuje název spojového seznamu. Konec cyklu se pak vymezí klíčovým slovem ‘Next’. Kód mezi těmito dvěma řádky se opakuje po celé délce spojového seznamu. Jakmile se dosáhne konce spojového seznamu, cyklus skončí. Cyklus ‘ForEach’ funguje se všemi typy spojových seznamů, dokonce i se strukturovanými. O spojových seznamech budu podrobněji mluvit o něco později, v kapitole 5.
Cykly ‘While’
Tento cyklus používá výraz, podle něhož se určuje, zda má začít a jak dlouho má pokračovat. Pokud výraz vrátí pravdu, cyklus začne. Po každém jednotlivém průchodu se výraz znovu testuje, a pokud stále vrací pravdu, cyklus pokračuje. Pokud výraz kdykoli vrátí nepravdu, cyklus skončí. Podívejte se na tento příklad:
Monkeys.l = 0
While Monkeys < 10
Debug Monkeys
Monkeys + 1
Wend
Sestavit tento cyklus je velmi jednoduché. Začíná klíčovým slovem ‘While’, za nímž následuje výraz, který cyklus řídí – v tomto případě jsem použil ‘Monkeys < 10’. Cyklus se pak uzavře klíčovým slovem ‘Wend’.
Úvodní výraz zkontroluje, zda je proměnná ‘Monkeys’ menší než ‘10’; pokud ano, program do cyklu vstoupí a cyklus začne. Kód uvnitř cyklu se pak opakuje, dokud ‘Monkeys < 10’ nevrátí nepravdu. Když se podíváte na výstup v okně Debug Output, uvidíte, že jakmile se ‘Monkeys’ rovná ‘10’, výraz vrátí nepravdu (protože hodnota už není menší než ‘10’) a cyklus skončí.
Při používání cyklů ‘While’ pamatujte na to, že pokud úvodní výraz vrátí nepravdu, program do cyklu nikdy nevstoupí a cyklus vůbec nezačne. To ukazuje tento příklad:
Monkeys.l = 20
While Monkeys < 10
Debug "This code is never executed"
Wend
Cykly ‘Repeat’
Tyto cykly jsou do značné míry opakem cyklů ‘While’. Cykly ‘Repeat’ začínají klíčovým slovem ‘Repeat’ a končí jedním ze dvou způsobů. Prvním je klíčové slovo ‘Until’ následované výrazem, druhým klíčové slovo ‘Forever’. Oba způsoby podrobně vysvětlím a začnu klíčovým slovem ‘Until’.
Podívejte se na tento příklad:
Bananas.l = 0
Repeat
Debug Bananas
Bananas + 1
Until Bananas > 10
Na rozdíl od cyklů ‘While’ je řídicí výraz na konci cyklu a vyhodnocuje se, zda vrací nepravdu. Pokud ano, cyklus pokračuje; pokud vrátí pravdu, cyklus skončí. Jak vidíte z výše uvedeného příkladu, cyklus skončí, jakmile je hodnota ‘Bananas’ větší než ‘10’.
Dalším bodem, kterého si všimněte, je, že na rozdíl od cyklů ‘While’ program do cyklu ‘Repeat’ vždy vstoupí a provede ho alespoň jednou, než se vyhodnotí výraz na jeho konci. To ukazuje tento příklad:
Bananas.l = 20
Repeat
Debug Bananas
Until Bananas > 10
Vidíte, že přestože je ‘Bananas’ větší než ‘10’, cyklus začne a jednou proběhne, než se vyhodnotí výraz na jeho konci. Při vyhodnocení výrazu je ‘Bananas’ větší než ‘10’, takže výraz vrátí pravdu a cyklus skončí.
Cykly ‘Repeat’ mají i druhou podobu: ve spojení s jiným klíčovým slovem z nich lze vytvořit zcela nekonečné cykly. Chcete-li sestavit nekonečný cyklus, použijte místo klíčového slova ‘Until’ a výrazu klíčové slovo ‘Forever’, takto:
Counter.l = 0
Repeat
Debug Counter
Counter + 1
ForEver
To se hodí, když chcete, aby cyklus běžel stále, nebo si nejste jisti, jaká podmínka má být splněna pro jeho ukončení, případně máte více podmínek, které musí být všechny splněny, aby se z cyklu vyskočilo. Tento příklad ukončíte příkazem nabídky ‘Kill Program’ (ukončit program; Menu:Debugger->Kill Program).
Řízení cyklů pomocí ‘Break’ a ‘Continue’
Všechny tyto typy cyklů lze kdykoli řídit dvěma společnými klíčovými slovy. Jsou to ‘Break’ a ‘Continue’. Nejprve vysvětlím ‘Break’.
Pokud je klíčové slovo ‘Break’ použito kdekoli uvnitř libovolného typu cyklu, cyklus se okamžitě ukončí, jakmile na toto klíčové slovo program narazí. U vnořených cyklů lze na konec klíčového slova ‘Break’ přidat nepovinný parametr, který určuje, z kolika cyklů se má vyskočit. Podívejme se na příklad použití klíčového slova ‘Break’:
For x = 1 To 10
If x = 5
Break
EndIf
Debug x
Next x
Zde jsem v cyklu ‘For’ předčasně vyskočil z cyklu pomocí klíčového slova ‘Break’, když se ‘x’ rovná ‘5’. Všimněte si, že cyklus skončí ještě předtím, než se do okna Debug Output vypíše ‘5’. Zde je příklad vyskočení z vnořených cyklů pomocí nepovinného parametru úrovně klíčového slova ‘Break’:
For x.l = 1 To 10
Counter = 0
Repeat
If x = 5
Break 2
EndIf
Counter + 1
Until Counter > 1
Debug x
Next
Jakmile se zde ‘x’ rovná ‘5’, ukončí se příkazem ‘Break 2’ oba cykly.
Dále tu máme klíčové slovo ‘Continue’. To vám umožňuje kdykoli vyskočit z aktuálního průchodu a pokračovat dalším průchodem aktuálního cyklu. Je to jednodušší, než to zní:
For x.l = 1 To 10
If x = 5
Continue
EndIf
Debug x
Next
Zde vidíte, že když se ‘x’ rovná ‘5’ (v pátém průchodu), použije se klíčové slovo ‘Continue’. Program tím vyskočí z průchodu a pokračuje od začátku cyklu šestým průchodem, v němž se ‘x’ rovná ‘6’. Kvůli tomuto skoku a pokračování cyklu si v okně Debug Output všimnete, že se ‘5’ nikdy nevypsala, protože v tomto průchodu program vyskočil z cyklu dřív, než se provedl řádek ‘Debug x’.
Cykly lze v programování využít k nejrůznějším účelům, především k omezení zdlouhavého opakujícího se kódu a k rychlému procházení obrovského množství dat. Doufám, že teď už máte představu o tom, jak je lze používat.
5Další datové struktury
V této kapitole vysvětlím, jak vytvářet a používat další způsoby ukládání a uspořádání dat, například uživatelem definované struktury, pole a spojové seznamy. Datové struktury tohoto druhu jsou pro programování aplikací i her nezbytné, protože umožňují snadnější a rychlejší přístup k mnoha hodnotám vzájemně souvisejících i nesouvisejících dat. Jako vždy najdete u všeho podrobné vysvětlení a řadu příkladů.
Struktury
Už dříve, v kapitole 2, jsem vás seznámil s vestavěnými typy Byte, Character, Word, Long, Quad, Float, Double a String. Pomocí klíčového slova ‘Structure’ si můžete definovat vlastní strukturovaný typ a ten pak přiřadit proměnné. Vytvoření vlastní strukturované proměnné se hodí, když potřebujete seskupit mnoho souvisejících proměnných pod jeden název struktury. Zmateni? Pak se podívejme na příklad struktury, která obsahuje několik polí (fields):
Structure PERSONALDETAILS
FirstName.s
LastName.s
Home.s
EndStructure
Me.PERSONALDETAILS
Me\FirstName = "Gary"
Me\LastName = "Willoughby"
Me\Home = "A House"
Debug "First Name: " + Me\FirstName
Debug "Last Name: " + Me\LastName
Debug "Home: " + Me\Home
Zde se klíčovým slovem ‘Structure’ vytvoří struktura ‘PERSONALDETAILS’. Poté se definují součásti struktury, a to přesně stejným způsobem jako běžné proměnné. Klíčové slovo ‘EndStructure’ vymezuje konec nové struktury. Jakmile je struktura deklarována, je okamžitě připravena k použití. Tento strukturovaný typ přiřadíme proměnné přesně stejně, jako jí přiřazujeme jakýkoli jiný typ, takto:
Me.PERSONALDETAILS
Zde se proměnná jmenuje ‘Me’ a její typ je ‘PERSONALDETAILS’. K přiřazování hodnot jednotlivým proměnným (někdy se jim říká pole) uvnitř nové strukturované proměnné ‘Me’ používáme znak ‘\’. Pokud se podíváte na delší příklad, uvidíte, že znak ‘\’ se používá i k čtení dat z jednotlivých polí, takto:
Father.PERSONALDETAILS
Father\FirstName = "Peter"
Debug Father\FirstName
V tomto malém příkladu vytvoříme novou strukturovanou proměnnou ‘Father’ s uživatelem definovaným strukturovaným typem ‘PERSONALDETAILS’. Poli ‘FirstName’ uvnitř ‘Father’ přiřadíme hodnotu ‘Peter’. Tuto hodnotu pak vypíšeme do okna Debug Output (výstup ladění).
Možná vám to ještě nedošlo, ale struktury jsou neuvěřitelně užitečné. V aplikacích mohou pomoci popsat cokoli od osobních záznamů po souřadnice oken, ve hrách s jejich pomocí můžete popsat třeba střely nebo vesmírné lodě se všemi souvisejícími hodnotami.
Paměťové nároky
Velikost strukturované proměnné v paměti závisí na proměnných polí použitých v původní definici struktury. Ve struktuře ‘PERSONALDETAILS’ jsou definována tři pole typu String, každé o velikosti 4 bajty (velikosti typů String najdete na obr. 3 v kapitole 2). Nově deklarovaná proměnná ‘Me’ tedy zabírá v paměti 12 bajtů (3 x 4 bajty). Můžeme si to ověřit vypsáním hodnoty, kterou vrátí příkaz ‘SizeOf()’.
Structure PERSONALDETAILS
FirstName.s
LastName.s
Home.s
EndStructure
Debug SizeOf(PERSONALDETAILS)
Zde ‘SizeOf()’ vrátí hodnotu ‘12’, což je počet bajtů, které tato struktura zabírá v paměti.
Dědění polí z jiné struktury
Struktury mohou také dědit pole z jiné struktury pomocí nepovinného klíčového slova ‘Extends’.
Structure PERSONALDETAILS
FirstName.s
LastName.s
Home.s
EndStructure
Structure FULLDETAILS Extends PERSONALDETAILS
Address.s
Country.s
ZipCode.s
EndStructure
User.FULLDETAILS
User\FirstName = "John"
User\LastName = "Smith"
User\Home = "A House"
User\Address = "A Street"
User\Country = "UK"
User\ZipCode = "12345"
Debug "Users First Name: " + User\FirstName
Debug "Users Last Name: " + User\LastName
Debug "Users Home: " + User\Home
Debug "Users Address: " + User\Address
Debug "Users Country: " + User\Country
Debug "Users Zip Code: " + User\ZipCode
V tomto příkladu struktura ‘FULLDETAILS’ při svém vytvoření rozšiřuje strukturu ‘PERSONALDETAILS’ a dědí všechna její pole. Tato pole se pak v nové struktuře objeví jako první. Nově vytvořený strukturovaný typ přiřadíme proměnné ‘User’ a poté přiřadíme hodnoty všem jejím polím. Ty pak otestujeme vypsáním jejich hodnot do okna Debug Output.
Sjednocení ve strukturách
Sjednocení ve strukturách (structure unions) jsou způsobem, jak šetřit paměť: skupiny proměnných uvnitř struktury jsou nuceny sdílet tutéž adresu v paměti. Na seznámení s tímto tématem je teď možná ještě příliš brzy, ale kvůli úplnosti jsem ho sem zařadil. Abyste lépe pochopili, jak sjednocení fungují, můžete si přečíst kapitolu 13 (Ukazatele). Zde je jednoduchý příklad:
Structure UNIONSTRUCTURE
StructureUnion
One.l
Two.l
Three.l
EndStructureUnion
EndStructure
Debug SizeOf(UNIONSTRUCTURE)
UnionVariable.UNIONSTRUCTURE
UnionVariable\One = 123
Debug UnionVariable\One
UnionVariable\Three = 456
Debug UnionVariable\One
Při deklaraci struktury ‘UNIONSTRUCTURE’ jsme klíčovými slovy ‘StructureUnion’ a ‘EndStructureUnion’ obklopili proměnné, které mají používat stejnou oblast paměti. Když tento malý program spustíme, první příkaz Debug vypíše do okna Debug Output ‘4’ (bajty). Je to proto, že v této struktuře jsou tři proměnné, které všechny sdílejí totéž místo v paměti, takže se vrátí velikost pouze jedné proměnné typu Long.
Dále v programu přiřadíme proměnné ‘UnionVariable’ typ ‘UNIONSTRUCTURE’, poli ‘UnionVariable\One’ přiřadíme hodnotu ‘123’ a vypíšeme ji. Pak přiřadíme poli ‘UnionVariable\Three’ zcela novou hodnotu ‘456’, ale protože toto pole sdílí totéž místo v paměti jako ostatní pole, můžeme k této hodnotě přistoupit přes kterýkoli jiný název pole. V tomto případě znovu vypíšeme do okna Debug Output hodnotu ‘UnionVariable\One’ a ta podle očekávání zobrazí sdílenou hodnotu ‘UnionVariable\Three’.
Struktury mohou obsahovat také takzvaná statická pole, ale než tyto znalosti uplatníme na struktury, musím nejprve vysvětlit pole. Pole i statická pole jsou podrobně vysvětlena v následující části.
Pole
Pole (array) v PureBasicu může obsahovat uživatelem určený počet proměnných stejného datového typu. K jednotlivým proměnným v poli se přistupuje pomocí indexu, a to souvislou řadou celých čísel. Pole lze definovat i tak, aby místo standardních typů proměnných PureBasicu obsahovala strukturované proměnné. Tato část vás naučí vše, co potřebujete o polích v PureBasicu vědět.
Klíčové slovo ‘Dim’
Pole se v PureBasicu vytvářejí pomocí klíčového slova ‘Dim’, jako v tomto příkladu:
Dim LongArray.l(2)
Vysvětlím tento řádek kódu trochu podrobněji. Nejprve klíčovým slovem ‘Dim’ sdělíme kompilátoru, že se chystáme definovat pole. Pak novému poli dáme název – v tomto případě jsem ho nápaditě nazval ‘LongArray’. Za názvem přiřadíme poli typ, podobně jako u proměnných, pomocí přípony typu. Zde jsem použil příponu ‘.l’, která určuje, že jde o pole typu Long. Po určení typu musíme definovat, kolik indexů má pole obsahovat. Číslo posledního indexu zadáváme v závorkách. Ve výše uvedeném příkladu jsme jako poslední index uvedli ‘2’, takže nové pole má ve skutečnosti tři indexy, protože indexy pole vždy začínají od nuly. Jakmile je pole vytvořeno, každý index obsahuje proměnnou typu Long.
Takovému jednoduchému poli se někdy říká jednorozměrné, protože k přiřazení i získání všech jeho hodnot stačí jediný index. V tomto úplnějším příkladu pole definujeme a přiřadíme hodnoty jeho indexům:
Dim LongArray.l(2)
LongArray(0) = 10
LongArray(1) = 25
LongArray(2) = 30
Debug LongArray(0) + LongArray(1)
Debug LongArray(1) * LongArray(2)
Debug LongArray(2) - LongArray(0)
Po přiřazení hodnot jsme do okna Debug Output vypsali několik testů s hodnotami uloženými na indexech pole. Jako první se například vypíše výsledek ‘10 + 25’, což jsou hodnoty uložené na indexech ‘0’ a ‘1’. Poté se vypíšou také výsledky ‘25 * 30’ a ‘30 - 10’. Indexy pole lze vyjádřit i pomocí proměnných nebo výrazů.
LastIndex.l = 2
FirstIndex.l = 0
Dim StringArray.s(LastIndex)
StringArray(FirstIndex) = "One is one and all alone"
StringArray(FirstIndex + 1) = "Two, two, the lily-white boys"
StringArray(FirstIndex + 2) = "Three, three, the rivals"
Debug StringArray(FirstIndex)
Debug StringArray(FirstIndex + 1)
Debug StringArray(FirstIndex + 2)
Zde jsme definovali pole se třemi indexy, z nichž každý obsahuje proměnnou typu String (všimněte si přípony ‘.s’ připojené k názvu pole v příkazu ‘Dim’). Poslední index nového pole jsme určili proměnnou ‘LastIndex’. Pak jsme pomocí proměnné ‘FirstIndex’ přiřadili řetězec prvnímu indexu pole a v dalších přiřazeních jsme použili výraz s operátorem sčítání. Stejnou techniku (výraz jako index) jsme použili i při vypisování výsledků z různých indexů pole do okna Debug Output. Grafické znázornění výše uvedeného pole najdete na obr. 16.
| Index | Hodnota |
|---|---|
| 0 | One is one and all alone |
| 1 | Two, two, the lily-white boys |
| 2 | Three, three, the rivals |
Obr. 16: Jednorozměrné pole řetězců
Protože pole jsou úhledně uspořádána podle indexů, lze je pomocí cyklů velmi rychle procházet. Jen abych vám udělal chuť, zde je příklad pole s tisícem indexů: každému indexu se cyklem ‘For’ přiřadí hodnota a druhým cyklem ‘For’ se pak hodnota každého indexu vypíše do okna Debug Output.
Dim TestArray.l(999)
For x = 0 To 999
TestArray(x) = x
Next x
For x = 0 To 999
Debug TestArray(x)
Next x
Spusťte ho a podívejte se do okna Debug Output. Jak vidíte, s poli lze velmi rychle nastavit i přečíst třeba tisíc hodnot.
Vícerozměrná pole
Vícerozměrná pole se nejlépe popisují jako tabulky se sloupci a řádky. Chcete-li vytvořit vícerozměrné pole, jednoduše zadejte počet sloupců a řádků, které má pole mít. V následujícím příkladu vytvoříme pole ‘Animals’, které obsahuje tři indexy a každý z nich obsahuje další tři indexy.
Dim Animals.s(2, 2)
Animals(0, 0) = "Sheep"
Animals(0, 1) = "4 Legs"
Animals(0, 2) = "Baaa"
Animals(1, 0) = "Cat"
Animals(1, 1) = "4 Legs"
Animals(1, 2) = "Meow"
Animals(2, 0) = "Parrot"
Animals(2, 1) = "2 Legs"
Animals(2, 2) = "Screech"
Debug Animals(0, 0) + " has " + Animals(0, 1) + " And says " + Animals(0, 2)
Debug Animals(1, 0) + " has " + Animals(1, 1) + " And says " + Animals(1, 2)
Debug Animals(2, 0) + " has " + Animals(2, 1) + " And says " + Animals(2, 2)
Po definici pole přiřadíme hodnoty jeho indexům. Protože pole ‘Animals’ má dva indexy, pomocí nichž se data přiřazují a čtou, nazývá se dvourozměrné. Dvourozměrná pole snadno pochopíte, když si je představíte jako dvourozměrnou tabulku složenou z řádků a sloupců. Obr. 17 ukazuje pole ‘Animals’ podobně, jako obr. 16 ukazuje jednorozměrné pole. Jsou na něm vidět řádky a sloupce, k nimž lze přistupovat pomocí dvou indexů, které dvourozměrné pole vyžaduje.
| Index | 0 | 1 | 2 |
|---|---|---|---|
| 0 | Sheep |
4 Legs |
Baaa |
| 1 | Cat |
4 Legs |
Meow |
| 2 | Parrot |
2 Legs |
Screech |
Obr. 17: Dvourozměrné pole řetězců
S obr. 17 jako vodítkem teď vidíme, jak snadno lze přiřazovat a číst hodnoty různých indexů. Pokud například chci vypsat do okna Debug Output hodnotu na řádkovém indexu ‘1’ a sloupcovém indexu ‘2’, napíšeme:
Debug Animals(1, 2)
Tím by se měl vypsat text ‘Meow’. Pokud byste chtěli nahradit celý řádek, můžeme to udělat takto:
Animals(0, 0) = "Tripod"
Animals(0, 1) = "3 Legs"
Animals(0, 2) = "Oo-la"
Tím se v poli ‘Animals’ na řádkovém indexu ‘0’ nahradí řetězce ‘Sheep’, ‘4 Legs’ a ‘Baaa’ řetězci ‘Tripod’, ‘3 Legs’ a ‘Oo-la’. Obr. 17 teď vypadá jako obr. 18 – všimněte si změněného prvního řádku.
| Index | 0 | 1 | 2 |
|---|---|---|---|
| 0 | Tripod |
3 Legs |
Oo-la |
| 1 | Cat |
4 Legs |
Meow |
| 2 | Parrot |
2 Legs |
Screech |
Obr. 18: Dvourozměrné pole řetězců (upravené)
Vícerozměrná pole lze vysvětlit i jinak: jsou to pole uvnitř polí. Stačí si představit, že každý index pole obsahuje další pole, a máte představu o tom, co jsou vícerozměrná pole. Kolik polí je obsaženo v každém indexu prvního rozměru, závisí na tom, jak bylo pole původně definováno.
V následujícím příkladu ukazuji, jak definovat jedno-, dvou-, tří-, čtyř- a pětirozměrná pole:
Dim Animals.s(5)
Dim Animals.s(5, 4)
Dim Animals.s(2, 5, 3)
Dim Animals.s(1, 5, 4, 5)
Dim Animals.s(2, 3, 6, 2, 3)
Od tří rozměrů výš začne z toho trochu bolet hlava, ale budete-li mít na paměti vysvětlení „pole v poli“, měli byste si poradit. Přestože maximální počet rozměrů, který lze poli přidělit, je dvě stě padesát pět (255), pole s více než dvěma či třemi rozměry se v běžné programátorské praxi používají jen zřídka.
Pole strukturovaného typu
Dosud jsme viděli, jak definovat různá pole jen se standardními typy PureBasicu, ale pole můžeme příkazem ‘Dim’ vytvořit i se strukturou. Podívejme se na jednoduchý příklad s jednorozměrným polem:
Structure FISH
Kind.s
Weight.s
Color.s
EndStructure
Dim FishInTank.FISH(2)
FishInTank(0)\Kind = "Clown Fish"
FishInTank(0)\Weight = "4 oz."
FishInTank(0)\Color = "Red, White and Black"
FishInTank(1)\Kind = "Box Fish"
FishInTank(1)\Weight = "1 oz."
FishInTank(1)\Color = "Yellow"
FishInTank(2)\Kind = "Sea Horse"
FishInTank(2)\Weight = "2 oz."
FishInTank(2)\Color = "Green"
Debug FishInTank(0)\Kind+" "+FishInTank(0)\Weight+" "+FishInTank(0)\Color
Debug FishInTank(1)\Kind+" "+FishInTank(1)\Weight+" "+FishInTank(1)\Color
Debug FishInTank(2)\Kind+" "+FishInTank(2)\Weight+" "+FishInTank(2)\Color
Zde po definici struktury ‘FISH’ definujeme pole klíčovým slovem ‘Dim’ a jako typ pole použijeme ‘FISH’, přesně tak, jako jsme jako typ pole ‘Animals’ použili ‘.s’ (String). Jako poslední index tohoto pole jsem opět použil ‘2’. Přiřazování hodnot polím struktury na jednotlivých indexech pole je neuvěřitelně jednoduché. Jen spojíme syntaxi přiřazování do polí a do struktur, takto:
FishInTank(0)\Kind = "Clown Fish"
Rozložme si to na snadno pochopitelné kousky. Nejprve je tu název pole, v tomto případě ‘FishInTank’. Pak následuje aktuální index v závorkách, v tomto případě index ‘0’. Dále znakem ‘\’ přistoupíme k poli ‘Kind’ uvnitř struktury ‘FISH’, která byla přiřazena poli ‘FishInTank’. Pak operátorem ‘=’ přiřadíme tomuto poli řetězcovou hodnotu. Jednoduché! Chceme-li hodnotu, kterou jsme právě přiřadili, přečíst, použijeme přesně stejnou syntaxi, jen bez části s přiřazením, takto:
Debug FishInTank(0)\Kind
Pokud potřebujeme přiřadit nebo přečíst hodnotu z jiného indexu, uděláme to stejně jako u pole:
Debug FishInTank(0)\Kind
Debug FishInTank(1)\Kind
Debug FishInTank(2)\Kind
Tím bychom vypsali pole ‘Kind’ ze všech indexů pole ‘FishInTank’. Chceme-li přiřadit nebo přečíst kterékoli z ostatních polí struktury, použijeme prostě jejich názvy:
Debug FishInTank(1)\Kind
Debug FishInTank(1)\Weight
Debug FishInTank(1)\Color
Zde vypíšeme do okna Debug Output všechna různá pole struktury na indexu ‘1’. Pro lepší pochopení se podívejte na obr. 19, kde je pole ‘FishInTank’ znázorněno graficky.
| Index | Struktura ‘FISH’ |
|---|---|
| 0 | Kind:Clown FishWeight:4 oz.Colour:Red, White and Black |
| 1 | Kind:Box FishWeight:1 oz.Colour:Yellow |
| 2 | Kind:Sea HorseWeight:2 oz.Colour:Green |
Obr. 19: Jednorozměrné pole strukturovaného typu
Stejně jako u polí standardních typů můžete i se strukturou jako typem pole definovat vícerozměrná pole. Získáte tak přístup k jednotlivým polím struktury na každém indexu, který vícerozměrné pole nabízí. Vícerozměrné pole strukturovaného typu definujeme přesně stejně jako jednorozměrné pole strukturovaného typu, jen přidáme další rozměry.
Zde je příklad, jak definovat dvourozměrné pole strukturovaného typu:
Structure FISH
Kind.s
Weight.s
Color.s
EndStructure
Dim FishInTank.FISH(2, 2)
...
K tomuto dvourozměrnému poli už další kód vypisovat nebudu, protože by byl příliš dlouhý. Místo toho se podívejte na obr. 20, kde je smyšlené dvourozměrné pole strukturovaného typu.
| Index | 0 | 1 | 2 |
|---|---|---|---|
| 0 | Kind:Clown Fish Weight:4 oz. Colour:Red, White and Black |
Kind:Box Fish Weight:1 oz. Colour:Yellow |
Kind:Sea Horse Weight:2 oz. Colour:Green |
| 1 | Kind:Parrot Fish Weight:5 oz. Colour:Red |
Kind:Angel Fish Weight:4 oz. Colour:Orange |
Kind:Shrimp Weight:1 oz. Colour:Pink |
| 2 | Kind:Gold Fish Weight:2 oz. Colour:Orange |
Kind:Lion Fish Weight:8 oz. Colour:Black and White |
Kind:Shark Weight:1 lb. Colour:Grey |
Obr. 20: Dvourozměrné pole strukturovaného typu
Abychom z takového pole přečetli hodnotu, musíme zadat dva indexy a název pole struktury, například takto:
Debug FishInTank(1, 1)\Kind
Tím by se do okna Debug Output vypsal text ‘Angel Fish’. Pokud bychom chtěli tuto nebo jiné hodnoty změnit, použijeme k přístupu k tomuto místu v poli stejný postup:
FishInTank(1, 1)\Kind = “Devil Fish”
FishInTank(1, 1)\Weight = “6 oz.”
FishInTank(1, 1)\Color = “Dark Red”
Tím by se změnila všechna pole struktury ‘FISH’ uložené uprostřed pole, na indexech ‘1, 1’. Ukazuje to obr. 21.
Jak vidíte, pole tohoto typu jsou nesmírně šikovná, i když trochu složitá (zvlášť když překročíte tři rozměry), ale znalost toho, jak fungují, vám později při programování poskytne výhodu.
| Index | 0 | 1 | 2 |
|---|---|---|---|
| 0 | Kind:Clown Fish Weight:4 oz. Colour:Red, White and Black |
Kind:Box Fish Weight:1 oz. Colour:Yellow |
Kind:Sea Horse Weight:2 oz. Colour:Green |
| 1 | Kind:Parrot Fish Weight:5 oz. Colour:Red |
Kind:Devil Fish Weight:6 oz. Colour:Dark Red |
Kind:Shrimp Weight:1 oz. Colour:Pink |
| 2 | Kind:Gold Fish Weight:2 oz. Colour:Orange |
Kind:Lion Fish Weight:8 oz. Colour:Black and White |
Kind:Shark Weight:1 lb. Colour:Grey |
Obr. 21: Dvourozměrné pole strukturovaného typu (upravené)
Ve svých programech budete zatím nejspíš používat jen jednorozměrná pole strukturovaného typu, ale znalost toho, jak fungují vícerozměrná pole strukturovaného typu, vám pomůže dobře porozumět pokročilejšímu kódu.
Předefinování již vytvořených polí
Standardní pole v PureBasicu nejsou zcela statická, což znamená, že je lze předefinovat dvěma různými způsoby. Prvním je znovu použít příkaz ‘Dim’, který pole předefinuje, ale přitom zničí všechna data, která mu byla dříve přiřazena. Druhým je příkaz ‘ReDim’, který pole předefinuje, ale dosavadní data zachová. Zde jsou příklady obou chování. Nejprve se podívejme na předefinování pole příkazem ‘Dim’:
Dim Dogs.s(2)
Dogs(0) = "Jack Russell"
Dogs(1) = "Alaskan Husky"
Dogs(2) = "Border Collie"
Debug Dogs(0)
Debug Dogs(1)
Debug Dogs(2)
Dim Dogs.s(2)
Debug Dogs(0)
Debug Dogs(1)
Debug Dogs(2)
Zde jsem po prvotním vytvoření pole a přiřazení dat znovu použil příkaz ‘Dim’ a předefinoval pole se stejným počtem indexů jako předtím. Po druhé definici si všimnete, že příkazy ‘Debug’ z nově definovaného pole nevracejí nic. Je to proto, že při předefinování byla všechna data zničena. Toto ničení dat však může mít i dobré využití. Pokud bych například potřeboval uvolnit paměť používanou polem, stačilo by ho předefinovat s nulou (0) jako maximálním indexem, čímž by se uvolnila veškerá paměť, která k němu patří. Při takovém předefinování polí musíte vždy použít stejný typ, jinak dojde k chybě.
Zde je příklad, jak při předefinování pole příkazem ‘ReDim’ zachovat data:
Dim Dogs.s(2)
Dogs(0) = "Jack Russell"
Dogs(1) = "Alaskan Husky"
Dogs(2) = "Border Collie"
For x.l = 0 To 2
Debug Dogs(x)
Next x
Debug ""
ReDim Dogs.s(4)
Dogs(3) = "Yorkshire Terrier"
Dogs(4) = "Greyhound"
For x.l = 0 To 4
Debug Dogs(x)
Next x
Zde jsem pole předefinoval příkazem ‘ReDim’, ale tentokrát jsem mu kromě předefinování přidal ještě dva indexy. Těmto dvěma novým indexům (‘3’ a ‘4’) se přiřadí data a pak se data celého pole vypíšou do okna Debug Output. Všimněte si, že data z prvotního vytvoření se neztratila. Mějte však na paměti, že kdybych příkazem ‘ReDim’ předefinoval pole s menším počtem indexů, než mělo dříve, data na odstraněných indexech by se samozřejmě ztratila. Pokud navíc příkazem ‘ReDim’ předefinováváte vícerozměrné pole, lze změnit velikost pouze posledního rozměru. U takového příkazu jazyka Basic je to standardní chování.
Pravidla pro používání polí
Přestože jsou pole velmi flexibilní, při jejich používání je třeba vzít v úvahu několik pravidel. Měli byste je dodržovat, když pole ve svých programech používáte.
1). Pokud je pole předefinováno příkazem ‘Dim’, jeho dosavadní data se ztratí. 2). Pokud je pole předefinováno příkazem ‘ReDim’, jeho dosavadní data se zachovají. 3). Pole se může skládat pouze z jednoho typu proměnné (strukturovaného nebo standardního typu). 4). Pole mohou být Global, Protected, Static a Shared. Viz kapitola 6 (Obor platnosti v programu). 5). Velikost pole je omezena pouze pamětí RAM nainstalovanou v daném počítači. 6). Vícerozměrná pole mohou mít 255 rozměrů. 7). Pole lze definovat dynamicky, velikost rozměru lze určit proměnnou nebo výrazem. 8). Při určování velikosti rozměru zadáváte číslo posledního indexu (všechny indexy začínají od ‘0’). 9). Ve vícerozměrných polích mohou mít rozměry různé velikosti.
Statická pole uvnitř struktur
Statická pole uvnitř struktur se od běžných polí popsaných výše trochu liší. Statická pole jsou ze své podstaty statická, a proto je po jejich definování nelze měnit. Pole tohoto typu navíc existují pouze uvnitř struktur.
Pro statická pole platí také jiná sada pravidel, kterou je třeba při jejich používání brát v úvahu:
1). Jakmile je statické pole definováno, jeho vnitřní strukturu nelze měnit. 2). Statická pole (stejně jako struktury) nelze předefinovat. 3). Mohou se skládat pouze z jednoho typu proměnné (strukturovaného nebo standardního typu). 4). Velikost pole je omezena pouze pamětí RAM nainstalovanou v daném počítači. 5). Statická pole mohou mít pouze jeden rozměr. 6). Lze je definovat dynamicky, velikost rozměru lze určit proměnnou nebo výrazem. 7). Při určování velikosti rozměru zadáváte počet indexů, které má pole obsahovat, nikoli poslední index. 8). Ke statickým polím lze přistupovat pouze prostřednictvím strukturované proměnné, v níž jsou definována.
Když už znáte hlavní pravidla, ukážu vám příklad jejich použití:
Structure FAMILY
Father.s
Mother.s
Children.s[2]
Surname.s
EndStructure
Family.FAMILY
Family\Father = "Peter"
Family\Mother = "Sarah"
Family\Children[0] = "John"
Family\Children[1] = "Jane"
Family\Surname = "Smith"
Debug "Family Members:"
Debug Family\Father + " " + Family\Surname
Debug Family\Mother + " " + Family\Surname
Debug Family\Children[0] + " " + Family\Surname
Debug Family\Children[1] + " " + Family\Surname
V tomto příkladu má struktura ‘FAMILY’ pole ‘Children’, které je statickým polem řetězců. Při definici tohoto pole jsme použili číslo ‘2’. To určuje, že toto statické pole bude obsahovat dva indexy. Toto chování je zcela odlišné od standardních polí, u nichž při vytvoření zadáváte poslední index. Naše nové statické pole má tedy dva indexy, ‘0’ a ‘1’. Dále v příkladu přiřadím hodnoty všem polím strukturované proměnné ‘Family’, včetně obou indexů statického pole ‘Children’. Všimnete si, že statická pole mají pro přiřazování a čtení dat trochu odlišnou syntaxi: místo obvyklých kulatých závorek používají hranaté.
Přiřazení dat do statického pole řetězců (s hranatými závorkami):
Family\Children[0] = "John"
Přiřazení dat do standardního pole typu Long (s kulatými závorkami):
LongArray(0) = 10
Všimnete si také, že při definici statického pole nemusíte použít žádné klíčové slovo jako ‘Dim’. Stačí přidat hranaté závorky na konec pole uvnitř struktury. V hranatých závorkách zadáte, kolik indexů má nově vytvořené statické pole mít. Ve výše uvedené struktuře ‘FAMILY’ jsme k vytvoření statického pole použili typ String, ale můžete použít kterýkoli vestavěný typ PureBasicu, nebo dokonce jinou strukturu!
Podívejme se na další jednoduchý příklad:
Structure EMPLOYEES
EmployeeName.s
EmployeeClockNumber.l
EmployeeAddress.s
EmployeeContactNumbers.l[2]
EndStructure
Dim Company.EMPLOYEES(9)
Company(0)\EmployeeName = "Bruce Dickinson"
Company(0)\EmployeeClockNumber = 666
Company(0)\EmployeeAddress = "22 Acacia Avenue"
Company(0)\EmployeeContactNumbers[0] = 0776032666
Company(0)\EmployeeContactNumbers[1] = 0205467746
Company(1)\EmployeeName = "Adrian Smith"
Company(1)\EmployeeClockNumber = 1158
...
Zde vytvořím uživatelem definovanou strukturu ‘EMPLOYEES’, která popisuje záznam o zaměstnanci malé firmy, a pak vytvořím standardní pole, které pojme deset takových záznamů (pamatujte, že u standardního pole zadáváte poslední index a indexy začínají od ‘0’). Uvnitř struktury ‘EMPLOYEES’ jsem pro uložení dvou kontaktních telefonních čísel použil statické pole typu Long. Pak jsem začal definovat jednotlivé záznamy o zaměstnancích, počínaje ‘Company(0)...’, dále ‘Company(1)...’ a tak dále. Příklad ve skutečnosti nedokončuji, protože nechci zbytečně zabíhat do podrobností, ale vidíte, kam tím mířím a jak všechno funguje.
Spojové seznamy
Spojové seznamy se podobají polím v tom, že dokážou pod jedním názvem odkazovat na spoustu dat. Od polí se však liší tím, že k přiřazování a čtení dat nepoužívají index.
Tyto seznamy jsou jako kniha, v níž můžete data listovat od začátku do konce, nebo jen nalistovat určitou stránku a číst data odtamtud. Spojové seznamy jsou také zcela dynamické, což znamená, že mohou růst nebo se zmenšovat podle toho, kolik dat v nich potřebujete mít. Zvětšením spojového seznamu nijak nepoškodíte ani nezměníte ostatní data, která obsahuje, a prvky do seznamu můžete bezpečně přidávat na libovolné potřebné místo.
Spojové seznamy jsou skvělým způsobem, jak ukládat a uspořádávat data neznámé délky, a lze je řadit několika způsoby. K dispozici je také vestavěná knihovna ‘Linked List’, která poskytuje funkce pro přidávání a mazání prvků a pro jejich prohazování. Ve vestavěné knihovně ‘Sort’ jsou navíc dvě funkce určené výhradně k řazení spojových seznamů – zmíním se o nich později. Obecný přehled vestavěných příkazů PureBasicu a úvod do nich najdete později v kapitole 7.
Klíčové slovo ‘NewList’
Spojové seznamy se v PureBasicu vytvářejí pomocí klíčového slova ‘NewList’, jako v tomto příkladu:
NewList Fruit.s()
Definice spojového seznamu se velmi podobá definici pole příkazem ‘Dim’. Nejprve klíčovým slovem ‘NewList’ sdělíme kompilátoru, že se chystáme definovat spojový seznam. Dále novému seznamu určíme název, v tomto případě ‘Fruit’. Po zadání názvu definujeme jeho typ, kterým je v tomto případě opět String. Definici seznamu pak zakončíme závorkami. V tomto malém příkladu si všimnete, že v závorkách nejsou definovány žádné indexy. Je to proto, že spojové seznamy je nepotřebují: jsou dynamické a s přidáváním prvků rostou. Podívejme se, jak do nového seznamu přidávat prvky. Zde je úplnější příklad:
NewList Fruit.s()
AddElement(Fruit())
Fruit() = "Banana"
AddElement(Fruit())
Fruit() = "Apple"
Protože spojové seznamy nemají indexy, může vám jejich používání zpočátku připadat trochu zvláštní, protože nemusíte vědět, kde v seznamu se právě nacházíte. Ve výše uvedeném příkladu jsem do seznamu ‘Fruit()’ přidal dva nové prvky. K tomu jsem použil funkci ‘AddElement()’ z vestavěné knihovny Linked List. Když touto funkcí přidáte nový prvek, nejenže se automaticky vytvoří nový prvek, ale název spojového seznamu zároveň začne ukazovat na tento nově vytvořený prázdný prvek. K přiřazení dat do seznamu tedy stačí použít jeho název – všimněte si, že závorky stále používáme:
Fruit() = "Banana"
Když funkcí ‘AddElement()’ přidáme další prvek, proběhne přesně stejný proces. Nejprve se vytvoří nový prvek a pak název spojového seznamu opět ukazuje na nově vytvořený prázdný prvek. Data do nového prvku pak přidáme přesně stejným způsobem:
Fruit() = "Apple"
Mohlo by se zdát, že je to špatně, protože text ‘Apple’ přiřazujeme stejnému názvu, kterému jsme přiřadili text ‘Banana’. Protože jsme ale přidali nový prvek, název spojového seznamu ‘Fruit()’ ukazuje na nový prvek v seznamu. Kolik prvků seznam obsahuje, můžeme také kdykoli zjistit vestavěnou funkcí ‘CountList()’, takto:
Debug CountList(Fruit())
Pokud bychom výše uvedený kód spustili, vypsal by se do okna Debug Output počet prvků v seznamu ‘Fruit()’. V tomto případě by to bylo ‘2’.
Přidejme do tohoto seznamu ještě několik prvků a pak vypišme hodnoty všech prvků do okna Debug Output. Zde je opět úplný příklad:
NewList Fruit.s()
AddElement(Fruit())
Fruit() = "Banana"
AddElement(Fruit())
Fruit() = "Apple"
AddElement(Fruit())
Fruit() = "Pear"
AddElement(Fruit())
Fruit() = "Orange"
ForEach Fruit()
Debug Fruit()
Next
V tomto delším příkladu vytvoříme nový spojový seznam ‘Fruits()’, vytvoříme v něm čtyři prvky a každému přiřadíme vlastní hodnotu. Pak seznam projdeme cyklem ‘ForEach’ a hodnoty všech prvků vypíšeme do okna Debug Output. Klíčové slovo ‘ForEach’ slouží k definici cyklu, který se používá pouze pro spojové seznamy.
Obr. 22 podává stručný přehled příkazů pro spojové seznamy, které nabízí vestavěná knihovna ‘Linked List’. Tento přehled není úplnou referencí; je zde uveden jako stručné vodítko, abyste věděli, jaký příkaz v případě potřeby použít. Pokročilejší příkazy najdete v nápovědě PureBasicu.
| Funkce | Popis |
|---|---|
AddElement( List ()) |
Přidá do spojového seznamu prvek. |
ClearList( List ()) |
Odstraní ze seznamu všechny prvky. |
CountList( List ()) |
Spočítá prvky v seznamu. |
DeleteElement( List ()) |
Smaže aktuální prvek seznamu |
FirstElement( List ()) |
Přejde na první prvek seznamu. |
InsertElement( List ()) |
Vloží do seznamu další prvek před aktuální prvek, nebo na začátek seznamu, je-li seznam prázdný. |
LastElement( List ()) |
Přejde na poslední prvek seznamu. |
ListIndex( List ()) |
Vrátí pozici aktuálního prvku v seznamu. (Pozice prvků začínají od ‘0’.) |
NextElement( List ()) |
Přejde na další prvek seznamu. |
PreviousElement( List ()) |
Přejde na předchozí prvek seznamu. |
ResetList( List ()) |
Nastaví pozici v seznamu na ‘0’ a první prvek učiní aktuálním. |
SelectElement( List (), Position ) |
Učiní aktuálním prvek určený parametrem ‘Position’. |
Obr. 22: Vestavěná knihovna Linked List
Strukturované spojové seznamy
Když jsem vysvětlil standardní spojové seznamy, přejděme ke strukturovaným spojovým seznamům. Ty se velmi podobají polím strukturovaného typu v tom, že se místo vestavěného typu proměnné definují pomocí struktury. Ve výsledku tak můžete mít spojový seznam s dynamicky se měnící velikostí, který se tváří jako pole strukturovaného typu a roste či se zmenšuje podle toho, kolik informací potřebujete uložit. Podívejme se na jeden z předchozích příkladů, tentokrát ale přepsaný tak, aby používal strukturovaný spojový seznam.
Structure FISH
Kind.s
Weight.s
Color.s
EndStructure
NewList FishInTank.FISH()
AddElement(FishInTank())
FishInTank()\Kind = "Clown Fish"
FishInTank()\Weight = "4 oz."
FishInTank()\Color = "Red, White and Black"
AddElement(FishInTank())
FishInTank()\Kind = "Box Fish"
FishInTank()\Weight = "1 oz."
FishInTank()\Color = "Yellow"
AddElement(FishInTank())
FishInTank()\Kind = "Sea Horse"
FishInTank()\Weight = "2 oz."
FishInTank()\Color = "Green"
ForEach FishInTank()
Debug FishInTank()\Kind+" "+FishInTank()\Weight+" "+FishInTank()\Color
Next
Z tohoto příkladu vidíte, že po vytvoření seznamu se data přiřazují a čtou velmi podobně jako u pole strukturovaného typu. Hlavní rozdíl je ovšem v tom, že se nepoužívají indexy jako u polí. Pamatujte, že příkazem ‘AddElement(FishInTank())’ vytvoříte nový prvek se strukturou z původní definice. Tento příkaz pak přesune aktuální pozici v seznamu na tento nově vytvořený prvek. Novému strukturovanému prvku pak můžete bezpečně přiřadit data, takto:
FishInTank()\Kind = "Clown Fish"
FishInTank()\Weight = "4 oz."
FishInTank()\Color = "Red, White and Black"
Protože název ‘FishInTank()’ teď ukazuje na váš nový prvek, není potřeba používat index. K polím uvnitř tohoto strukturovaného prvku opět přistupujete znakem ‘\’. Na konci příkladu se opět použije cyklus ‘ForEach’, který data rychle a efektivně vypíše do okna Debug Output.
Výhody a nevýhody spojových seznamů?
Spojové seznamy jsou skvělé pro ukládání dat, když nevíte, kolik jich bude. Kdysi jsem například napsal program pro sledování výdajů domácnosti a k uchovávání údajů o těchto výdajích jsem použil strukturovaný spojový seznam. Díky spojovému seznamu místo pole bylo snazší data přidávat, mazat a řadit.
Při psaní programu jsem si říkal, že ho musím udělat dostatečně flexibilní, aby dokázal přijímat nové výdaje, jakmile se objeví, a mazat staré – pro případ, že si koupím nové auto nebo splatím půjčku a podobně. Se spojovými seznamy se to řeší velmi elegantně. Když potřebuji přidat záznam, použiji funkci ‘AddElement()’, a když potřebuji záznam smazat, použiji funkci ‘DeleteElement()’. Po přidání a smazání záznamů v seznamu pak všechna data přenesu do pěkného grafického uživatelského rozhraní (GUI), kde je uživatel vidí a může s nimi pracovat. O grafických rozhraních budu podrobněji mluvit v kapitole 9.
Spojové seznamy jsou flexibilnější než pole v tom, že se jejich velikost dá snadněji zvětšovat a zmenšovat, ale pole vždy spotřebují k uložení stejného množství dat méně paměti RAM než spojové seznamy. Je to proto, že pole jsou souvislé oblasti paměti, které na každý index spotřebují jen standardní množství RAM pro daný typ. Spojové seznamy se liší v tom, že každý prvek spotřebuje přibližně trojnásobek RAM oproti velikosti svého typu. Spojové seznamy totiž neleží v jednom souvislém kusu paměti a musí si uchovávat informace o tom, kde v RAM najít ostatní prvky. Na to pamatujte při práci s obrovským množstvím dat, protože při použití spojových seznamů mohou být vaše nároky na paměť až trojnásobné.
Řazení polí a spojových seznamů
Pole a spojové seznamy jsou skvělé pro ukládání nejrůznějších dat a tyto datové struktury lze snadno procházet a data z nich rychle získávat. Někdy však potřebujete data v poli nebo spojovém seznamu přeuspořádat tak, aby byla seřazena abecedně nebo číselně. Zde je několik příkladů, jak k řazení polí a spojových seznamů použít příkazy knihovny ‘Sort’ (Helpfile:Reference Manual->General Libraries->Sort).
Řazení standardního pole
Seřadit standardní pole je nesmírně jednoduché. Nejprve potřebujete pole naplněné hodnotami a pak ho seřadíte příkazem ‘SortArray()’. Zde je ukázka syntaxe:
SortArray(Array(), Options [, Start, End])
Prvním parametrem je pole, které se má seřadit. Všimněte si kulatých závorek za názvem pole – jsou nutné, aby se pole správně předalo jako parametr. Druhý parametr je volba, kterou určíte, jak chcete pole seřadit. Zde jsou možnosti pro druhý parametr:
‘0’ : Seřadí pole vzestupně s rozlišováním velkých a malých písmen. ‘1’ : Seřadí pole sestupně s rozlišováním velkých a malých písmen. ‘2’ : Seřadí pole vzestupně bez rozlišování velkých a malých písmen (‘A’ je totéž co ‘a’). ‘3’ : Seřadí pole sestupně bez rozlišování velkých a malých písmen (‘A’ je totéž co ‘a’).
Hranaté závorky kolem posledních dvou parametrů naznačují, že jsou nepovinné a při použití příkazu je nemusíte zadávat. Tyto dva poslední parametry slouží k určení rozsahu pozic v poli, v němž se má řazení provést.
S využitím výše uvedených informací můžeme celé pole seřadit vzestupně s rozlišováním velkých a malých písmen, a to takto:
Dim Fruit.s(3)
Fruit(0) = "Banana"
Fruit(1) = "Apple"
Fruit(2) = "Pear"
Fruit(3) = "Orange"
SortArray(Fruit(), 0)
For x.l = 0 To 3
Debug Fruit(x)
Next x
Řazení strukturovaného pole
To je o něco složitější, protože se k tomu používá o něco složitější příkaz pro řazení: ‘SortStructuredArray()’. Zde je ukázka syntaxe:
SortStructuredArray(Array(), Options, Offset, Type [, Start, End])
Prvním parametrem je název pole včetně závorek. Druhým jsou volby řazení, které jsou přesně stejné jako u příkazu ‘SortArray()’. Třetím parametrem je posun (offset, tj. pozice v rámci výchozí struktury) pole struktury, podle kterého chcete řadit. Ten získáte příkazem ‘OffsetOf()’. Příkaz ‘OffsetOf()’ vrací počet bajtů, o který je dané pole struktury posunuto od začátku struktury. Čtvrtý parametr určuje, jaký typ proměnné se na dříve předaném posunu nachází. Ve čtvrtém parametru můžete k popisu typu proměnné, podle které řadíte, použít vestavěné konstanty. Jsou to:
‘#PB_Sort_Byte’: pole struktury, podle kterého se řadí, je typu Byte (.b) ‘#PB_Sort_Character’: pole struktury, podle kterého se řadí, je typu Character (.c) ‘#PB_Sort_Word’: pole struktury, podle kterého se řadí, je typu Word (.w) ‘#PB_Sort_Long’: pole struktury, podle kterého se řadí, je typu Long (.l) ‘#PB_Sort_Quad’: pole struktury, podle kterého se řadí, je typu Quad (.q) ‘#PB_Sort_Float’: pole struktury, podle kterého se řadí, je typu Float (.f) ‘#PB_Sort_Double’: pole struktury, podle kterého se řadí, je typu Double (.d) ‘#PB_Sort_String’: pole struktury, podle kterého se řadí, je typu String (.s nebo $)
Poslední dva parametry tohoto příkazu jsou nepovinné a při jeho použití je nemusíte zadávat. Slouží k určení rozsahu pozic v poli, v němž se má řazení provést. S využitím výše uvedených informací můžeme celé strukturované pole seřadit vzestupně podle pole ‘Range’, takto:
Structure WEAPON
Name.s
Range.l
EndStructure
Dim Weapons.WEAPON(2)
Weapons(0)\Name = "Phased Plasma Rifle"
Weapons(0)\Range = 40
Weapons(1)\Name = "SVD-Dragunov Sniper Rifle"
Weapons(1)\Range = 3800
Weapons(2)\Name = "HK-MP5 Sub-Machine Gun"
Weapons(2)\Range = 300
SortStructuredArray(Weapons(), 0, OffsetOf(WEAPON\Range), #PB_Sort_Long)
For x.l = 0 To 2
Debug Weapons(x)\Name + " : " + Str(Weapons(x)\Range)
Next x
V tomto příkladu jsem jako pole, podle kterého se strukturované pole seřadí, zvolil ‘Range’. V příkazu pro řazení jsem ho tedy určil posunem ‘OffsetOf(WEAPON\Range)’ a konstantou ‘#PB_Sort_Long’ jsem příkazu sdělil, že jde o pole struktury typu Long.
Řazení standardního spojového seznamu
Seřadit standardní spojový seznam je nesmírně jednoduché. Nejprve potřebujete spojový seznam naplněný hodnotami a pak ho seřadíte příkazem ‘SortList()’. Zde je ukázka syntaxe:
SortList(ListName(), Options [, Start, End])
Prvním parametrem je spojový seznam, který se má seřadit. Všimněte si kulatých závorek za názvem seznamu – jsou nutné, aby se spojový seznam správně předal jako parametr. Druhým jsou volby řazení, které jsou přesně stejné jako u příkazu ‘SortArray()’. Poslední dva parametry slouží k určení rozsahu pozic ve spojovém seznamu, v němž se má řazení provést.
S využitím výše uvedených informací můžeme celý spojový seznam seřadit vzestupně s rozlišováním velkých a malých písmen, a to takto:
NewList Fruit.s()
AddElement(Fruit())
Fruit() = "Banana"
AddElement(Fruit())
Fruit() = "Apple"
AddElement(Fruit())
Fruit() = "Orange"
SortList(Fruit(), 0)
ForEach Fruit()
Debug Fruit()
Next
Řazení strukturovaného spojového seznamu
Seřadit strukturovaný spojový seznam je o něco složitější, protože se k tomu používá o něco složitější příkaz pro řazení: ‘SortStructuredList()’. Zde je ukázka syntaxe tohoto příkazu:
SortStructuredList(List(), Options, Offset, Type [, Start, End])
Prvním parametrem je název spojového seznamu včetně závorek. Druhým jsou volby řazení, které jsou přesně stejné jako u příkazu ‘SortArray()’. Třetím parametrem je posun (offset, tj. pozice v rámci výchozí struktury) pole struktury, podle kterého chcete řadit. Ten získáte příkazem ‘OffsetOf()’. Čtvrtý parametr určuje, jaký typ proměnné se na dříve předaném posunu nachází. Ve čtvrtém parametru můžete k popisu typu proměnné, podle které řadíte, použít vestavěné konstanty, které jsou přesně stejné jako u příkazu ‘SortStructuredArray()’. Poslední dva parametry slouží k určení rozsahu pozic ve spojovém seznamu, v němž se má řazení provést.
S využitím výše uvedených informací můžeme celý strukturovaný spojový seznam seřadit vzestupně s rozlišováním velkých a malých písmen, a to takto:
Structure GIRL
Name.s
Weight.s
EndStructure
NewList Girls.GIRL()
AddElement(Girls())
Girls()\Name = "Mia"
Girls()\Weight = "8.5 Stone"
AddElement(Girls())
Girls()\Name = "Big Rosie"
Girls()\Weight = "19 stone"
AddElement(Girls())
Girls()\Name = "Sara"
Girls()\Weight = "10 Stone"
SortStructuredList(Girls(), 0, OffsetOf(GIRL\Name), #PB_Sort_String)
ForEach Girls()
Debug Girls()\Name + " : " + Girls()\Weight
Next
V tomto příkladu jsem jako pole, podle kterého se tento strukturovaný spojový seznam seřadí, zvolil ‘Name’. V příkazu pro řazení jsem ho tedy určil posunem ‘OffsetOf(GIRL\Name)’ a konstantou ‘#PB_Sort_String’ jsem příkazu sdělil, že jde o řetězec.
Snadné řazení
Všechny předchozí příklady řazení lze stejným způsobem použít k řazení podle číselných polí i podle řetězců – jde jen o to zvolit při použití různých příkazů pro řazení správnou volbu. Řazení polí a spojových seznamů, ať už vytvořených pomocí struktury, či nikoli, je jen otázkou použití správných voleb a posunů. Vyzkoušejte si sami několik příkladů a procvičte si řazení pomocí těchto příkazů.
6Procedury a podprogramy
V této kapitole se budu zabývat procedurami a podprogramy. Procedury jsou nezbytnou součástí každého programovacího jazyka – umožňují úhledně strukturovat kód a opakovaně ho využívat. PureBasic je považován za strukturovaný programovací jazyk a právě procedury jsou prostředkem, jímž se struktura programu vytváří. V této kapitole zmíním i podprogramy, ty však v mnoha programovacích jazycích nepatří k hlavním rysům. Protože ale v PureBasicu svou roli hrají, uvádím je zde pro úplnost.
Proč používat procedury a podprogramy?
Teoreticky byste procedury ani podprogramy asi nikdy používat nemuseli. Mohli byste prostě napsat jeden obrovský kus kódu, ten by se však velmi rychle stal velmi nepřehledným a myslím, že byste se v takové spleti kódu mnohokrát opakovali. Procedury a podprogramy umožňují kdykoli během hlavního kódu zavolat samostatné části kódu. Tyto samostatné části mohou dělat cokoli. Můžete například zavolat proceduru, která přehraje zvuk nebo aktualizuje obrazovku, nebo dokonce takovou, která obsahuje celý plně funkční program.
Procedury a podprogramy jsou dobrým způsobem, jak udržet kód čistý a uspořádaný a dát mu jasnou strukturu. Dobře strukturovaný kód se později vždy lépe čte, zvlášť pokud se k němu vracíte kvůli úpravám nebo pracujete v týmu, kde na stejném souboru bude pravděpodobně pracovat více lidí.
Podprogramy
Podprogramy se v PureBasicu nepoužívají příliš často a někteří je považují za špatný programátorský styl, občas se ale hodí, když potřebujete rychle zavolat nějaký kód. Podprogramy umožňují skočit na jiné místo ve zdrojovém kódu (dále v něm) a po jeho provedení se vrátit zpět na místo, odkud se skákalo. Abyste mohli tímto způsobem skočit na samostatný kus kódu, musíte určit místo, kam se má skočit. Tento cíl skoku se v kódu určuje pomocí návěští podprogramu.
Pro návěští podprogramu můžete použít libovolný název, musíte však dodržet stejná pravidla pojmenování jako u proměnných, jen s tím rozdílem, že místo přípony se návěští označuje dvojtečkou, takto:
Label:
Na toto návěští podprogramu lze z kteréhokoli místa v kódu skočit tímto příkazem:
Gosub Label
Všimněte si, že v příkazu ‘Gosub’ při uvádění návěští, na které se má skočit, dvojtečku nepoužíváme. Za cílové návěští napíšete běžný kód PureBasicu, který má podprogram provést. Za tímto kódem pak musíte uvést, že se chcete vrátit zpět do hlavního kódu, a to tímto příkazem:
Return
Zde je krátký příklad, který ukazuje použití podprogramu:
a.l = 10
Debug a
Gosub Calculation
Debug a
End
Calculation:
a = a * 5 + 5
Return
V tomto příkladu přiřadíme proměnné ‘a’ hodnotu ‘10’ a vypíšeme ji do okna Debug Output (výstup ladění). Poté klíčovým slovem ‘Gosub’ skočíme na návěští ‘Calculation’. Že jde o návěští, poznáte podle dvojtečky za jeho názvem a nejspíš si také všimnete, že IDE obarvuje návěští jinou barvou. Po skoku na toto návěští se s proměnnou ‘a’ provede malý výpočet a klíčovým slovem ‘Return’ se vrátíme do hlavního kódu. Při návratu do hlavního kódu se vracíme na řádek bezprostředně následující za původním příkazem ‘Gosub’. V tomto případě se vrátíme na řádek ‘Debug a’, který znovu vypíše hodnotu ‘a’ do okna Debug Output. Tato hodnota se mezitím změnila podle výpočtu provedeného v podprogramu.
Poznámka k umístění podprogramů v kódu
Musím zde upozornit na jednu důležitou věc: pokud do programu zařadíte podprogramy, musí být vždy až za klíčovým slovem ‘End’. Klíčové slovo ‘End’ po provedení nejen okamžitě ukončí program, ale při kompilaci také určuje koncový bod programu. Všechny podprogramy se musí nacházet až za tímto bodem, jinak by program mohl fungovat nesprávně.
Vyskočení z podprogramu
Obecně se to považuje za velmi špatnou programátorskou praxi, ale když už mluvím o podprogramech, mohu se držet stylu zbytku této knihy, popsat je v plném rozsahu a uvést i správnou syntaxi, jak to udělat.
Protože každý podprogram musí obsahovat klíčové slovo ‘Return’, jímž se skočí zpět do hlavního kódu, je třeba z podprogramu předčasně „vrátit“, chcete-li ho kdykoli správně opustit. K tomu slouží klíčová slova ‘FakeReturn’ a ‘Goto’. Zde je příklad:
a.l = 10
Debug a
Gosub Calculation
Debug a
End
RunAgain:
a.l = 20
Debug a
Gosub Calculation
Debug a
End
Calculation:
If a = 10
FakeReturn
Goto RunAgain
Else
a = a * 5 + 5
EndIf
Return
Jak vidíte z tohoto malého příkladu, věci se začínají komplikovat a kód skáče sem a tam po celém programu. Jak jsem už řekl, jde o špatný programátorský styl, který vede k velmi ošklivému kódu.
Pokud příklad pozorně sledujete, je docela jednoduchý. Vidíte, že v podprogramu ‘Calculation’ musíme před vyskočením pomocí příkazu ‘Goto’ použít ‘FakeReturn’. Skáčeme na další návěští (podprogram) s názvem ‘RunAgain’, které odkazuje na další téměř samostatný program i s dalším klíčovým slovem ‘End’, což opravdu není ideální.
Doufám, že vám tyto příklady poskytly přehled o podprogramech a o tom, jak v programu skákat z místa na místo, ale také doufám, že tyto postupy nebudete zneužívat a neosvojíte si je jako běžný způsob programování. Myslím, že pomocí procedur lze kód strukturovat mnohem lépe.
Základy procedur
Pojem „strukturované programování“ jasně vystihuje PureBasic i filozofii, s níž byl vytvořen. PureBasic lze popsat jako „procedurální“ a „strukturovaný“ programovací jazyk. Architekturu strukturovaného programování zajišťují procedury. Jsou doslova onou strukturou ve strukturovaném programování.
Procedury (v jiných jazycích se jim někdy říká „funkce“) jsou nejdůležitější funkcí, kterou PureBasic nabízí. V nejzákladnější podobě jsou jen schránkou na kus kódu, který lze v programu kdykoli zavolat (spustit), což je velmi podobné podprogramům. Stejně jako podprogramy je lze volat, kolikrát chcete, a mohou obsahovat libovolný kód PureBasicu. Na rozdíl od podprogramů však procedurám lze předat několik vstupních parametrů a mohou dokonce vracet jednu hodnotu libovolného vestavěného typu.
Začněme jednoduchým příkladem procedury.
Procedure NurseryRhyme()
Debug "Mary had a little lamb, its fleece was white as snow."
Debug "And everywhere that Mary went, that lamb was sure to go."
EndProcedure
NurseryRhyme()
Abyste mohli proceduru v kódu použít, musíte ji nejprve definovat. Zde jsem pomocí klíčového slova ‘Procedure’ definoval proceduru s názvem ‘NurseryRhyme’. Za tento řádek se pak zapíše kód, který má procedura obsahovat. Konec procedury se pak určí klíčovým slovem ‘EndProcedure’. Kód obsažený v této proceduře pak můžeme kdykoli zavolat pouhým uvedením jejího názvu, takto:
NurseryRhyme()
Než budeme pokračovat, musím v tomto příkladu upozornit na několik věcí, které si zaslouží podrobnější vysvětlení. Zaprvé jste si možná všimli, že za názvem procedury je záhadná dvojice závorek. Ty slouží k uvedení parametrů, které se mají proceduře předat. I když žádné parametry nepředáváte, jako v tomto příkladu, musíte závorky uvést. Také při volání procedury musíte závorky vždy uvést jako součást volání, ať už s parametry, nebo bez nich. Předávání parametrů procedurám vysvětlím později v této kapitole.
Ještě je třeba upozornit, že název procedury, např. ‘NurseryRhyme()’, nesmí obsahovat mezery a měl by dodržovat stejná pravidla pojmenování jako proměnné.
Když výše uvedený příklad spustíte, měli byste v okně Debug Output vidět říkanku, kterou obsahuje procedura ‘NurseryRhyme()’. Chcete-li kód této procedury v tomto malém příkladu kdykoli zopakovat, stačí ji znovu a znovu volat jejím názvem.
Procedure NurseryRhyme()
Debug "Mary had a little lamb, its fleece was white as snow."
Debug "And everywhere that Mary went, that lamb was sure to go."
EndProcedure
For x.l = 1 To 5
NurseryRhyme()
Next x
Procedury lze volat z kteréhokoli místa programu, jako ve výše uvedeném příkladu, kde jsem proceduru ‘NurseryRhyme()’ zavolal z cyklu. Procedury lze volat také z jiných procedur.
Procedure NurseryRhyme2()
Debug "And everywhere that Mary went, that lamb was sure to go."
EndProcedure
Procedure NurseryRhyme1()
Debug "Mary had a little lamb, its fleece was white as snow."
NurseryRhyme2()
EndProcedure
NurseryRhyme1()
Zde vidíte, že ‘NurseryRhyme1()’ obsahuje volání ‘NurseryRhyme2()’.
Poznámka k umístění procedur v kódu
Výše uvedený příklad pěkně ukazuje, proč na umístění procedur v kódu záleží. Všimněte si, že jsem ‘NurseryRhyme2()’ napsal jako první, nad ‘NurseryRhyme1()’. Bylo to záměrné a nutné, protože proceduru musíte vždy definovat dříve, než ji zavoláte. Protože ‘NurseryRhyme1()’ volá ‘NurseryRhyme2()’, musela být ta druhá definována dříve. Kompilátor PureBasicu je takzvaný „jednoprůchodový“ kompilátor, který čte zdrojový kód shora dolů. Pokud narazí na volání procedury, která dosud nebyla definována, ohlásí chybu. Tento jednoduchý příklad zároveň ukazuje, proč se procedury ve většině zdrojových kódů definují na začátku.
Jako u většiny věcí v životě však i z tohoto pravidla existuje výjimka. Pomocí klíčového slova ‘Declare’ můžete umístění definic procedur v kódu změnit. Klíčové slovo ‘Declare’ proceduru nedefinuje, pouze dává kompilátoru vědět, které procedury bude mít za úkol volat. Díky tomu mohou být procedury definovány až později ve zdrojovém kódu. Zde je příklad:
Declare NurseryRhyme1()
Declare NurseryRhyme2()
NurseryRhyme1()
Procedure NurseryRhyme1()
Debug "Mary had a little lamb, its fleece was white as snow."
NurseryRhyme2()
EndProcedure
Procedure NurseryRhyme2()
Debug "And everywhere that Mary went, that lamb was sure to go."
EndProcedure
Při použití klíčového slova ‘Declare’ uvedete jen první řádek procedury, a to přesně stejně, jako byste ho zapsali s klíčovým slovem ‘Procedure’. Poté můžete tuto proceduru kdykoli po této deklaraci volat. Protože jde čistě o deklaraci, a ne o definici, musíte proceduru také někde jinde v kódu běžně definovat. Nyní ji však lze definovat kdekoli, dokonce i na konci zdrojového kódu místo na začátku.
Pokud se podíváte na výše uvedený příklad, vidíte, že jsem použil dvě deklarace s klíčovým slovem ‘Declare’. Poté už mohu volat proceduru ‘NurseryRhyme1()’. Vlastní definice procedur jsou na konci kódu.
Obor platnosti v programu
Při používání procedur je také velmi důležité rozumět různým oborům platnosti, které program může obsahovat. Tento pojem označuje, v jakém rozsahu je daná proměnná, pole nebo spojový seznam k dispozici. Začnu vysvětlovat na jednoduchém příkladu s proměnnou.
a.l = 10
Procedure DisplayValue()
Debug a
EndProcedure
DisplayValue()
Zde jsem definoval proměnnou typu Long s názvem ‘a’ a přiřadil jí číselnou hodnotu ‘10’. Definoval jsem také proceduru s názvem ‘DisplayValue()’ a v ní jsem napsal jeden řádek kódu, který vypíše hodnotu ‘a’. Poslední řádek příkladu tuto proceduru volá. Když příklad spustíte, čekali byste, že se do okna Debug Output vypíše hodnota ‘a’ (tedy ‘10’), ale není tomu tak. Všimnete si, že se místo toho vypíše hodnota ‘0’. Je to kvůli oboru platnosti.
Rozeberu tento příklad ještě podrobněji a vysvětlím, co se přesně děje. Při používání proměnných v PureBasicu si musíte především pamatovat, že mají ve výchozím stavu lokální obor platnosti. To znamená, že ve výše uvedeném příkladu je proměnná z první definice ‘a.l = 10’ lokální v tom oboru platnosti, v němž je definována, v tomto případě v hlavním zdrojovém kódu. Pokud tuto proměnnou neuděláte globální, žádná procedura ji neuvidí ani ji nebude moci použít.
V proceduře ‘DisplayValue()’ vypisujeme hodnotu ‘a’, tato proměnná ‘a’ však není tatáž jako ta mimo proceduru. Mají stejný název, ale nejde o stejnou proměnnou. Ta uvnitř procedury je lokální pro proceduru, takže ani jedna z proměnných není té druhé přístupná.
Může to být velmi matoucí, zvlášť když obě lokální proměnné mají stejný název jako v tomto malém příkladu, ale myslím, že jsem lokální obor platnosti pěkně předvedl.
Jak jsem už řekl, kdyby byla původní proměnná globální, všechny procedury by ji viděly a mohly ji používat. Ukážu vám, jak se to dělá.
Global a.l = 10
Procedure DisplayValue()
Debug a
EndProcedure
DisplayValue()
Všimněte si, že jedinou změnou je použití klíčového slova ‘Global’ před definicí proměnné. Tím je proměnná ‘a’ definována jako globální a všechny procedury ji nyní vidí a mohou ji používat. V okně Debug Output nyní uvidíte vypsanou správnou hodnotu ‘10’.
A naopak, pokud definujeme proměnné uvnitř procedury, považují se také za lokální pro tuto proceduru. Podívejte se na tohle:
Procedure DisplayValue()
a.l = 10
EndProcedure
DisplayValue()
Debug a
Podle očekávání poslední řádek ‘Debug a’ vypíše do okna Debug Output hodnotu ‘0’. Chceme-li proměnnou ‘a’ vidět a používat i mimo proceduru, v níž byla definována, musíme ji udělat globální. Takto:
Procedure DisplayValue()
Global a.l = 10
EndProcedure
DisplayValue()
Debug a
Při čtení těchto posledních příkladů vás možná napadne, proč neudělat všechny proměnné globální. Někomu to může dávat smysl, ale jakmile programy dosáhnou větší velikosti, mohou se věci zamotat a znepřehlednit, pokud jsou všechny proměnné globální. Také můžete zjistit, že vám začnou docházet použitelné názvy proměnných. Používání různých oborů platnosti v programu vám rovněž umožňuje používat uvnitř procedur dočasné názvy proměnných pro výpočty nebo cykly s jistotou, že neovlivní žádné proměnné mimo ně. Někteří programátoři se snaží používat co nejméně globálních proměnných, protože ladění programu je pak mnohem méně pracné. Podezřelé hodnoty a proměnné lze rychleji zúžit na konkrétní obor platnosti, pokud se používá méně globálních proměnných.
Také pole a spojové seznamy mohou mít při použití s procedurami v programu různé obory platnosti, přesně jako proměnné. Až do verze PureBasic v4 byla všechna pole a spojové seznamy ve výchozím stavu globální, takže s nimi procedury mohly vždy pracovat. S příchodem PureBasicu v4 mohou být pole a spojové seznamy lokální, globální, chráněné (protected) a statické přesně stejným způsobem jako proměnné. Používají dokonce stejná klíčová slova pro obor platnosti.
V dalším oddílu uvádím všechna klíčová slova pro obor platnosti, ke každému podávám úplné vysvětlení a spoustu příkladů, které ukazují jejich použití u proměnných, polí a spojových seznamů.
Klíčové slovo ‘Global’
Globální proměnné
Příklad klíčového slova ‘Global’ jsem už uvedl při vysvětlování oboru platnosti v programu, ale pro úplnost tohoto přehledu ho uvádím znovu.
Global a.l = 10
Procedure DisplayValue()
Debug a
EndProcedure
DisplayValue()
Klíčové slovo ‘Global’ se píše před definici proměnné, aby byl obor platnosti této proměnné globální. Jakmile je proměnná definována jako globální, lze ji vidět a měnit ve všech procedurách, které váš zdrojový kód obsahuje. Syntaxe je velmi jednoduchá, jak vidíte z výše uvedeného příkladu.
Globální pole
Global Dim Numbers.l(1)
Procedure ChangeValues()
Numbers(0) = 3
Numbers(1) = 4
EndProcedure
ChangeValues()
Debug Numbers(0)
Debug Numbers(1)
V tomto příkladu jsem podobně jako u globálních proměnných použil klíčové slovo ‘Global’ před definicí pole, takže k němu mohu přistupovat uvnitř procedury. Bez klíčového slova ‘Global’ před polem by ho procedura neviděla ani by ho nemohla používat.
Globální spojové seznamy
Global Newlist Numbers.l()
AddElement(Numbers())
Numbers() = 1
Procedure ChangeValue()
SelectElement(Numbers(), 1)
Numbers() = 100
EndProcedure
ChangeValue()
SelectElement(Numbers(), 1)
Debug Numbers()
V tomto příkladu jsem podobně jako u polí použil klíčové slovo ‘Global’ před definicí spojového seznamu, takže k němu mohu přistupovat uvnitř procedury. Bez klíčového slova ‘Global’ před spojovým seznamem by ho procedura neviděla ani by ho nemohla používat.
Klíčové slovo ‘Protected’
Chráněné proměnné
Klíčové slovo ‘Protected’ vynutí, aby proměnná byla v proceduře lokální, i když byla stejná proměnná v hlavním zdrojovém kódu deklarována jako globální. To je velmi užitečné pro definování dočasných názvů proměnných uvnitř procedur, nebo prostě pro jistotu, že proměnné procedury nikdy nebudou kolidovat s žádnými globálními proměnnými hlavního kódu.
Global a.l = 10
Procedure ChangeValue()
Protected a.l = 20
EndProcedure
ChangeValue()
Debug a
Vidíte, že přestože má chráněná proměnná uvnitř procedury stejný název jako globální proměnná, považují se za dvě samostatné proměnné ve dvou různých oborech platnosti. Když výše uvedený příklad spustíte, bude výsledek vypsaný do okna Debug Output ‘10’, protože i když voláme proceduru ‘ChangeValue()’, chráněná proměnná tu globální nezmění. Toto klíčové slovo je nezbytné při psaní obecných procedur, které hodláte používat v mnoha různých zdrojových kódech, aby nic v hlavním kódu neovlivňovaly.
Chráněná pole
Global Dim Numbers.l(1)
Procedure ChangeValues()
Protected Dim Numbers.l(1)
Numbers(0) = 3
Numbers(1) = 4
EndProcedure
ChangeValues()
Debug Numbers(0)
Debug Numbers(1)
V tomto příkladu používáme klíčové slovo ‘Protected’ přesně stejným způsobem jako v příkladu s chráněnou proměnnou. Když výše uvedený příklad spustíte, budou výsledky vypsané do okna Debug Output ‘0’, protože i když voláme proceduru ‘ChangeValues()’, chráněné pole to globální vůbec nezmění. Toto klíčové slovo se skvěle hodí k ochraně polí uvnitř procedur, aby nikdy nezasahovala do hlavního kódu, i když mají stejný název jako globální pole.
Chráněné spojové seznamy
Global Newlist Numbers.l()
AddElement(Numbers())
Numbers() = 1
Procedure ChangeValue()
Protected Newlist Numbers.l()
AddElement(Numbers())
Numbers() = 100
EndProcedure
ChangeValue()
SelectElement(Numbers(), 1)
Debug Numbers()
Když výše uvedený příklad spustíte, bude výsledek vypsaný do okna Debug Output opět ‘1’, protože i když voláme proceduru ‘ChangeValue()’, chráněný spojový seznam ten globální nezmění. Toto klíčové slovo se skvěle hodí k ochraně spojových seznamů uvnitř procedur, aby nikdy nezasahovaly do hlavního kódu, i když mají stejný název jako globální spojové seznamy.
Klíčové slovo ‘Shared’
Sdílené proměnné
Někdy můžete v kódu potřebovat přistoupit zevnitř procedury k proměnné, která nebyla definována jako globální. Právě tehdy se používá klíčové slovo ‘Shared’. Zde je příklad:
a.l = 10
Procedure ChangeValue()
Shared a
a = 50
EndProcedure
ChangeValue()
Debug a
Přestože zde proměnná ‘a’ původně není definována jako globální, můžete k ní zevnitř procedury přistupovat pomocí klíčového slova ‘Shared’. Když výše uvedený příklad spustíte, procedura ‘ChangeValue()’ změní hodnotu ‘a’, přestože nejde o globální proměnnou.
Sdílená pole
Dim Numbers.l(1)
Procedure ChangeValues()
Shared Numbers()
Numbers(0) = 3
Numbers(1) = 4
EndProcedure
ChangeValues()
Debug Numbers(0)
Debug Numbers(1)
Přestože pole ‘Numbers()’ v tomto příkladu není definováno jako globální, mohu k němu zevnitř procedury ‘ChangeValues()’ přistupovat pomocí klíčového slova ‘Shared’. Při určování, které pole chcete sdílet, stačí uvést název pole se závorkami na konci, takto: ‘Numbers()’; příponu typu, indexy ani rozměry uvádět není třeba.
Sdílené spojové seznamy
Newlist Numbers.l()
Procedure ChangeValue()
Shared Numbers()
AddElement(Numbers())
Numbers() = 100
EndProcedure
ChangeValue()
SelectElement(Numbers(), 1)
Debug Numbers()
Přestože spojový seznam ‘Numbers()’ v tomto příkladu není definován jako globální, mohu k němu z procedury ‘ChangeValue()’ přistupovat pomocí klíčového slova ‘Shared’, velmi podobně jako v příkladu se sdíleným polem. Při určování, který spojový seznam chcete sdílet, stačí uvést jeho název se závorkami na konci, takto: ‘Numbers()’; příponu typu uvádět není třeba.
Klíčové slovo ‘Static’
Statické proměnné
Pokaždé, když procedura skončí, ztratí se hodnoty všech proměnných v ní definovaných. Chcete-li, aby si procedura hodnotu proměnné pamatovala i po každém volání, musíte použít klíčové slovo ‘Static’. Podívejte se na tento příklad:
Procedure ChangeValue()
Static a.l
a + 1
Debug a
EndProcedure
For x.l = 1 To 5
ChangeValue()
Next x
Zde jsem v proceduře ‘ChangeValue()’ pomocí klíčového slova ‘Static’ nastavil proměnnou ‘a’ jako statickou. Poté zvýším hodnotu ‘a’ o ‘1’ a tuto hodnotu vypíšu do okna Debug Output. Tuto proceduru pak pomocí běžného cyklu ‘For’ zavolám pětkrát. Když se podíváte na vypsané hodnoty, jsou všechny různé a pokaždé o ‘1’ vyšší. Je to proto, že se hodnota ‘a’ mezi voláními procedury pamatuje.
Statická pole
Pomocí klíčového slova ‘Static’ můžete mezi voláními procedury zachovat také hodnoty pole.
Procedure ChangeValue()
Static Dim Numbers.l(1)
Numbers(0) + 1
Numbers(1) + 1
Debug Numbers(0)
Debug Numbers(1)
EndProcedure
For x.l = 1 To 5
ChangeValue()
Next x
Ve výše uvedeném příkladu jsem klíčové slovo ‘Static’ použil k zachování hodnot pole mezi voláními procedury přesně stejně jako u statických proměnných. Když se podíváte na vypsané hodnoty, jsou všechny různé a pokaždé o ‘1’ vyšší. Je to proto, že se všechny hodnoty statického pole mezi voláními zachovaly.
Statické spojové seznamy
Procedure ChangeValue()
Static NewList Numbers.l()
If CountList(Numbers()) = 0
AddElement(Numbers())
EndIf
SelectElement(Numbers(), 1)
Numbers() + 1
Debug Numbers()
EndProcedure
For x.l = 1 To 5
ChangeValue()
Next x
V tomto příkladu používám klíčové slovo ‘Static’ k zachování hodnot spojového seznamu mezi voláními procedury přesně stejně jako u statických polí. Když se podíváte na vypsané hodnoty, jsou všechny různé a pokaždé o ‘1’ vyšší.
Protože je tento spojový seznam statický a pro účely tohoto příkladu jsem chtěl přidat jen jeden prvek, použil jsem v proceduře příkaz ‘If’, který testuje počet prvků v seznamu. Pokud seznam nemá žádné prvky, jeden přidám, jinak jen změním hodnotu stávajícího prvku ve statickém spojovém seznamu. Kdybych to neudělal takto, přidával bych při každém volání procedury další prvky, což jsem nechtěl.
Předávání proměnných procedurám
Jak jsem se už zmínil, jednou z nejužitečnějších schopností procedur je, že mohou přijímat počáteční vstupní parametry. Těmito parametry mohou být proměnné libovolného vestavěného typu, pole, nebo dokonce spojové seznamy. Parametry slouží k předávání hodnot z hlavního programu do procedury ke zpracování. Procedury pak lze jednou definovat a používat v celém programu znovu a znovu s různými počátečními hodnotami. Takto definujete proceduru, která přijímá parametry:
Procedure AddTogether(a.l, b.l)
Debug a + b
EndProcedure
AddTogether(10, 5)
AddTogether(7, 7)
AddTogether(50, 50)
Všechny parametry, které se mají proceduře předat, musí být uvnitř závorek, a je-li jich potřeba více, oddělují se čárkami. Jsou-li parametry takto uvedeny v definici, musí mít všechny také definovaný typ. Zde jsem definoval dva parametry, ‘a’ a ‘b’, oba jsou proměnné typu Long.
Jakmile je procedura takto definována, nesmíte zapomenout při jejím volání uvést hodnoty, které chcete předat jako parametry, takto:
AddTogether(10, 5)
Po tomto konkrétním volání se hodnota ‘10’ předá do proměnné ‘a’ a hodnota ‘5’ do proměnné ‘b’. Procedura tyto proměnné sečte a výsledek zobrazí v okně Debug Output. Totéž platí i pro všechna ostatní volání: první hodnota parametru ve volání se předá do ‘a’ a druhá do ‘b’.
Zde je další příklad, tentokrát s řetězci:
Procedure JoinString(a.s, b.s)
Debug a + b
EndProcedure
JoinString("Mary had a little lamb, ", "its fleece was white as snow.")
JoinString("And everywhere that Mary went, ", "that lamb was sure to go.")
JoinString("..", "..")
Zde využíváme druhou roli operátoru ‘+’, kdy ho místo sčítání používáme ke spojování řetězců. V podstatě jsem upravil proceduru ‘AddTogether(a.l, b.l)’, nahradil parametry typu Long řetězcovými typy a přejmenoval ji na ‘JoinString(a.s, b.s)’. Tuto proceduru nyní mohu zavolat odkudkoli v programu a předat jí řetězce odpovídající definovaným parametrům.
Další věc, kterou je u procedur dobré si pamatovat, je, že jejich parametry nemusí být všechny stejného typu – můžete je libovolně kombinovat.
Procedure LotsOfTypes(a.b, b.w, c.l, d.f, e.s)
Debug "Byte: " + Str(a)
Debug "Word: " + Str(b)
Debug "Long: " + Str(c)
Debug "Float: " + StrF(d)
Debug "String: " + e
EndProcedure
LotsOfTypes(104, 21674, 97987897, 3.141590, "Mary had a little lamb")
Zde jsem v proceduře ‘LotsOfTypes()’ použil jako parametry několik různých typů proměnných, abych ukázal, že parametry nemusí být všechny stejného typu. Hodnoty předané při volání procedury se postupně přiřadí definovaným parametrům procedury ‘a’, ‘b’, ‘c’, ‘d’ a ‘e’. Všimnete si také, že všechny předávané hodnoty musí odpovídat typům příslušných parametrů, jinak dojde k syntaktické chybě.
Jistě jste si také všimli, že jsem použil dvě vestavěné funkce, které možná neznáte. Tyto dvě funkce, ‘Str()’ a ‘StrF()’, budou podrobněji vysvětleny v kapitole 7 (Příklady běžných příkazů), ale zjednodušeně řečeno převádějí číselné typy na řetězce.
Už z těchto jednoduchých příkladů by se měla začít ukazovat síla procedur. Nejen že ušetří spoustu času při psaní kódu, ale také programátorům umožňují rozšiřovat funkčnost PureBasicu a tuto funkčnost pak libovolně používat v jakémkoli zdrojovém kódu. To umožňuje výborné opakované využití kódu, zvlášť pokud jste napsali nějaké opravdu užitečné obecné procedury.
Volitelné parametry
Novinkou PureBasicu v4 byly volitelné parametry procedur. Velmi snadno se vysvětlují i předvádějí a jsou nesmírně užitečné.
V podstatě můžete libovolnému parametru nastavit počáteční hodnotu pro případ, že ho při volání procedury neuvedete. Zde je příklad:
Procedure DisplayParameters(a.l, b.l, c.l = 3)
Debug a
Debug b
Debug c
EndProcedure
DisplayParameters(1, 2)
Když se podíváte na definici procedury ve výše uvedeném příkladu, uvidíte, že poslední parametr je definován jinak než ostatní a byla mu přiřazena počáteční hodnota ‘3’. Pokud poslední parametr při volání procedury neuvedete, bude mít tuto výchozí hodnotu. Když ve výše uvedeném příkladu zavolám proceduru jako ‘DisplayParameters(1, 2)’ a poslední parametr vynechám, uvidíte ve výpisu v okně Debug Output, že byla tato výchozí hodnota rozpoznána a použita.
Takto lze definovat jako volitelné libovolné množství parametrů. Musíte však vědět, že všechny volitelné parametry se musí vždy nacházet napravo od běžných, nevolitelných parametrů. Je to proto, že všechny hodnoty předávané při volání procedury se parametrům přiřazují zleva doprava a volitelné parametry nelze přeskočit.
Předávání polí procedurám
Kromě proměnných můžete procedurám jako parametry předávat také pole a spojové seznamy. Jejich použití je jednoduchost sama a velmi snadno se předvádí.
Chcete-li předat pole jako parametr, musíte nejprve pole definovat běžným klíčovým slovem ‘Dim’. Zde je jednoduché jednorozměrné pole řetězců definované se čtyřmi indexy (nezapomeňte, že indexy začínají od ‘0’), které jsem nazval ‘Countries’:
Dim Countries.s(3)
Countries(0) = "England"
Countries(1) = "Northern Ireland"
Countries(2) = "Scotland"
Countries(3) = "Wales"
Jakmile je toto pole definováno, definujme proceduru, které ho předáme:
Procedure EchoArray(MyArray.s(1))
For x.l = 0 To 3
Debug MyArray(x)
Next x
EndProcedure
Chcete-li definovat proceduru, která přijímá pole jako parametr, musíte to udělat velmi striktním způsobem. Především se parametr typu pole definuje ve stejných závorkách procedury jako jakýkoli jiný běžný parametr. Samotný parametr pole se skládá ze tří částí.
Nejprve se použije název, který bude uvnitř procedury sloužit jako název pole. K tomuto názvu se pak připojí přípona očekávaného typu pole a na konec se přidají závorky. Tyto závorky obvykle obsahují číslo, které vyjadřuje index pole. Zde však má toto číslo udávat počet rozměrů předávaného pole. Ve výše uvedeném příkladu jsem použil jednorozměrné pole, takže celý parametr pole vypadá takto:
MyArray.s(1)
Vidíte tu název parametru pole, příponu typu pole a pak mezi závorkami počet rozměrů definovaných v očekávaném poli.
Všimněte si, že jsem jako název parametru pole použil ‘MyArray’. Není to nutné, parametry můžete pojmenovat, jak chcete. Vždy však musíte dodržovat stejná pravidla pojmenování jako u proměnných, tj. žádné mezery, žádné názvy klíčových slov atd.
Uvnitř této procedury nyní můžete ‘MyArray()’ používat jako jakékoli jiné běžné pole a pomocí běžných indexů z něj číst hodnoty a zapisovat je do něj. Ve výše uvedeném příkladu jsem použil jednoduchý cyklus ‘For’, kterým pole procházím a jeho hodnoty vypisuji do okna Debug Output. Při hledání způsobů, jak pole zpracovávat, však můžete být tak tvořiví, jak chcete.
Jakmile je procedura správně definována, můžete ji zavolat a předat jí pole ‘Countries’ takto:
EchoArray(Countries())
Všimněte si, že při předávání našeho pole ‘Countries()’ používáme jen jeho název se závorkami na konci, skoro jako by šlo o volání procedury. Při skutečném předávání pole ve volání procedury nejsou potřeba žádné typy, indexy ani rozměry.
Když tento příklad spustíte, měli byste v okně Debug Output vidět vypsané čtyři země Spojeného království.
Předávání vícerozměrných polí
Jako parametry můžete předávat i vícerozměrná pole, jak ukazuje tento příklad:
Dim Countries.s(3, 1)
Countries(0,0) = "England"
Countries(0,1) = "57,000,000"
Countries(1, 0) = "Northern Ireland"
Countries(1,1) = "2,000,000"
Countries(2, 0) = "Scotland"
Countries(2,1) = "5,200,000"
Countries(3, 0) = "Wales"
Countries(3,1) = "3,100,000"
Procedure EchoArray(MyArray.s(2))
For x.l = 0 To 3
Debug MyArray(x,0) + " - " + "Population: " + MyArray(x,1)
Next x
EndProcedure
EchoArray(Countries())
Přestože jde o dvourozměrné pole, při definování procedury, která toto pole přijímá jako parametr, používáme stále stejná pravidla jako předtím. Všimněte si, že v této definici parametru pole uvádíme v závorkách ‘2’, čímž určujeme, že očekávané pole bude dvourozměrné, takto:
MyArray.s(2)
I když je tento parametr definován pro dvourozměrné pole, proceduru voláme a pole předáváme stejně jako předtím, bez typů, indexů a rozměrů:
EchoArray(Countries())
Předávání polí strukturovaného typu
Také pole strukturovaného typu lze procedurám předávat velmi snadno. Postupuje se přesně tak, jak bylo ukázáno na předchozí stránce, jen je třeba změnit typ parametru pole tak, aby odpovídal struktuře použité v definici pole. Podívejte se na tento příklad:
Structure COUNTRY
Name.s
Population.s
EndStructure
Dim Countries.COUNTRY(3)
Countries(0)\Name = "England"
Countries(0)\Population = "57,000,000"
Countries(1)\Name = "Northern Ireland"
Countries(1)\Population = "2,000,000"
Countries(2)\Name = "Scotland"
Countries(2)\Population = "5,200,000"
Countries(3)\Name = "Wales"
Countries(3)\Population = "3,100,000"
Procedure EchoArray(MyArray.COUNTRY(1))
For x.l = 0 To 3
Debug MyArray(x)\Name + " - " + "Population: " + MyArray(x)\Population
Next x
EndProcedure
EchoArray(Countries())
Zde jsem použil strukturované pole definované pomocí struktury ‘COUNTRY’. Aby bylo možné takové pole předat proceduře, musíte zajistit, aby parametr pole byl definován se stejnou strukturou, jaká byla použita při definici očekávaného pole, v tomto případě se strukturou ‘COUNTRY’. Tento parametr vidíte ve výše uvedené definici procedury:
MyArray.COUNTRY(1)
Je zde název parametru, přípona strukturovaného typu pole a pak počet rozměrů předávaného pole. Je-li vše napsáno správně jako výše, předá se do této procedury jednorozměrné pole se strukturou ‘COUNTRY’ bez problémů.
Předávání spojových seznamů procedurám
Při programování v PureBasicu možná budete chtít proceduře předat spojový seznam. Je to velmi podobné předávání pole. Nejprve se podívejte na tento příklad:
NewList Numbers.l()
AddElement(Numbers())
Numbers() = 25
AddElement(Numbers())
Numbers() = 50
AddElement(Numbers())
Numbers() = 75
Procedure EchoList(MyList.l())
ForEach MyList()
Debug MyList()
Next
EndProcedure
EchoList(Numbers())
Zde jsem vytvořil běžný spojový seznam s názvem ‘Numbers’, který bude obsahovat prvky typu Long. Po přidání tří prvků do tohoto seznamu jsem definoval proceduru ‘EchoList()’, které bude tento spojový seznam předán. Parametr spojového seznamu se zapisuje velmi podobně jako parametr pole: začíná názvem parametru, za ním následuje přípona typu seznamu a nakonec dvojice závorek. Spojové seznamy nepoužívají indexy jako pole, takže do závorek nemusíte psát žádné číslo. Jakmile je toto hotovo, můžete proceduru zavolat a předat jí spojový seznam stejně jako pole, bez typu atd. Takto:
EchoList(Numbers())
Uvnitř procedury ‘EchoList()’ pak spojový seznam ‘MyList()’ samozřejmě obsahuje všechny informace, které obsahoval předaný spojový seznam, a lze ho používat přesně stejně jako jakýkoli jiný běžný spojový seznam. Vidíte, že uvnitř procedury ‘EchoList()’ jsem použil běžný cyklus ‘ForEach’, kterým spojový seznam rychle procházím a jeho hodnoty vypisuji do okna Debug Output.
Předávání strukturovaných spojových seznamů
Také strukturované spojové seznamy lze snadno předávat jako parametry procedur. Podobně jako při předávání strukturovaných polí musíte nezapomenout definovat v parametru procedury stejnou strukturu, jaká byla použita při definici spojového seznamu, který má být předán.
Structure FLAGS
Country.s
Flag.s
EndStructure
NewList Info.FLAGS()
AddElement(Info())
Info()\Country = "Great Britain"
Info()\Flag = "Union Jack"
AddElement(Info())
Info()\Country = "USA"
Info()\Flag = "Stars And Stripes"
AddElement(Info())
Info()\Country = "France"
Info()\Flag = "Tricolore"
Procedure EchoList(MyList.FLAGS())
ForEach MyList()
Debug MyList()\Country + "'s flag is the " + MyList()\Flag
Next
EndProcedure
EchoList(Info())
Všimněte si, že ve výše uvedeném příkladu vypadá parametr spojového seznamu takto:
MyList.FLAGS()
Zajistil jsem, aby parametr spojového seznamu nyní obsahoval typ ‘FLAGS’, aby se strukturovaný spojový seznam předal správně.
Vracení hodnoty z procedur
Další skvělou vlastností procedur je, že mohou vracet hodnotu. Tato hodnota může být libovolného z vestavěných typů PureBasicu. Vracení hodnoty z procedury je výborný způsob, jak v proceduře spočítat nebo zpracovat data a pak vrátit něco užitečného. Může to být výsledek výpočtu, chybový kód, nebo dokonce popisný řetězec o tom, co procedura právě udělala či čeho dosáhla. Seznam typů, které mohou procedury vracet, najdete na Obr. 2 a Obr. 3.
Syntaxe pro vracení hodnoty z procedury je jednoduchost sama. Nejprve musíte určit, jaký typ má procedura vracet, což se provede mírným rozšířením definice procedury. Podívejte se na tento příklad:
Procedure.l AddTogether(a.l, b.l)
ProcedureReturn a + b
EndProcedure
Debug AddTogether(7, 5)
Výše uvedená definice procedury dostala na konci klíčového slova ‘Procedure’ novou příponu typu. Právě zde se určuje typ, který bude tato procedura vracet. Výše uvedená definice dostala příponu ‘.l’, což znamená, že procedura bude vracet hodnotu typu Long. Aby procedura hodnotu skutečně vrátila, musíme použít klíčové slovo ‘ProcedureReturn’. Vrací se hodnota nebo výraz, který za tímto klíčovým slovem následuje. V tomto případě se vrací hodnota vzniklá vyhodnocením ‘a + b’.
Vidíte také, že když výše uvedenou proceduru zavoláme jako ‘AddTogether(7, 5)’, vrátí se hodnota přímo z tohoto volání a samo volání lze použít ve výrazu nebo příkazu. V tomto případě jsem ho použil jako výraz pro příkaz ‘Debug’. Volání procedury vrátí hodnotu ‘12’, která se pomocí klíčového slova ‘Debug’ rovnou vypíše do okna Debug Output.
Chceme-li, aby procedura vracela řetězec, stačí změnit návratový typ na ‘.s’, jak je ukázáno zde:
Procedure.s JoinString(a.s, b.s)
ProcedureReturn a + b
EndProcedure
Debug JoinString("Red ", "Lorry")
Debug JoinString("Yellow ", "Lorry")
Všimněte si, že návratový typ je uveden v klíčovém slově ‘Procedure.s’. To nyní určuje, že procedura bude vracet řetězec. V tomto novém příkladu předávám proceduře dva řetězce, které se spojí a vrátí na řádku ‘ProcedureReturn a + b’. Tuto proceduru volám třikrát, opět s klíčovým slovem ‘Debug’, abych vrácené hodnoty vypsal do okna Debug Output a ukázal je.
Procedury, které vracejí hodnoty, lze použít všude, kde lze použít výrazy. Mohou být například použity v dalším volání procedury, takto:
Procedure.l AddTogether(a.l, b.l)
ProcedureReturn a + b
EndProcedure
Debug AddTogether(AddTogether(2, 3), AddTogether(4, 1))
Zde jsem použil proceduru ‘AddTogether(a.l, b.l)’, aby vrátila součet hodnot vrácených ze dvou samostatných volání téže procedury. Nejprve se zavolá ‘AddTogether(2, 3)’, které vrátí ‘5’, pak se zavolá ‘AddTogether(4, 1)’, které vrátí také ‘5’. Obě tato volání procedury se používají jako parametry v dalším volání procedury. Toto poslední volání sečte obě vrácené hodnoty a vrátí výsledek, který se vypíše do okna Debug Output.
Parametry neovlivňují návratové typy
Při používání návratových typů procedur je třeba pamatovat na to, že nemusí být stejné jako typy definovaných parametrů. Například:
Procedure.s DisplayValue(a.l, b.s)
ProcedureReturn Str(a) + b
EndProcedure
x = 5
While x >= 0
Debug DisplayValue(x, " green bottles hanging on the wall.")
x - 1
Wend
Přestože jsem v proceduře ‘DisplayValue(a.l, b.s)’ použil parametr typu Long a parametr typu String, může procedura stále vracet řetězec, jak určuje přípona typu v klíčovém slově ‘Procedure.s’. Návratové typy a typy parametrů lze libovolně kombinovat.
Návratové typy jsou však velmi striktní, stejně jako typy proměnných. Pokud jste definovali proceduru, která vrací řetězec, a chcete z ní vrátit hodnotu typu Long, musíte tuto hodnotu před vrácením převést na správný návratový typ (String), jinak dostanete syntaktickou chybu. Vidíte to v praxi ve výše uvedeném příkladu. Použil jsem vestavěný příkaz ‘Str()’, abych ‘a’ převedl na řetězec, než ho spojím a správně vrátím.
Omezení při vracení výsledků
Při používání procedur k vracení výsledků však platí dvě omezení. Zaprvé, procedury mohou při jednom volání vrátit jen jeden výsledek. To znamená, že v jednom volání procedury nelze vrátit dvě nebo více hodnot. Zadruhé, z procedur nelze vracet pole, spojové seznamy ani žádné uživatelsky definované typy. Vracet lze jen vestavěné typy PureBasicu. Tato omezení však lze obejít vrácením ukazatele. Vysvětlení této techniky najdete v kapitole 13 (Ukazatele).
7Používání vestavěných příkazů
Programovací jazyky nejsou ničím bez vestavěných knihoven užitečných příkazů, a proto PureBasic nabízí přes osm set vestavěných příkazů, které můžete ve svých programech používat. Sahají od práce s řetězci přes matematiku a práci se soubory až po grafické příkazy. Pokrývají téměř každou představitelnou programátorskou úlohu, a pokud mezi nimi nenajdete nic, co by vyhovovalo vašim potřebám, máte stále možnost vytvořit si vlastní procedury.
V této kapitole představím a vysvětlím nejčastěji používané vestavěné příkazy, které PureBasic nabízí. Tento přehled rozhodně není úplný, ale měl by dostatečně objasnit některé z nejběžnějších příkazů, se kterými se při běžném programování setkáte.
Kapitola začíná popisem toho, jak číst syntaxi příkazů v nápovědě PureBasicu, a poté přechází k samotným popisům a vysvětlením příkazů. Kapitolu zakončím oddílem o práci se soubory – o jejich načítání, zápisu do nich, čtení z nich a ukládání, to vše pomocí vestavěných příkazů PureBasicu.
Používání nápovědy PureBasicu
Nyní se pořádně podíváme na nápovědu PureBasicu. Vysvětlím, jak jsou její stránky uspořádány, jak je číst a hlavně jak používat vestavěné příkazy, které jsou v ní popsány.
Když si v nápovědě PureBasicu zobrazíte stránku některého příkazu, uvidíte standardní rozvržení, které vypadá přibližně takto:
Syntaxe Popis Příklad Podporované operační systémy
Poslední tři části každé stránky nápovědy jsou většinou samovysvětlující, takže se na chvíli soustřeďme na část se syntaxí. Oddíl se syntaxí v horní části každé stránky nápovědy ukazuje, jak se příkaz skutečně zapisuje do IDE a jaké parametry očekává. Podívejme se například na příkaz ‘SaveImage()’ v nápovědě. Ke správné stránce se dostanete takto: (Helpfile:Reference Manual->General Libraries->Image->SaveImage). Na této stránce úplně nahoře, pod nadpisem Syntax, najdete tento příklad syntaxe:
SaveImage(#Image, FileName$ [, ImagePlugin [, Flags]])
Na tomto řádku je nejprve samotný název příkazu, v tomto případě ‘SaveImage’, za ním následuje dvojice závorek, a pokud daný příkaz přijímá parametry, jsou uvedeny uvnitř těchto závorek. V příkladu syntaxe příkazu ‘SaveImage()’ je vidět, že tento příkaz přijímá čtyři parametry, a proto jsou v závorkách uvedeny všechny čtyři. Všimněte si také, že poslední dva parametry jsou navíc uvedeny v hranatých závorkách. To značí, že tyto dva poslední parametry jsou nepovinné a při volání příkazu ‘SaveImage()’ je nemusíte použít. Budeme-li to mít na paměti, můžeme příkaz ‘SaveImage()’ správně použít například těmito třemi způsoby:
SaveImage(1, "Image.bmp")
SaveImage(1, "Image.jpg", #PB_ImagePlugin_JPEG)
SaveImage(1, "Image.jpg", #PB_ImagePlugin_JPEG, 10)
První příklad uloží obrázek s názvem ‘Image.bmp’ ve výchozím 24bitovém formátu Bitmap. Druhý příklad uloží obrázek ve formátu JPEG se standardní hodnotou komprese. Třetí příklad uloží obrázek ve formátu JPEG s maximální hodnotou komprese deset (‘10’). Jednoduché!
První věc, které si při používání vestavěných příkazů nejspíš všimnete, je, že vypadají a chovají se úplně stejně jako běžná volání procedur. Všechny vestavěné příkazy jednoduše volají předem napsané procedury, které jsou definovány jako součást balíku PureBasic. Celý trik jejich správného používání spočívá v tom, že při volání vestavěného příkazu mu musíte předat správné parametry tak, jak jsou definovány v příkladu syntaxe daného příkazu, jinak kompilátor ohlásí syntaktickou chybu.
Struktura výše uvedeného příkladu syntaxe se opakuje v celé nápovědě, takže pokud rozumíte tomuto, porozumíte i všem příkladům syntaxe všech ostatních vestavěných příkazů.
PB čísla a identifikátory OS
Při používání vestavěných příkazů je důležité porozumět roli systému číslování objektů v PureBasicu i roli identifikátorů operačního systému, protože se přímo používají k řízení toho, co se ve vašem programu děje. Obojí nejsou nic jiného než čísla, ale obojí slouží k identifikaci objektů v programech. Například jednotlivé části grafického uživatelského rozhraní nebo různé obrázky musíte identifikovat číslem. Vědět, jak a kdy je používat, je nezbytné nejen v PureBasicu, ale v programování obecně.
Nápověda PureBasicu je díky informacím, které obsahuje, k nezaplacení, ale při prvních pokusech pochopit systém číslování objektů PureBasicu a identifikátory operačního systému může být trochu matoucí. Je to proto, že nápověda někdy označuje obojí jako identifikátory. Dovolte mi přesně vysvětlit, o co jde, abyste nápovědě lépe rozuměli.
Vysvětlení PB čísel
PureBasic používá systém čísel k identifikaci každého objektu, který ve svém programu vytvoříte. Objektem PureBasicu může být mimo jiné okno, gadget nebo třeba obrázek. Tato čísla, budeme jim říkat PB čísla, pak váš program používá k tomu, aby se na tyto objekty později odkazoval, když s nimi chce něco provést.
Mnoho příkazů PureBasicu potřebuje ke správné funkci předat jako parametry jedno nebo dvě PB čísla. Ta jsou v nápovědě PureBasicu uvedena v příkladu syntaxe daného příkazu. Pokud příkaz potřebuje PB číslo, je obvykle zobrazeno jako konstanta, která začíná znakem mřížky (#) a končí názvem knihovny, do níž příkaz patří, např. ‘#Image’ se používá pro číslo obrázku, ‘#Window’ pro číslo okna atd.
Zde je příklad vestavěného příkazu z knihovny ‘Image’, který používá PB číslo: (Helpfile:Reference Manual->General Libraries->Image->CreateImage).
CreateImage(#Image, Width, Height)
Jak vidíte, tento příkaz očekává, že mu jako první parametr předáte PB číslo, označené ‘#Image’. Přestože je v příkladu syntaxe uvedeno jako konstanta, nemusí to nutně znamenat, že příkazu musíte předat konstantu – znamená to jen, že se konstanty obvykle používají. Ve skutečnosti lze jako PB číslo objektu použít libovolné celé číslo, pokud je jedinečné mezi ostatními objekty stejného druhu. Toto číslo pak v celém programu odkazuje na nově vytvořený objekt.
Objekty stejného druhu nemohou sdílet PB čísla
Čísla PureBasicu představují skvělý způsob, jak se jednotlivě odkazovat na cokoli, co PureBasic vytvoří. Z tohoto důvodu nemohou dva objekty stejného druhu sdílet stejné PB číslo. Pokud vytvoříte obrázek s číslem ‘1’ a později v programu vytvoříte další obrázek s číslem ‘1’, PureBasic první obrázek automaticky zruší a uvolní paměť, kterou používal, a teprve poté vytvoří druhý. Tím je zajištěno, že žádné dva objekty ze stejné knihovny nesdílejí stejné PB číslo. Tato vlastnost se také velmi hodí, pokud chcete objekty kdykoli nahradit.
Mezi různými knihovnami však čísla PureBasicu sdílet lze. Můžete například vytvořit okno s PB číslem ‘1’ a pak na něm vytvořit gadget tlačítka, také s PB číslem ‘1’. Tato dvě čísla se navzájem nepřekrývají, protože odkazují na objekty ze dvou různých knihoven.
Při vytváření objektů různými příkazy se lze snadno zamotat, když se snažíte sledovat všechna čísla, která je nutné použít. Aby se tomuto problému předešlo, používá mnoho programátorů v PureBasicu (včetně mě) pro PB čísla konstanty. Tyto konstanty se obvykle definují v bloku výčtu (enumeration), aby čísla šla po sobě. Zde je příklad:
Enumeration
#IMAGE_DOG
#IMAGE_CAT
#IMAGE_BIRD
EndEnumeration
CreateImage(#IMAGE_DOG, 100, 100)
CreateImage(#IMAGE_CAT, 250, 300)
CreateImage(#IMAGE_BIRD, 450, 115)
Po definování konstant je mohu použít k vytvoření výše uvedených obrázků (nebo jakýchkoli jiných objektů) a nemusím se obávat, že by se jejich hodnoty překrývaly. V celém programu se také mohu pomocí těchto konstant odkazovat na obrázky jménem. Na první obrázek se nyní mohu například odkazovat konstantou ‘#IMAGE_DOG’. Tento způsob používání konstant pro čísla PureBasicu zaručuje přehledně uspořádaný a čitelný kód.
Dynamická PB čísla
Jako alternativu k blokům výčtu pro správu PB čísel nově vytvářených objektů můžete pro všechny použít jednu speciální konstantu. Tou konstantou je:
#PB_Any
Tuto konstantu lze použít všude, kde příkaz pro vytvoření objektu očekává PB číslo. Hodnotou této konstanty je další PB číslo, které je k dispozici. Takže například při prvním použití může mít hodnotu ‘1’, při druhém použití hodnotu ‘2’. Toto chování se skvěle hodí pro tvorbu dynamických programů, u nichž předem nemusíte vědět, kolik objektů budete vytvářet.
Jediná věc, kterou je při použití ‘#PB_Any’ jako PB čísla třeba mít na paměti, je, že abyste se na tento objekt mohli později odkazovat, musíte vědět, jakou hodnotu ‘#PB_Any’ měla při vytváření objektu. PureBasic to usnadňuje: když tuto speciální konstantu použijete jako parametr příkazu, příkaz vrátí PB číslo nově vytvořeného objektu. Zde je příklad použití dynamického PB čísla v příkazu ‘CreateImage’:
ImageDog.l = CreateImage(#PB_Any, 100, 100)
Příkaz ‘CreateImage()’ zde vrací PB číslo nově vytvořeného obrázku, protože jsme jako parametr PB čísla použili konstantu ‘#PB_Any’. Úplně stejně to funguje u všech příkazů pro vytváření objektů.
PB čísla jsou specialitou PureBasicu a umožňují rychle a snadno se odkazovat na různé objekty v programu. Chcete-li je vidět ve skutečných funkčních příkladech, podívejte se do kapitoly 9.
Identifikátory operačního systému
Některým objektům, které vytvoříte pomocí vestavěných příkazů PureBasicu, přidělí čísla také operační systém. Pomocí těchto čísel samotný operační systém sleduje například okna, písma, obrázky atd. Nápověda PureBasicu je nazývá OS Identifiers (identifikátory OS) nebo zkráceně ID. Při programování v PureBasicu si všimnete, že některé příkazy identifikátory OS vracejí, zatímco jiné je mohou potřebovat jako parametry.
Zde je několik příkazů, které vracejí identifikátor OS objektu určeného parametrem s PB číslem:
WindowOSId.l = WindowID(#Window)
GadgetOSId.l = GadgetID(#Gadget)
ImageOSId.l = ImageID(#Image)
Uvedl jsem zde tři, ale je jich ještě několik dalších. Příkazy, jejichž název končí na ‘...ID()’, obvykle vracejí identifikátory OS. Jak jsem již zmínil, zde je příklad příkazu, který identifikátor OS používá jako parametr:
CreateGadgetList(WindowOSId)
Tento příkaz slouží k vytvoření seznamu gadgetů v okně a k určení, kde se seznam vytvoří, používá identifikátor operačního systému. Identifikátor OS se v tomto příkazu používá místo PB čísla kvůli maximální kompatibilitě, pro případ, že okno bylo vytvořeno nativním API operačního systému. Pokud byste chtěli tento příkaz použít k vytvoření seznamu gadgetů v okně vytvořeném pomocí systému čísel PureBasicu, mohli bychom postupovat například takto:
CreateGadgetList(WindowID(#Window))
Všimněte si, že jako parametr používáme příkaz ‘WindowID()’, který vrací identifikátor OS okna označeného PB číslem.
Každý operační systém má nativní rozhraní pro programování aplikací, zkráceně API (Application Programming Interface). Je to vestavěná sada příkazů, kterou mohou používat všechny programovací jazyky k ovládání operačního systému a k vykreslování jeho rozhraní. Identifikátory OS slouží ke sledování všech objektů, které operační systém obsahuje, a k přístupu k nim. Všechny identifikátory OS jsou v rámci každého programu jedinečné a existují pro všechny objekty, dokonce i pro ty, které nejsou napsány v PureBasicu. Aby mohl operační systém sledovat tisíce položek, mohou být použitá čísla dost velká, takže se nedivte, když uvidíte identifikátory OS delší než osm číslic.
K vytváření plně funkčních programů v PureBasicu identifikátory OS používat nemusíte, ale pro začátečníky je dobré vědět, co jsou zač, i když je pravděpodobně používat nebudou. Identifikátory OS hrají zásadní roli při používání API kteréhokoli operačního systému, zejména Windows API, kterému se trochu více věnuji v kapitole 13.
Příklady běžných příkazů
V tomto oddílu předvedu některé z nejčastěji používaných příkazů PureBasicu. Tyto příkazy najdete ve většině programů v PureBasicu, a proto je velmi výhodné naučit se jejich syntaxi a účel. Všechny patří do různých knihoven a nemusejí spolu nijak souviset – jsou prostě velmi užitečné pro běžné programátorské úlohy. Níže je uvádím v abecedním pořadí, včetně jejich umístění v nápovědě a příkladů použití.
Asc()
(Helpfile:Reference Manual->General Libraries->String->Asc)
Příklad syntaxe:
ASCIIValue.l = Asc(Character.s)
Tento příkaz vrací ASCII hodnotu příslušného znaku podle standardní tabulky ASCII. Ve standardní znakové sadě ASCII se čísla od ‘0’ do ‘255’ používají k reprezentaci znaků a řídicích kódů počítače. Parametrem předávaným tomuto příkazu je řetězec o délce jednoho znaku, k němuž příkaz zjistí příslušnou ASCII hodnotu.
Text.s = "This is a test"
For x.l = 1 To Len(Text)
Debug Mid(Text, x, 1) + " : " + Str(Asc(Mid(Text, x, 1)))
Next x
Výše uvedený příklad používá cyklus ‘For’ a vestavěný příkaz ‘Mid()’ k rozdělení textu uloženého v proměnné ‘Text’ na jednotlivá písmena. Během běhu cyklu je každé písmeno předáno příkazu ‘Asc()’ a zjistí se jeho ASCII hodnota. Tyto hodnoty se spolu s příslušnými písmeny vypisují do okna Debug Output (výstup ladění). V tomto příkladu jsem použil několik nových příkazů, ale nepanikařte, vysvětlím je o něco dále v tomto oddílu. Úplnou tabulku ASCII se všemi znaky a příslušnými čísly od ‘0’ do ‘255’ najdete v příloze B (Užitečné tabulky).
Chr()
(Helpfile:Reference Manual->General Libraries->String->Chr)
Příklad syntaxe:
Character.s = Chr(ASCIIValue.l)
Tento příkaz vrací jednoznakový řetězec podle standardní tabulky ASCII. Vrácený řetězec je ASCII znak odpovídající hodnotě předané jako parametr. Ve standardní znakové sadě ASCII jsou čísla od ‘33’ do ‘126’ skutečné tisknutelné znaky, které najdete na standardní anglické klávesnici.
Parametr předávaný tomuto příkazu, ‘ASCIIValue.l’, je číslo, podle něhož se zjistí příslušný znak.
Text.s = Chr(84) + Chr(104) + Chr(105) + Chr(115) + Chr(32)
Text.s + Chr(105) + Chr(115) + Chr(32)
Text.s + Chr(97) + Chr(32)
Text.s + Chr(116) + Chr(101) + Chr(115) + Chr(116)
Debug Text
Výše uvedený příklad sestaví řetězec ‘This is a test’ spojením výsledků několika příkazů ‘Chr()’. Například první příkaz ‘Chr(84)’ vrátí znak ‘T’, ostatní se pak připojují k proměnné ‘Text’. Úplnou tabulku ASCII se všemi znaky a příslušnými čísly od ‘0’ do ‘255’ najdete v příloze B (Užitečné tabulky).
Delay()
(Helpfile:Reference Manual->General Libraries->Misc->Delay)
Příklad syntaxe:
Delay(Milliseconds)
Tento příkaz pozastaví veškerou činnost programu na dobu zadanou v parametru ‘Milliseconds’. Čas se měří v milisekundách (tedy tisícinách sekundy).
Debug "Start..."
Delay(5000)
Debug "This is executed 5 seconds later"
Když výše uvedený příklad spustíte, druhý příkaz ‘Debug’ se provede pět sekund po prvním, protože jsem v příkazu ‘Delay()’ použil hodnotu ‘5000’ milisekund (5 sekund).
ElapsedMilliseconds()
(Helpfile:Reference Manual->General Libraries->Misc->ElapsedMilliseconds)
Příklad syntaxe:
Result.l = ElapsedMilliseconds()
Tento příkaz vrací počet milisekund, které uplynuly od zapnutí počítače.
Debug "Start..."
StartTime.l = ElapsedMilliseconds()
Delay(5000)
Debug "Delayed for "+Str(ElapsedMilliseconds() - StartTime)+" milliseconds."
Tento příkaz se skvěle hodí pro jakékoli měření času v programu. Chcete-li například změřit, kolik milisekund uplynulo, nejprve tímto příkazem zaznamenáte počáteční čas do proměnné typu Long. Když pak chcete měření zastavit, zaznamenáte čas znovu pomocí ‘ElapsedMilliseconds()’. Výsledek získáte tak, že od koncového času odečtete počáteční čas, a zbude vám počet milisekund, které mezi oběma příkazy uplynuly. To vše ukazuje výše uvedený příklad. Při prvním použití tohoto příkazu vás možná zarazí, jak velká čísla vrací. Musíte si uvědomit, že zaznamenává milisekundy uplynulé od zapnutí systému. Velkých čísel se nelekejte, pamatujte jen, že poskytují vhodný referenční bod v čase, a výše uvedeným způsobem můžete vypočítat uplynulý čas od libovolného okamžiku.
FindString()
(Helpfile:Reference Manual->General Libraries->String->FindString)
Příklad syntaxe:
Position.l = FindString(String.s, StringToFind.s, StartPosition.l)
Tento příkaz se pokusí najít parametr ‘StringToFind’ v parametru ‘String’, a to od pozice určené parametrem ‘StartPosition’. Pokud tento řetězec najde, okamžitě vrátí pozici jeho prvního výskytu. Tyto pozice se počítají ve znacích od začátku parametru ‘String.s’, počínaje číslem ‘1’.
String.s = "I like to go fishing and catch lots of fish"
StringToFind.s = "fish"
FirstOccurrence.l = FindString(String, StringToFind, 1)
SecondOccurrence.l = FindString(String, StringToFind, FirstOccurrence + 1)
Debug "Index of the first occurrence: " + Str(FirstOccurrence)
Debug "Index of the second occurrence: " + Str(SecondOccurrence)
Tento příklad ukazuje, jak najít řetězec v jiném řetězci. První příkaz ‘FindString()’ se pokusí najít řetězec ‘fish’ od pozice ‘1’, což se mu úspěšně podaří, a do proměnné ‘FirstOccurrence’ přiřadí pozici ‘14’. Druhý příkaz ‘FindString()’ se pokusí najít tentýž řetězec, ale od pozice ‘FirstOccurrence + 1’, abychom se vyhnuli opětovnému nalezení prvního výskytu. Ten vrátí pozici ‘40’, která se přiřadí do proměnné ‘SecondOccurrence’. Obě hodnoty se pak vypíší do okna Debug Output.
Len()
(Helpfile:Reference Manual->General Libraries->String->Len)
Příklad syntaxe:
Length.l = Len(String.s)
Tento příkaz vrací délku parametru ‘String’ ve znacích.
Alphabet.s = "abcdefghijklmnopqrstuvwxyz"
LengthOfString.l = Len(Alphabet)
Debug LengthOfString
Tento příklad je velmi jednoduchý, protože i samotný příkaz ‘Len()’ je velmi jednoduchý. Abeceda se přiřadí do řetězcové proměnné ‘Alphabet’. Tato proměnná se pak předá příkazu ‘Len()’, který vrátí ‘26’ (právě tolik znaků proměnná ‘Alphabet’ obsahuje). Tato hodnota se přiřadí do proměnné ‘LengthOfString’, která se pak vypíše do okna Debug Output.
MessageRequester()
(Helpfile:Reference Manual->General Libraries->Requester->MessageRequester)
Příklad syntaxe:
Result.l = MessageRequester(Title.s, Text.s [, Flags])
;Possible Flags:
#PB_MessageRequester_Ok
#PB_MessageRequester_YesNo
#PB_MessageRequester_YesNoCancel
;Possible Return Values:
#PB_MessageRequester_Yes
#PB_MessageRequester_No
#PB_MessageRequester_Cancel
Tento příkaz slouží k vytvoření malého okna, které může ve vašem programu zobrazit libovolnou informaci. Lze ho použít v jakémkoli typu programu, nejen v programech s grafickým uživatelským rozhraním. Prvním parametrem tohoto příkazu je řetězec zobrazený v titulkovém pruhu okna. Druhým parametrem je samotný text zprávy zobrazený v okně. Třetí a poslední parametr je určen pro nepovinné příznaky (flags). Pomocí různých příznaků v posledním parametru můžete změnit styl dialogového okna tak, aby obsahovalo různá tlačítka. Váš program se zastaví, dokud není některé z těchto tlačítek stisknuto. Které to bylo, zjistíte otestováním návratové hodnoty, například takto:
Title.s = "Information"
Message.s = "This is the default style message requester"
MessageRequester(Title, Message, #PB_MessageRequester_Ok)
Message.s = "In this style you can choose 'Yes' or 'No'."
Result.l = MessageRequester(Title, Message, #PB_MessageRequester_YesNo)
If Result = #PB_MessageRequester_Yes
Debug "You pressed 'Yes'"
Else
Debug "You pressed 'No'"
EndIf
Message.s = "In this style you can choose 'Yes' or 'No' or 'Cancel'."
Result.l = MessageRequester(Title, Message, #PB_MessageRequester_YesNoCancel)
Select Result
Case #PB_MessageRequester_Yes
Debug "You pressed 'Yes'"
Case #PB_MessageRequester_No
Debug "You pressed 'No'"
Case #PB_MessageRequester_Cancel
Debug "You pressed 'Cancel'"
EndSelect
Tento příklad ukazuje všechny různé způsoby, jak lze příkaz ‘MessageRequester’ použít. Ukazuje také, jak pomocí konstant návratových hodnot zjistit, které tlačítko bylo stisknuto. Díky takovému používání konstant si nemusíte lámat hlavu pamatováním číselných hodnot. Nemusíte vědět, jaké hodnoty jsou těmto konstantám interně přiřazeny – zajímá nás jen to, zda se rovnají (nebo nerovnají) návratové hodnotě příkazu.
Mid()
(Helpfile:Reference Manual->General Libraries->String->Mid)
Příklad syntaxe:
Result.s = Mid(String.s, StartPosition.l, Length.l)
Tento příkaz vrací oříznutý řetězec, který je vyjmut z jiného řetězce. Výchozí řetězec se předává jako parametr ‘String’. Vyjímaný řetězec lze pak vzít z libovolné pozice ve výchozím řetězci, určené parametrem ‘StartPosition’. Délka nového vyjímaného řetězce se určuje parametrem ‘Length’. Zde je příklad:
StartingString.s = "Hickory Dickory Dock"
ExtractedString.s = Mid(StartingString, 17, 4)
Debug ExtractedString
Zde vyjímám řetězec ‘Dock’ tak, že zadám počáteční pozici ‘17’ a poté vyjmu ‘4’ znaky. Stejně jako u příkazu ‘FindString()’ se pozice ve výchozím řetězci měří ve znacích.
Random()
(Helpfile:Reference Manual->General Libraries->Misc->Random)
Příklad syntaxe:
Result.l = Random(Maximum.l)
Tento příkaz se předvádí snadno, protože jediné, co dělá, je, že vrací náhodné celé číslo mezi ‘0’ a hodnotou zadanou v parametru ‘Maximum’ (včetně obou mezí).
Debug Random(100)
Ve výše uvedeném příkladu vrátí příkaz ‘Random()’ náhodnou hodnotu mezi ‘0’ a ‘100’.
Str(), StrF(), StrQ(), StrD()
(Helpfile:Reference Manual->General Libraries->String->Str)
Příklady syntaxe:
Result.s = Str(Value.b)
Result.s = Str(Value.w)
Result.s = Str(Value.l)
Result.s = StrF(Value.f [, DecimalPlaces.l])
Result.s = StrQ(Value.q)
Result.s = StrD(Value.d [, DecimalPlaces.l])
Tyto čtyři příkazy jsou v podstatě stejné. Hlavně slouží k převodu číselných hodnot na řetězce. Jsou zde čtyři různé příkazy pro čtyři různé typy číselných hodnot: ‘Str()’ pro typy Byte, Word a Long, ‘StrF()’ pro typ Float, ‘StrQ()’ pro typ Quad a ‘StrD()’ pro typ Double. K převodu konkrétní číselné hodnoty na řetězec musíte použít správný typ funkce ‘Str()’. U ‘StrF()’ a ‘StrD()’ si všimnete, že mají navíc nepovinný parametr ‘DecimalPlaces’. Pokud tento parametr použijete, určuje, na kolik desetinných míst se má hodnota před převodem na řetězec oříznout.
Debug "Long converted to a String: " + Str(2147483647)
Debug "Float converted to a String: " +StrF(12.05643564333454646, 7)
Debug "Quad converted to a String: " +StrQ(9223372036854775807)
Debug "Double converted to a String: " +StrD(12.05643564333454646, 14)
Výše uvedený příklad ukazuje, jak převést čtyři různé druhy číselných hodnot na řetězce. V každém případě jsem k převedenému řetězci připojil řetězcový literál, aby vznikly celé věty, a ty pak vypisuji do okna Debug Output. Důležité je uvědomit si, že pokud u příkazů pro typ Float nebo Double vynecháte parametr ‘DecimalPlaces’, použijí oba výchozích šest desetinných míst a můžete přijít o hodně přesnosti.
Val(), ValF(), ValQ(), ValD()
(Helpfile:Reference Manual->General Libraries->String->Val)
Příklady syntaxe:
Result.l = Val(String.s)
Result.f = ValF(String.s)
Result.q = ValQ(String.s)
Result.d = ValD(String.s)
Tyto čtyři příkazy jsou si navzájem v podstatě rovnocenné a jsou přesným opakem příkazů ‘Str()’. Rozdíl je v tom, že tyto příkazy přijímají jako parametr řetězec a vracejí číselnou hodnotu podle toho, která varianta ‘Val()’ je použita. Například ‘Val()’ vrací Long, ‘ValF()’ vrací Float, ‘ValQ()’ vrací Quad a ‘ValD()’ vrací Double. Zde je jednoduchý příklad:
LongTypeVar.l = Val("2147483647")
FloatTypeVar.f = ValF("12.05643564333454646")
QuadTypeVar.q = ValQ("9223372036854775807")
DoubleTypeVar.d = ValD("12.05643564333454646")
Debug LongTypeVar
Debug FloatTypeVar
Debug QuadTypeVar
Debug DoubleTypeVar
V tomto příkladu jsem použil všechny čtyři typy příkazu ‘Val()’ k převodu čtyř řetězců na jejich příslušné číselné typy. Musíte však mít na paměti, že pokud převádíte z řetězců čísla, která jsou větší, než dokáže výsledný typ pojmout, dojde k jejich oříznutí. Podíváte-li se například ve výše uvedeném příkladu na řádek ‘ValF("12.05643564333454646")’, toto číslo je příliš velké či přesné, než aby ho běžný typ Float dokázal pojmout, takže při převodu příkazem ‘ValF()’ se ořízne, aby se vešlo do cílového typu.
Práce se soubory
Používání souborů je pro každý program přirozeným způsobem ukládání a načítání dat. PureBasic poskytuje plnou podporu pro čtení a zápis souborů a dokáže číst a zapisovat libovolný počet souborů současně. Všechny příkazy pro práci se soubory jsou ve stejné knihovně File, kterou najdete v nápovědě PureBasicu zde:
(Helpfile:Reference Manual->General Libraries->File)
V tomto oddílu nebudou podrobně vysvětleny všechny příkazy pro práci se soubory, ale poskytnu vám dobrý základ čtení a zápisu souborů, takže až budete ostatní příkazy používat, snadno jim porozumíte.
Zápis do souboru
Začněme příkladem, jak zapsat nějaká data do souboru – zapíšeme několik řetězců do jednoduchého textového souboru.
#FILE_RHYME = 1
Dim Rhyme.s(3)
Rhyme(0) = "Baa baa black sheep, have you any wool?"
Rhyme(1) = "Yes sir, yes sir, three bags full!"
Rhyme(2) = "One for the master, one for the dame,"
Rhyme(3) = "And one for the little boy who lives down the lane."
If CreateFile(#FILE_RHYME, "Baa baa.txt")
For x.l = 0 To 3
WriteStringN(#FILE_RHYME, Rhyme(x))
Next x
CloseFile(#FILE_RHYME)
EndIf
Nejprve jsem pro náš nový souborový objekt určil jako PB číslo konstantu ‘#FILE_RHYME’ a definoval jsem pole řetězců, do kterého uložím svou říkanku. Po přidání řetězců do pole ‘Rhyme()’ přejdeme k zápisu souboru. Kdybych chtěl otevřít existující soubor a zapisovat do něj, mohl bych použít příkaz ‘OpenFile()’, ale ve výše uvedeném příkladu chci vytvořit nový soubor a zapisovat do něj, proto místo toho používám příkaz ‘CreateFile()’.
Příkaz ‘CreateFile()’ přijímá dva parametry: prvním je PB číslo, s nímž bude nový souborový objekt spojen, druhým je skutečný název, který soubor po vytvoření dostane. Příkaz ‘CreateFile()’ jsem také použil uvnitř příkazu ‘If’, abych otestoval, zda vrací pravdu (true). Pokud ano, soubor byl úspěšně vytvořen a mohu pokračovat v programu. Vytvoření souboru je vždy dobré otestovat, protože pokud se pokusíte zapisovat do neplatného souboru, může se něco hodně pokazit.
K samotnému zápisu řetězce do souboru jsem použil příkaz ‘WriteStringN()’. Ten přijímá dva parametry: prvním je PB číslo spojené se souborovým objektem, do kterého chci zapisovat, druhým je samotný řetězec, který chci zapsat. Pomocí cyklu procházím pole a zapisuji celý jeho obsah do souboru, a tím zapíšu celou říkanku. Příkaz ‘WriteStringN()’ použitý v tomto příkladu je rozšířenou verzí příkazu ‘WriteString()’. Jediným rozdílem je ve skutečnosti ‘N’ před závorkami. Toto ‘N’ znamená, že se při provádění příkazu za řetězec zapíše znak „nového řádku“. Protože chci, aby za každým řetězcem zapsaným do souboru začínal nový řádek, používám příkaz ‘WriteStringN()’, jinak by bylo všechno na jednom řádku.
Jakmile do souboru zapíšu všechny řetězce a cyklus skončí, zavřu soubor příkazem ‘CloseFile()’. Ten přijímá jen jeden parametr, a to PB číslo souborového objektu, který chcete zavřít.
Soubor s říkankou by nyní měl být někde na vašem pevném disku. Pokud vytvoříte soubor pomocí relativního názvu, například ‘Baa baa.txt’, bude nově vytvořený soubor ve stejném adresáři jako soubor se zdrojovým kódem. Potřebujete-li vytvořit soubor na konkrétnějším místě, musíte zadat absolutní cestu, která by měla obsahovat označení jednotky, všechny adresáře a název souboru, například nějak takto:
...
If CreateFile(#FILE_RHYME, "C:\My Directory\Baa baa.txt")
...
Při tomto postupu však musíte vždy zajistit, aby všechny adresáře uvedené v cestě před zápisem souboru skutečně existovaly, jinak se vytvoření souboru nezdaří.
Jak zapisovat hodnoty ostatních vestavěných typů?
Zápis ostatních vestavěných typů do souboru je stejně snadný jako zápis řetězců. Teď, když rozumíte tomu, jak funguje příkaz ‘WriteString()’, snadno pochopíte i ostatní. Zde jsou příklady syntaxe pro zápis ostatních vestavěných typů:
WriteByte(#File, Value.b)
WriteChar(#File, Value.c)
WriteWord(#File, Value.w)
WriteLong(#File, Value.l)
WriteQuad(#File, Value.q)
WriteFloat(#File, Value.f)
WriteDouble(#File, Value.d)
Pomocí nich můžete do souboru zapsat hodnotu libovolného vestavěného typu a všechny příkazy lze použít tolikrát, kolikrát chcete. Tyto hodnoty lze v případě potřeby spolu s řetězci v jednom souboru libovolně a opakovaně kombinovat. Aby to bylo ještě jednodušší, používají se všechny tyto příkazy stejným způsobem jako příkaz ‘WriteString()’: prvním parametrem je souborový objekt, do kterého se zapisuje, a druhým je samotná zapisovaná hodnota.
Čtení ze souboru
Čtení ze souborů je stejně jednoduché jako zápis do nich. PureBasic to díky výkonným příkazům pro čtení souborů činí mimořádně snadným. V dalším příkladu čtu řetězce ze souboru ‘Report.txt’ a ukládám je do spojového seznamu ‘FileContents’. Obsah tohoto spojového seznamu se pak vypíše do okna Debug Output, čistě proto, aby byla vidět načtená řetězcová data. Tato data však vypisovat nemusíte – můžete s řetězci v programu dále pracovat jakkoli uznáte za vhodné.
#FILE_REPORT = 1
NewList FileContents.s()
If ReadFile(#FILE_REPORT, "Report.txt")
While Eof(#FILE_REPORT) = #False
AddElement(FileContents())
FileContents() = ReadString(#FILE_REPORT)
Wend
CloseFile(#FILE_REPORT)
EndIf
ForEach FileContents()
Debug FileContents()
Next
Na začátku kódu jsem použil konstantu, která poslouží jako PB číslo otevřeného souboru. Pak vytvořím spojový seznam ‘FileContents’, do kterého uložím řetězce, které budeme číst. K uložení těchto řetězců nemusíte použít spojový seznam, jen mi připadá, že je to tak trochu přehlednější. Spojový seznam jsem zde použil proto, že se snadno používá a může se rozrůstat o nové položky, na rozdíl od polí, jejichž velikost je předem daná.
Soubor otevírám příkazem ‘ReadFile()’, který ho otevře pouze pro čtení a po dobu, kdy je otevřený, zabrání jakémukoli zápisu do něj. Stejně jako u příkazu ‘CreateFile()’ je prvním parametrem PB číslo, s nímž bude nově otevřený soubor spojen, a druhým je název čteného souboru. Stejně jako předtím jsem tento příkaz použil uvnitř příkazu ‘If’, abych se ujistil, že vrací pravdu. Pokud ano, mohu si být jistý, že byl soubor správně otevřen a mohu k němu řádně přistupovat.
Jakmile je soubor otevřený, potřebuji přečíst informace v něm. Použil jsem zde cyklus ‘While’, abych nemusel vypisovat opakované příkazy pro čtení jednotlivých řetězců. Cyklus je sestaven pomocí příkazu ‘Eof()’ – ‘Eof’ znamená „End of file“ (konec souboru) a tento příkaz vrátí pravdu, pokud jste dosáhli konce otevřeného souboru. V cyklu při každém průchodu kontroluji, zda příkaz vrací nepravdu (false); pokud ano, vím, že nejsem na konci souboru a mohu z něj dál číst. Příkaz ‘Eof()’ přijímá jeden parametr, a to PB číslo souboru, který chcete otestovat.
Dokud je soubor otevřený, čtu z něj příkazem ‘ReadString()’ vždy po jednom řetězci. Řetězec vrácený tímto příkazem začíná na začátku aktuálního řádku a končí, jakmile narazí na nový řádek; příkaz zároveň posune ukazatel pozice v souboru o jeden řádek dopředu. Pokaždé, když ze souboru přečtu řetězec, vytvořím ve spojovém seznamu ‘FileContents’ nový prvek a řetězec do něj přiřadím. V tom pokračuji, dokud příkaz ‘Eof()’ nevrátí pravdu, čímž se cyklus ukončí.
Po skončení cyklu otevřený soubor řádně zavřu příkazem ‘CloseFile()’. Zavření souboru je důležité a mělo by proběhnout, jakmile s ním skončíte. Načtená data se pak jednoduchým cyklem ‘ForEach’ vypíší do okna Debug Output.
Jak číst hodnoty ostatních vestavěných typů?
Přestože se minulý příklad zabýval řetězci, můžete stejně snadno číst i hodnoty ostatních typů. PureBasic poskytuje pro každý z vestavěných typů specifické příkazy, které je správně načtou.
ReadByte(#File)
ReadChar(#File)
ReadWord(#File)
ReadLong(#File)
ReadQuad(#File)
ReadFloat(#File)
ReadDouble(#File)
Pro jednoduchost mají všechny tyto příkazy stejný parametr jako příkaz ‘ReadString()’. Tímto parametrem je PB číslo otevřeného souborového objektu, ze kterého se čte. Jediný rozdíl mezi těmito příkazy a ‘ReadString()’ spočívá v tom, že tyto přečtou ze souboru pouze jednu hodnotu, která zabírá počet bajtů odpovídající danému typu. Na rozdíl od ‘ReadString()’ nečtou dál, dokud nenarazí na další řádek. Kdybych například chtěl ze souboru přečíst hodnotu typu Long, použil bych ‘ReadLong()’, který by přečetl ‘4’ bajty a vrátil hodnotu obsaženou v těchto bajtech jako Long. Tím by se zároveň ukazatel pozice v souboru posunul o ‘4’ bajty dopředu, připravený pro další příkaz čtení.
Jak zjistit polohu ukazatele pozice v souboru?
Kdykoli během čtení ze souboru nebo zápisu do něj můžete zjistit polohu ukazatele pozice v souboru pomocí příkazu ‘Loc()’. ‘Loc()’ znamená „Location“ (poloha). Návratová hodnota se udává v bajtech.
(Helpfile:Reference Manual->General Libraries->File->Loc)
Příklad syntaxe:
Position.q = Loc(#File)
Tento příkaz vrátí polohu ukazatele pozice v souboru (v bajtech) v souborovém objektu určeném parametrem s PB číslem. Poloha se vrací jako hodnota typu Quad, aby byly podporovány velké soubory.
Jak přesunout ukazatel pozice v souboru?
Ukazatel pozice v souboru lze kdykoli přesunout příkazem ‘FileSeek()’.
(Helpfile:Reference Manual->General Libraries->File->FileSeek)
Příklad syntaxe:
FileSeek(#File, NewPosition.q)
Tento příkaz přijímá dva parametry: prvním je PB číslo souborového objektu, který se má upravit, a druhým je nová poloha (v bajtech) ukazatele pozice v souboru. Díky tomu můžete kdykoli číst z libovolné pozice v libovolném souboru. Parametr ‘NewPosition’ je typu Quad kvůli podpoře velkých souborů.
Jak zjistit aktuální velikost souboru?
Velikost právě používaného souboru zjistíte příkazem ‘Lof()’. ‘Lof()’ znamená „Length of file“ (délka souboru).
(Helpfile:Reference Manual->General Libraries->File->Lof)
Příklad syntaxe:
Length.q = Lof(#File)
Tento příkaz vrátí velikost souborového objektu určeného parametrem s PB číslem v bajtech. Délka se vrací jako typ Quad, aby byly podporovány velké soubory.
Příklad použití Loc, Lof a FileSeek
V následující ukázce předvedu použití příkazů ‘Loc()’, ‘Lof()’ a ‘FileSeek()’, abych vám poskytl názorný příklad jejich využití. V níže uvedeném kódu čtu hudební soubor MP3, abych zjistil, zda obsahuje vloženou značku (tag) ID3(v1). Tyto značky obvykle obsahují informace jako jméno interpreta, název skladby, žánr atd.
Po přečtení specifikace značek MP3 ID3 na internetu jsem zjistil, že informace značky se vždy přidávají na konec běžného souboru MP3 a že tato značka je vždy dlouhá ‘128’ bajtů. Specifikace uvádí, že první ‘3’ bajty této značky tvoří znaky ‘TAG’, a právě to budu kontrolovat.
Zde je kód:
#FILE_MP3 = 1
MP3File.s = "Test.mp3"
If ReadFile(#FILE_MP3, MP3File)
FileSeek(#FILE_MP3, Lof(#FILE_MP3) - 128)
For x.l = 1 To 3
Text.s + Chr(ReadByte(#FILE_MP3))
Next x
CloseFile(#FILE_MP3)
If Text = "TAG"
Debug "'" + MP3File + "' has an ID3v1 tag embedded within it."
Else
Debug "'" + MP3File + "' does not have an ID3v1 tag embedded within it."
EndIf
EndIf
Po otevření souboru příkazem ‘ReadFile()’ přesunu ukazatel pozice v souboru na správné místo tak, že zjistím délku souboru a pak se vrátím o ‘128’ bajtů zpět. Takto:
FileSeek(#FILE_MP3, Lof(#FILE_MP3) - 128)
Po provedení tohoto příkazu je ukazatel pozice v souboru na správném místě. Pomocí cyklu tedy třikrát provedu operaci ‘ReadByte()’ a každý bajt předám příkazu ‘Chr()’, který vrátí znak. Tyto znaky se pak spojí do řetězcové proměnné ‘Text’. Po skončení cyklu a zavření souboru zkontroluji hodnotu proměnné ‘Text’. Pokud se řetězec v proměnné ‘Text’ rovná ‘TAG’, je v souboru MP3 přítomna značka ID3(v1).
Čtěte nápovědu
To je již léta bojový pokřik mnoha dobrých programátorů, zejména na internetových fórech. Chcete-li něčemu skutečně porozumět, musíte to studovat, a chcete-li něco pořádně nastudovat, musíte si o tom přečíst všechno. Nelze se vyhnout skutečnosti, že lidé, kteří o nějakém tématu čtou více, mu obvykle lépe rozumějí. To platí obzvlášť u programovacích jazyků.
Nejlepší rada, kterou vám mohu dát na začátek učení PureBasicu, je přečíst si nápovědu PureBasicu od začátku do konce a projít každou stránku o každém příkazu. Zní to velmi nudně, ale věřte mi, že to výrazně prohloubí vaše porozumění PureBasicu a poskytne vám vynikající představu o tom, co všechno lze v tomto skvělém jazyce dokázat.
Někdy dobrého programátora od skutečně vynikajícího odlišuje jen to, kolik relevantních informací přečetl a nastudoval.
Doufám, že vám tato kapitola poskytla dostatečný vhled, abyste dokázali číst nápovědu a pochopit, jak používat většinu vestavěných příkazů čistě na základě příkladů syntaxe v nápovědě.
8Dobrý programátorský styl
Až dosud jsem se soustředil na vysvětlování základních principů programování v PureBasicu: jeho vestavěných typů, příkazů, výrazů a dalších věcí. Myslím, že nastal čas zmínit se také o stylu, jakým by měl být program napsán.
V této kapitole budu mluvit o něčem, co by měli všichni programátoři znát a dodržovat, a tím je dobrý programátorský styl. Učit se programovat může být velká zábava, ale ta se rychle vytratí, jakmile se ocitnete tváří v tvář špatně napsanému kódu (a snažíte se mu porozumět), zvlášť pokud jste jeho autorem vy sami. Úhledně naformátovaný kód nejenže vypadá profesionálněji, ale skutečně vám pomáhá ho lépe číst a chápat.
V následujících odstavcích popíšu, jak můžete svůj kód formátovat, aby byl co nejčitelnější. Nemusí to být nutně ten jediný správný způsob, je to prostě způsob, jakým obvykle pracuji já. Doufám, že si po přečtení dalšího textu vytvoříte svůj vlastní styl a budete se ho držet.
Dále v této kapitole vám ukážu tipy a triky, které vám pomohou vyhnout se chybám v kódu, a uvedu příklady, jak chyby ošetřit, když už k nim dojde. Zařadil jsem také několik rad, jak pomocí debuggeru (ladicího programu) PureBasicu vystopovat, kde ve vašem kódu mohou problémy vznikat.
Proč se obtěžovat úhledným formátováním kódu?
Tuto otázku si začátečníci občas kladou, a je proto namístě se jí věnovat. Jednou z možných odpovědí je protiotázka: kdybych tuto knihu napsal bez nadpisů, podnadpisů, odstavců a velkých písmen a slil celý text do jednoho velkého bloku, četla by se stejně snadno jako teď?
Úhledné formátování kódu nemá s kompilací programu vůbec nic společného a nijak nemění ani funkci, ani běh zkompilovaného programu; dělá se čistě proto, aby byl kód snadno čitelný. Proč se tedy obtěžovat? Mohu vám zaručit, že v budoucnu budete pracovat na zdrojovém kódu, ke kterému se budete vracet znovu a znovu. Někdy proto, že nestihnete dokončit práci za jeden den, jindy proto, že budete upravovat starý program a přidávat do něj nové funkce. Pokaždé budete muset svůj kód znovu přečíst a pochopit, co dělá. Pokud bude váš kód ošklivý a neuspořádaný, zaručuji vám, že se v něm budete jen těžko vyznávat a obtížně budete na projektu pokračovat.
Když se ve vašem programu objeví chyba a kód není dobře uspořádaný, budete mít také mnohem těžší práci s hledáním místa, kde chyba vězí. Program, který je vám dnes naprosto jasný, už zítra jasný být nemusí. A pokud vám chvíli trvá, než se v něm vyznáte, jak dlouho by to trvalo někomu jinému?
Dalším dobrým důvodem pro psaní dobře naformátovaného kódu je týmová práce. Pokud pracujete na projektu v týmu a upravujete kód jiných lidí a zároveň píšete nový, je nezbytné, aby celý tým používal stejný standard formátování. Jen tak mohou všichni členové týmu rychle a snadno porozumět kódu kteréhokoli programátora a efektivně pokračovat v práci na projektu.
Hodnota komentářů
Úplně první věcí, o které je třeba mluvit v souvislosti s dobrým programátorským stylem, je používání komentářů. Až dosud jsem v žádném příkladu komentáře nepoužil. Rozhodl jsem se s nimi počkat až do této kapitoly, abych je mohl pořádně popsat, protože komentáře považuji za jeden z nejdůležitějších aspektů psaní dobrého kódu.
Zjednodušeně řečeno jsou komentáře jen řádky textu vložené do programu, které slouží k popisu či dokumentaci toho, co váš kód dělá. Nikdy se nekompilují do výsledného spustitelného souboru a nemají na program žádný jiný vliv. Můžete jich použít, kolik chcete, protože výkon programu nijak neovlivní.
Komentáře umožňují podrobněji vysvětlit, co píšete, a také podat přehled o tom, jak mají jednotlivé části programu fungovat a jak spolupracují se zbytkem kódu. Tady je krátký příklad:
;The procedure Pi() is called to return the value of Pi.
;This calculation is only accurate to six decimal places.
Procedure.f Pi()
ProcedureReturn 4 * (4 * ATan(1/5) - ATan(1/239))
EndProcedure
CircleDiameter.l = 150
Debug "A circle which has a diameter of " + Str(CircleDiameter) + "mm"
Debug "has a circumference of " + StrF(CircleDiameter * Pi()) + "mm."
V tomto příkladu jsem pomocí komentářů popsal funkci procedury ‘Pi()’ a, což je důležitější, vysvětlil jsem její omezení: je přesná jen na šest desetinných míst.
Vytváření komentářů je jednoduché, protože každý komentář začíná středníkem (‘;’), a to je vše:
;This is a comment
Komentáře se mohou objevit naprosto kdekoli ve zdrojovém kódu, dokonce i na stejném řádku jako jiný příkaz, například takto:
Procedure.l AddTogether(a.l, b.l) ;Add two numbers and return the result
ProcedureReturn a + b
EndProcedure
Musíte si pamatovat jen středník na začátku, který určuje, kde komentář začíná. Komentář pak sahá až do konce aktuálního řádku a s novým řádkem končí. Chcete-li, aby komentář pokračoval i na dalším řádku, musíte i ten nový řádek začít dalším středníkem.
Chcete-li kód komentovat správně, dbejte na to, aby každý komentář měl smysl, a odolejte pokušení komentářem jen opakovat to, co říká kód. Komentáře by neměly být příliš dlouhé, ale dost dlouhé na to, aby vysvětlily, co je potřeba. Obecné pravidlo pro psaní komentářů zní: představte si, že složitější části svého kódu vysvětlujete jinému člověku. Až se ke svému kódu za šest měsíců vrátíte, budete rádi, že tam komentáře máte a že vám pomohou vaší práci porozumět.
Komentáře lze použít k:
1). přidání informací o licenci nebo autorských právech; 2). vysvětlení, proč byl zvolen určitý postup; 3). poznámkám o tom, kde by se dal kód vylepšit; 4). objasnění funkce složitých procedur; 5). objasnění vnitřního fungování procedur nakreslením grafů nebo vzorců pomocí ASCII artu.
Můj formát kódu
Celkové rozvržení mého kódu a způsob, jakým strukturuji různé drobnosti, vychází ze standardního formátu kódu několika programovacích jazyků. V tomto stylu je napsána celá tato kniha a osobně ho považuji za formát, který se snadno čte i učí. Zde vysvětlím proč a ukážu vám, jak kód píšu, abyste měli náskok při psaní úhledných a čitelných programů. Doufám, že vám bude tento styl užitečný a že ho budete i nadále používat.
Proměnné, pole, spojové seznamy a procedury
Tyto prvky obvykle pojmenovávám jasnými, přesnými, vyslovitelnými a popisnými názvy podle notace ‘CamelHump’ („velbloudí hrby“). Tato notace je snadno pochopitelná: první písmeno názvu napíšete velké a velkým písmenem začnete i každé další slovo, které následuje. Velká písmena slouží jako oddělovač slov, protože mezery použít nelze. Díky tomuto psaní velkých písmen vypadají slova, jako by se po nich táhly hrby, odtud název notace ‘CamelHump’. Takto dávám přednost formátování všech proměnných, polí a spojových seznamů, protože podle mě se pak lépe čtou.
Příklad:
NumberOfDays.l = 365
Dim MonthsOfTheYear.s(11)
NewList Days.s()
Konstanty
Konstanty formátuji podle standardního stylu jazyka C a Windows API, tedy celé velkými písmeny. Pokud v nich potřebuji oddělit jednotlivá slova, použiji podtržítka.
Příklad:
#SPEED_OF_LIGHT = 299792458 ; Meters per second
Struktury
Pro struktury používám stejný standard jako pro konstanty, tedy názvy psané celé velkými písmeny. I to je standardní formát jazyka C a Windows API. Stejně jako u konstant používám podtržítka, pokud potřebuji oddělit jednotlivá slova. Všimněte si, že následující název struktury je celý velkými písmeny.
Příklad:
Structure USER_SERVICE
ServiceType.s
ServiceCode.l
EndStructure
Odsazování
Odsazení představuje způsob, jak strukturovat kód a usnadnit rozpoznání začátku a konce procedur, cyklů a podmíněných příkazů. Odsazení se velmi často používá čistě jako vizuální pomůcka při čtení kódu. Tady jsou příklady dobrého odsazení:
; Returns a String containing a floating point number that’s been rounded up.
; 'Number' = Number to round up and return as a String.
; 'DecimalPlaces' = Number of decimal places to round up to.
Procedure.s StrFRound(Number.f, DecimalPlaces.l)
Protected R.f
Protected T.f
If DecimalPlaces < 0
DecimalPlaces = 0
EndIf
R.f = 0.5 * Pow(10, -1 * DecimalPlaces)
T.f = Pow(10, DecimalPlaces)
ProcedureReturn StrF(Int((Number + R) * T) / T, DecimalPlaces)
EndProcedure
Debug StrFRound(3.1415927, 4)
Jak vidíte, v tomto příkladu jsem kód odsadil pomocí tabulátorů. Tím je jasně vymezen kód mezi počátečním a koncovým klíčovým slovem bloku kódu, jako je procedura nebo příkaz ‘If’. Stejným způsobem odsazuji i kód cyklů, procedur, příkazů ‘If’ a ‘Select’ a bloků ‘Enumeration’. Odsazování je užitečné zejména u vnořených příkazů, například takto:
For x = 0 To 2
For y = 0 To 2
z.l = 0
While z =< 10
Debug x * y + z
z + 1
Wend
Next y
Next x
Zde jasně vidíte počáteční a koncové klíčové slovo každého cyklu i veškerý kód, který obsahují. Na každý blok kódu se používá jen jeden tabulátor doprava, aby kód uvnitř bloku nebyl příliš daleko od počátečního a koncového klíčového slova, což by také mohlo čtení kódu ztížit.
Podíváte-li se na řádek ‘For y = 0 To 2’, můžete v kódu snadno sledovat směrem dolů a najít řádek ‘Next y’. To je začátek a konec příkazu ‘If’. Při pohledu na to víme, že veškerý kód odsazený doprava se nachází uvnitř tohoto bloku. To bude tím užitečnější, čím větší budou vaše programy.
Více příkazů na jednom řádku
Občas píšu více příkazů na jeden řádek, abych část zdrojového kódu zkrátil. To se snadno provede pomocí znaku dvojtečky (‘:’). Dvojtečka sděluje kompilátoru, že začal nový řádek, a ten pak zachází s dalším příkazem, jako by stál na samostatném řádku. Podívejte se na toto:
Dim Birds.s(3)
Birds(0)="Sparrow" : Birds(1)="Wren" : Birds(2)="Cuckoo" : Birds(3)="Owl"
Někteří programátoři se na tento druh formátování dívají skrz prsty, protože může zhoršovat čitelnost. Podle mě to někdy může pomoci, pokud se to nepřehání.
Rozdělení zdrojového kódu
Když píšu program a ten začíná být velký, mám ve zvyku ho rozdělit do mnoha samostatných souborů se zdrojovým kódem. Tyto soubory jsou standardní soubory PureBasicu, ale mají buď příponu ‘.pb’, nebo ‘.pbi’. Soubory ‘.pb’ jsou standardní soubory s kódem PureBasicu, zatímco soubory ‘.pbi’ jsou vkládané soubory (Include files) PureBasicu. Oba typy souborů jsou naprosto stejné a oba jsou přiřazeny k IDE, takže se v něm správně otevírají. Přípona ‘*.pbi’ je však čistě kosmetická a slouží k tomu, abyste při pohledu do složky, kde jsou soubory pohromadě, rychle odlišili vkládané soubory od hlavního souboru programu.
V těchto samostatných souborech uchovávám různé části hlavního programu a pak je všechny vložím do hlavního souboru se zdrojovým kódem pomocí klíčového slova ‘IncludeFile’ nebo ‘XIncludeFile’.
Pokud například definuji mnoho procedur, mohu vytvořit samostatný zdrojový soubor nazvaný ‘Procedures.pbi’, v němž budou definovány všechny moje procedury. Na začátek hlavního souboru se zdrojovým kódem pak kód procedur vložím takto:
IncludeFile "Procedures.pbi"
Výsledkem je, že se všechny řádky kódu ze souboru „Procedures.pbi“ vezmou a vloží do mého hlavního zdrojového kódu počínaje tímto řádkem. Kód z vkládaného souboru se do hlavního kódu přidá přesně v místě, kde se nachází příkaz ‘IncludeFile’. To se děje ještě před kompilací, takže kompilátor vidí jen jeden velký soubor, který má zkompilovat.
Pokud do hlavního kódu přidáte řádek ‘IncludeFile’ se stejným názvem souboru vícekrát, vloží se do hlavního souboru duplicitní části kódu. Chcete-li se tomu vyhnout, musíte použít klíčové slovo ‘XIncludeFile’. To se používá stejně jako výše:
XIncludeFile "Procedures.pbi"
Řádek ‘XIncludeFile’ vloží kód ze souboru ‘Procedures.pbi’ jen tehdy, pokud tento řádek ještě nebyl použit. Příkaz ‘IncludeFile’ používám jen zřídka, protože v daném programu obvykle potřebujete vložit každý vkládaný soubor jen jednou. Raději používám ‘XIncludeFile’ pro všechno, protože to snižuje výskyt chyb.
Správné ukončení programu
Chcete-li program správně ukončit, měli byste vždy použít klíčové slovo ‘End’. To v programu vše řádně uzavře a uvolní veškerou paměť, kterou program používal. S klíčovým slovem ‘End’ lze v případě potřeby použít i volitelný návratový (výstupní) kód. Syntaxe je jednoduchá: toto klíčové slovo prostě použijete tam, kde chcete program ukončit. V jednom programu se může objevit i více příkazů ‘End’, pokud potřebujete program případně ukončit na více místech kódu.
Bez návratového kódu:
End ; Immediately ends the program and frees all memory used by it.
S návratovým kódem:
End 1 ; Immediately ends the program, frees all memory and returns 1.
Zlatá pravidla pro psaní snadno čitelného kódu
Zde je seznam zlatých pravidel, která při psaní programu dodržuji. Držím se jich, i když píšu velmi malé programy. Budete-li se jimi řídit, budete i vy psát dobrý, čistý a srozumitelný kód. Používání standardního způsobu práce dává vašemu kódu jasnou a přehlednou strukturu pro každého, kdo ho čte, a díky němu bude kód vypadat a působit profesionálněji.
1). Dávejte všem proměnným, procedurám, polím atd. jasné, přesné, vyslovitelné a popisné názvy. 2). Logicky související proměnné nebo data seskupujte do polí nebo struktur. 3). Procedury by měly plnit jednu funkci a plnit ji dobře. 4). K vyjádření struktury kódu používejte odsazení. 5). Ve výrazech používejte závorky, abyste se vyhnuli nejasnostem při vyhodnocování. 6). K oddělení jednotlivých procedur a dalších bloků kódu používejte prázdné řádky. 7). Snažte se nepoužívat klíčová slova ‘Goto’ a ‘Gosub’. 8). Používejte komentáře, abyste ostatním (nebo sobě) pomohli kódu lépe porozumět. 9). Nesnažte se špatný kód dokumentovat komentáři, raději ho pořádně přepište. 10). Při práci v týmu se před začátkem dohodněte na stylu formátování a pak ho dodržujte.
Jak minimalizovat a ošetřovat chyby
V této kapitole budu mluvit o metodách, které vám pomohou zachytit chyby ve vašem kódu. I ten nejzkušenější a nejsvědomitější programátor může udělat chybu, zapomenout ošetřit ty běžné nebo je dokonce úplně přehlédnout. Zde odhalím osvědčené pracovní postupy spolu s několika cennými tipy a triky, díky nimž budete při programování ostražitější a minimalizujete pravděpodobnost, že nastanou nějaké problémy.
Používejte proceduru pro ošetření chyb
Pokud PureBasic používáte pro velké projekty, možná zjistíte, že provádíte mnoho testů, abyste ověřili pravdivou hodnotu. Je to proto, že velké množství příkazů vrací nějakou hodnotu. Tato hodnota je téměř vždy celé číslo, a pokud vše proběhlo v pořádku, je vždy větší než ‘0’. Někteří programátoři před pokračováním testují příkazy na pravdivou hodnotu pomocí příkazů ‘If’, protože, jak si jistě pamatujete z kapitoly 4, vše větší než ‘0’ se v PureBasicu považuje za pravdivou hodnotu.
Zatímco někteří lidé pomocí příkazů ‘If’ kontrolují, zda vše proběhlo v pořádku, než budou pokračovat, já považuji tento přístup za užitečný jen u malých programů, protože u větších může vést ke spoustě nepřehledných vnořených příkazů ‘If’. Místo příkazu ‘If’ proto obvykle používám jako obsluhu chyb proceduru. Nejenže je díky tomu zdrojový kód mnohem čitelnější, ale této proceduře můžete předávat i vlastní zprávy, které uživatele informují, kde přesně v programu a u kterého příkazu se něco pokazilo. Abyste viděli obě strany, zde je příklad testování příkazu pomocí příkazu ‘If’:
#TEXTFILE = 1
If ReadFile(#TEXTFILE, "TextFile.txt")
Debug ReadString(#TEXTFILE)
CloseFile(#TEXTFILE)
Else
MessageRequester("Error", "Could not open the file: 'TextFile.txt'.")
EndIf
Zde testuji, zda mohu číst soubor ‘TextFile.txt’, a pokud ano, přečtu z něj řetězec. I když je tato metoda u malých programů v pořádku, u větších projektů dávám přednost tomuto způsobu:
#TEXTFILE = 1
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
HandleError(ReadFile(#TEXTFILE,"TextFile.txt"),"Couldn’t open: 'TextFile.txt'.")
Debug ReadString(#TEXTFILE)
CloseFile(#TEXTFILE)
Zde jsem použil proceduru nazvanou ‘HandleError()’, která se stará o testování návratových hodnot všech příkazů, které jsou jí předány. Do prvního parametru nazvaného ‘Result’ se předává návratová hodnota příkazu. Pokud je takto proceduře předán příkaz, tento příkaz se vždy provede ještě před zavoláním procedury. Tím je zajištěno, že se případné návratové hodnoty předají správně. Druhý parametr ‘Text.s’ je řetězec, který chcete zobrazit, pokud předaný příkaz vrátí ‘0’. Pojďme si to rozebrat trochu podrobněji.
Když proceduře ‘HandleError()’ předám tento příkaz:
ReadFile(#TEXTFILE, "TextFile.txt")
Pokud soubor ‘TextFile.txt’ na vašem pevném disku neexistuje nebo se pokazí něco jiného, vrátí příkaz ‘ReadFile()’ hodnotu ‘0’. Tato hodnota ‘0’ se pak předá do prvního parametru procedury pro ošetření chyb. Uvnitř procedury se tento parametr otestuje, zda se jeho hodnota rovná ‘0’; pokud ano, zobrazí se chybová zpráva předaná ve druhém parametru pomocí okna se zprávou (message requester) a program skončí. To je šikovný způsob, jak poskytnout jasné a výstižné chybové zprávy pro každý příkaz, který vyvolá chybu.
Pokud příkaz předaný proceduře pro ošetření chyb vrátí hodnotu větší než ‘0’, považuje se za úspěšný a procedura pro ošetření chyb nic nedělá.
Procedura ukázaná ve výše uvedeném příkladu se může u tak malého příkladu zdát přehnaná, ale k takovým účelům by se hlavně nepoužívala. Procedura pro ošetření chyb se stává skutečně užitečnou ve větších programech, kde je třeba otestovat mnoho příkazů jeden po druhém. Jakmile je procedura definována, můžete s ní testovat libovolné množství příkazů a každý z nich lze na rozdíl od příkazu ‘If’ otestovat na jediném řádku. Podívejte se na tento příklad testování více příkazů:
HandleError(InitEngine3D(), "InitEngine3D() failed to initialized!")
HandleError(InitSprite(), "InitSprite() failed to initialized!")
HandleError(InitKeyboard(), "InitKeyboard() failed to initialized!")
HandleError(OpenScreen(1024, 768, 32, "Game"), "A screen could not be opened!")
Dokážete si představit, že byste všechny tyto příkazy testovali pomocí příkazů ‘If’? Byla by to noční můra vnořených ‘If’, a to ještě nejde ani o úplný program! Používání procedur pro ošetření chyb dodá vašemu kódu úhlednější, čistší a čitelnější vzhled.
Při takovéto práci zjistíte, že se chyby snáze odhalují a neočekávané problémy se jednodušeji ošetřují. Jediným problémem tohoto přístupu je, že se na začátku každého řádku objevuje ‘HandleError’, což někomu připadá rušivé.
Používejte příkaz ‘EnableExplicit’
Tento příkaz je pro někoho požehnáním a pro jiného překážkou, a proto je jeho použití zcela volitelné. Zapíná explicitní definici proměnných v celém vašem programu. Co to znamená? V kapitole 2 jsem vysvětlil, že pokud u proměnné neuvedete příponu typu, bude mít výchozí typ, kterým je obvykle Long. Pokud bylo klíčovým slovem ‘Define’ nastaven jiný výchozí typ, použijí všechny proměnné bez určeného typu ten. Příkaz ‘EnableExplicit’ toto chování vypne a od místa svého použití vyžaduje, aby všechny nové proměnné měly přesně definovaný obor platnosti a typ. Ukážu vám, jak se může tento příkaz hodit.
Řekněme například, že mám proceduru, které je potřeba předat proměnnou s nějakou zásadní hodnotou, a výsledek této procedury je pak třeba použít. Mohl bych to napsat takto:
WeeklyAmount.l = 1024
Procedure CalculateYearlyAmount(Value.l)
YearlyAmount.l = Value * 52
ProcedureReturn YearlyAmount
EndProcedure
Debug CalculateYearlyAmount(WeaklyAmount)
Vypadá to v pořádku, a pokud tento příklad jen rychle přelétnete očima, žádné problémy neuvidíte. Když ho ale spustíte, vrátí procedura ‘CalculateYearlyAmount()’ hodnotu ‘0’. To zjevně není správně, protože jsme jí měli předat proměnnou ‘WeeklyAmount’, která má hodnotu ‘1024’. Podíváte-li se pozorně na volání procedury, uvidíte, že ve skutečnosti předávám proměnnou nazvanou ‘WeaklyAmount’. Všimněte si, že tato proměnná je napsána chybně, a proto se s ní zachází jako s novou proměnnou. Když takto předáváte proměnné, které dosud nebyly definovány, PureBasic automaticky vytvoří novou proměnnou a předá ji. Proměnným, kterým při vytvoření nebyl definován typ ani hodnota, se vždy přiřadí výchozí typ a nulová hodnota. Tato nová proměnná s názvem ‘WeaklyAmount’ má tedy ve výše uvedeném příkladu hodnotu ‘0’.
Automatické definování takto zapsaných proměnných považují někteří programátoři za nedbalé a velmi náchylné k chybám. Toto výchozí chování lze vypnout a pomocí příkazu ‘EnableExplicit’ přimět kompilátor, aby byl při definici proměnných přísnější. Kdybychom tento příkaz použili ve výše uvedeném příkladu, dostali bychom několik hlášení, že některé proměnné je třeba definovat přesněji. To znamená, že všechny proměnné použité po příkazu ‘EnableExplicit’ musí být definovány pomocí některého z klíčových slov pro definici proměnných. Jsou to ‘Define’, ‘Global’, ‘Protected’, ‘Static’ a ‘Shared’, jak bylo vysvětleno v kapitolách 2 a 6.
Pokud bychom výše uvedený příklad prošli, všechny proměnné přesně definovali a program znovu spustili, kompilátor by nás upozornil na poslední řádek a zobrazil hlášení, že i proměnnou ‘WeaklyAmount’ je třeba definovat přesněji. To by bylo trochu zvláštní, protože to už by mělo být v programu uděláno dříve. Při bližším zkoumání bychom si pak všimli, že je tato proměnná napsána chybně a je třeba ji opravit. Takto by výše uvedený příklad vypadal s použitím příkazu ‘EnableExplicit’ a se všemi proměnnými definovanými explicitněji.
EnableExplicit
Define WeeklyAmount.l = 1024
Procedure CalculateYearlyAmount(Value.l)
Protected YearlyAmount.l = Value * 52
ProcedureReturn YearlyAmount
EndProcedure
Debug CalculateYearlyAmount(WeeklyAmount)
Tento příkaz by vás měl, doufejme, uchránit před mnoha dalšími překlepy v názvech proměnných, protože pokaždé, když narazí na překlep, kompilátor ho bude považovat za samostatný název proměnné a vy budete požádáni o upřesnění jejího oboru platnosti a definice. Dostanete tak příležitost proměnnou opravit, a tím obnovit hodnoty, které by se kvůli takovým chybám mohly ztratit.
Pokud se budete chtít kdykoli vrátit k výchozímu chování PureBasicu, můžete vliv příkazu ‘EnableExplicit’ vypnout příkazem ‘DisableExplicit’.
Seznámení s debuggerem PureBasicu
PureBasic nabízí plnohodnotný debugger, který pomáhá najít chyby ve vašem kódu. Tento debugger je k nezaplacení, protože vám umožňuje řídit běh programu a kdykoli během jeho chodu nahlédnout do hodnot proměnných, polí a spojových seznamů. Nabízí také pokročilé funkce pro programátory v assembleru, kteří mohou zkoumat a měnit registry procesoru nebo prohlížet hodnoty uložené na příslušných adresách v paměti. Pomocí vestavěného monitoru procesoru (CPU monitor) lze také sledovat, jak váš program vytěžuje procesor.
Pokud spustíte program a debugger narazí na chybu, program se zastaví, řádek, na kterém k chybě došlo, se v IDE označí (červeně) a chyba se zobrazí v protokolu chyb IDE (Error Log) a ve stavovém řádku IDE. Když je chyba takto zachycena, můžete použít funkce pro řízení programu, nebo běžící program ukončit. K ukončení běžícího programu slouží položka nabídky ‘Kill Program’ (Menu:Debugger->Kill Program) nebo příslušné tlačítko na panelu nástrojů. Pokud je debugger vypnutý, žádné chyby se nezachytí, což může vést k pádu programu.
Při psaní programu v IDE je debugger ve výchozím stavu zapnutý. To poznáte na první pohled podle přepínacího tlačítka debuggeru na panelu nástrojů IDE, viz obr. 23. Pokud je toto tlačítko zobrazeno jako stisknuté, je debugger zapnutý, pokud je zobrazeno jako nestisknuté, je debugger vypnutý. Toto tlačítko je také zkratkou pro položku nabídky ‘Use Debugger’ (Menu:Debugger->Use Debugger), která je rovněž přepínačem. Debugger lze zapnout i v nastavení kompilátoru pro váš program (Menu:Compiler->Compiler Options...->Compiler Options->Enable Debugger). Všechny tyto různé způsoby přepínání stavu debuggeru jsou propojené. Pokud použijete jeden z nich, ostatní jeho stav převezmou.
Balíček PureBasicu pro Windows obsahuje tři různé druhy debuggeru. Všemi lze program ladit, ale ne všechny mají stejné funkce. Prvním je vestavěný debugger, který je ze všech nejbohatší na funkce a používá se ve výchozím nastavení, protože je přímo integrovaný do IDE. IDE PureBasicu na některých operačních systémech tuto vestavěnou verzi nepodporuje, a proto je součástí instalace i samostatný debugger. Tato samostatná verze má téměř stejnou sadu funkcí jako vestavěný debugger, ale protože je oddělená od IDE, přichází se o část efektivity, kterou poskytuje přímý přístup z IDE. Třetí debugger běží pouze v konzoli. Tato verze je určena především pro negrafická prostředí, jako jsou textové operační systémy Linux, nebo pro vzdáleně vyvíjené aplikace pracující s klienty přes protokol SSH. Dostupné debuggery lze nastavit jako výchozí v předvolbách IDE (Menu:File->Preferences- >Debugger).
I když je debugger skvělým nástrojem pro hledání problémů, veškerá tato ladicí funkčnost má svou cenu. Zjistíte, že programy spuštěné se zapnutým debuggerem běží výrazně pomaleji, než když je debugger vypnutý. To by však nemělo představovat žádný problém, protože naprostá většina výsledných spustitelných souborů se kompiluje bez debuggeru, aby byly co nejrychlejší a nejkompaktnější. Je ale třeba na to pamatovat, pokud vyvíjíte programy, u nichž záleží na rychlosti, nebo potřebujete měřit dobu běhu určitých částí kódu apod.
Pokud potřebujete debugger k ladění kódu, ale v některých částech by se vám hodilo, aby byl vypnutý, můžete použít vestavěné příkazy debuggeru ‘DisableDebugger’ a ‘EnableDebugger’. Jejich použití je celkem samozřejmé: příkaz ‘DisableDebugger’ vypne debugger od daného místa v kódu a příkaz ‘EnableDebugger’ ho znovu zapne. Pokud debugger vypnete, všimnete si také, že tím vypnete i všechny příkazy ‘Debug’. Je to proto, že příkazy ‘Debug’ jsou rovněž součástí debuggeru, a pokud je debugger vypnutý, nekompilují se.
Používání debuggeru
Funkce debuggeru lze použít kdykoli během běhu programu; jsou přístupné z nabídky debuggeru i pomocí příslušných tlačítek na panelu nástrojů. Vždy jsou dostupné také protokol chyb (Menu:Debugger->Error Log) a monitor procesoru (Menu:Debugger->CPU Monitor). Během používání debuggeru se všechny soubory se zdrojovým kódem, které patří k běžícímu programu, okamžitě přepnou do režimu jen pro čtení, dokud program neskončí. Tím je zajištěno, že se právě používaný kód nijak nezmění, což představuje jednoduchou správu verzí vašeho kódu.
Abych vám poskytl přehled o debuggeru, začnu vysvětlením funkcí pro řízení programu, které nabízí. Tyto ovládací prvky vám umožňují kdykoli program zastavit a prozkoumat hodnotu libovolné proměnné, pole nebo spojového seznamu. Umožňují také procházet program po jednotlivých řádcích a přesně sledovat, jak se program provádí. Stav programu během používání debuggeru se zobrazuje ve stavovém řádku IDE a v protokolu chyb. Tlačítka debuggeru pro řízení programu na panelu nástrojů jsou zobrazena na obr. 23; odpovídají jim také příkazy v nabídce ‘Debugger’.

Obr. 23: Tlačítka debuggeru na panelu nástrojů
Chcete-li program kdykoli zastavit a použít ovládací prvky debuggeru, můžete buď v kódu použít klíčové slovo ‘CallDebugger’, zvolit ‘Stop’ v nabídce debuggeru (Menu:Debugger->Stop), nebo za běhu programu stisknout tlačítko ‘Stop’ na panelu nástrojů. K zastavení běhu programu můžete použít také body přerušení (breakpoints). Chcete-li v IDE použít bod přerušení, umístěte kurzor na řádek, na kterém se má program zastavit, a přepněte řízení na debugger. Pak bod přerušení přidejte příkazem nabídky ‘Breakpoint’ (Menu:Debugger->Breakpoint). Všimnete si, že se v pruhu s čísly řádků v IDE objeví malé kolečko. To je vizuální označení míst, kde jsou definovány body přerušení. Při příštím spuštění se program zastaví na řádku, kde je bod přerušení definován, a poté budou k dispozici funkce debuggeru pro řízení programu. Pak můžete zkoumat libovolné hodnoty dat nebo procházet program krok za krokem a analyzovat kód podrobněji. Zde je krátký popis funkcí pro řízení programu:
‘Stop’ Zastaví program a zobrazí aktuální řádek.
‘Continue’ Pokračuje v provádění programu, dokud nenarazí na další příkaz k zastavení.
‘Step’ Provede jeden řádek zdrojového kódu a pak provádění znovu zastaví.
‘Kill Program’ Vynutí ukončení programu a zavře všechna související okna debuggeru.
Zde je krátký příklad zastavení běhu programu pomocí příkazu ‘CallDebugger’:
CallDebugger
For x.l = 1 To 10
Debug x
Next x
End
Jakmile je výše uvedený program zastaven příkazem ‘CallDebugger’, můžete jím procházet po jednotlivých řádcích pomocí tlačítka ‘Step’ na panelu nástrojů. Klikněte na něj desetkrát a uvidíte, jak se hodnota ‘x’ vypisuje do okna Debug Output (výstup ladění) a při každém stisknutí tlačítka se zvýší o jedna. Když je program takto zastaven, můžete si prohlédnout hodnotu libovolné proměnné, pole nebo spojového seznamu otevřením okna Variable Viewer (prohlížeč proměnných, Menu:Debugger->Variable Viewer). Tento krátký přehled by vám měl stačit k osvojení základů práce s debuggerem. Podrobnější informace o tom, co všechno dokáže, najdete v nápovědě PureBasicu.
Knihovna ‘OnError’
Vestavěná knihovna ‘OnError’ vám umožňuje provádět kontrolu chyb ve výsledném spustitelném souboru, kdy debugger není k dispozici. Během vývoje byste normálně k zachytávání chyb používali debugger, ale když výsledný spustitelný soubor kompilujete pro distribuci, debugger vypnete, abyste získali co nejmenší a nejrychlejší spustitelný soubor. Vypnutím debuggeru získáte přibližně šestinásobnou rychlost oproti běhu se zapnutým debuggerem. Pomocí knihovny ‘OnError’ lze do výsledného spustitelného souboru snadno začlenit pokročilou kontrolu a ošetřování chyb a přitom mít stále k dispozici plnou rychlost PureBasicu.
Tato knihovna nabízí mnoho velmi pokročilých příkazů, ty však přesahují rozsah této knihy, a proto se zaměřím jen na ty běžněji používané a snadno pochopitelné. Nejprve vám ukážu, jak efektivně zachytit a popsat chybu bez použití debuggeru. Podívejte se na následující příklad:
;Set the error handler
OnErrorGoto(?ErrorHandler)
;Trigger a classic 'divide by zero' error.
Null.l = 0
TestVariable.l = 100 / Null
;Handle any system error that occurs
ErrorHandler:
Text.s = "Error count:" + #TAB$ + #TAB$ + Str(GetErrorCounter()) + #CRLF$
Text.s + "Error ID number:" + #TAB$ + #TAB$ + Str(GetErrorNumber()) + #CRLF$
Text.s + "Error description:" + #TAB$ + #TAB$ + GetErrorDescription() + #CRLF$
Text.s + "Error occurred on line:" + #TAB$ + Str(GetErrorLineNR()) + #CRLF$
Text.s + "Error occurred in module:" + #TAB$ + GetErrorModuleName() + #CRLF$
MessageRequester("ERROR", Text)
End
Zde pomocí příkazu ‘OnErrorGoto()’ určuji, kam se má skočit, pokud dojde k chybě. Parametrem tohoto příkazu je návěští, na které se má skočit. Podíváte-li se pozorně na návěští, které jsem předal jako parametr, všimnete si, že jsem na začátek jeho názvu přidal otazník. Je to proto, že příkaz ‘OnErrorGoto()’ ve skutečnosti potřebuje předat ukazatel na návěští, a ne jen samotné návěští. Takto použitý otazník vrací adresu návěští v paměti. Ukazatel je proměnná, která obsahuje adresu v paměti, kde je něco uloženo; podrobnější vysvětlení najdete v kapitole 13 (Ukazatele). Stejně jako u příkazů ‘Goto’ a ‘Gosub’ i zde vynecháváme dvojtečku na konci návěští, když jeho název tomuto příkazu předáváme.
Poté, co je návěští určeno příkazem ‘OnErrorGoto()’, nám další příkazy knihovny ‘OnError’ pomohou pochopit, co se pokazilo a kde. Ve výše uvedeném příkladu jsem použil tyto příkazy:
‘GetErrorCounter()’ Tento příkaz vrací počet chyb, ke kterým ve vašem programu od jeho spuštění došlo.
‘GetErrorNumber()’ Tento příkaz vrací jedinečné číslo poslední chyby, ke které došlo.
‘GetErrorDescription()’ Tento příkaz vrací řetězec s úplným popisem chyby, ke které došlo.
‘GetErrorLineNR()’ Tento příkaz vrací číslo řádku ve zdrojovém kódu, na kterém k chybě došlo, ať už v hlavním zdrojovém souboru, nebo v některém z vkládaných souborů. Aby tento příkaz fungoval správně, musíte před kompilací programu zapnout volbu kompilátoru ‘Enable OnError Lines Support’.
‘GetErrorModuleName()’ Tento příkaz vrací řetězec, který vám sdělí, ve kterém souboru se zdrojovým kódem k chybě došlo. To je velmi užitečné, pokud používáte mnoho vkládaných souborů se zdrojovým kódem. Aby tento příkaz fungoval správně, musíte před kompilací programu zapnout volbu kompilátoru ‘Enable OnError Lines Support’.
Poslední dva zde uvedené příkazy vyžadují, abyste před kompilací programu zapnuli volbu kompilátoru ‘Enable OnError Lines Support’. Ta se nachází v nastavení kompilátoru v IDE (Menu:Compiler->Compiler Options...->Compiler Options->Enable OnError Lines Support).
Abych skutečně předvedl, jak příkazy ‘OnError’ zachytí a ošetří chybu, vytvořil jsem v kódu reprodukovatelnou chybu. Jde o jednoduchou chybu „dělení nulou“ a je zapsána takto:
;Trigger a classic 'divide by zero' error.
Null.l = 0
TestVariable.l = 100 / Null
Pokud je debugger zapnutý, snadno by tuto chybu zachytil, ale kdybychom ho vypnuli, chyba by zůstala nepovšimnuta. K zachycení této chyby bez potřeby debuggeru můžeme použít knihovnu ‘OnError’. Chcete-li příklad spustit a vidět, jak správně funguje, musíte nejprve vypnout debugger a zapnout volbu kompilátoru ‘Enable OnError Lines Support’. Když nyní program zkompilujete, měl by zachytit chybu „dělení nulou“ a poskytnout vám podrobné informace, a to vše bez pomoci debuggeru. Obr. 24 ukazuje tento příklad v akci a zobrazuje informace shromážděné ostatními příkazy ‘OnError’.

Obr. 24
V posledním příkladu jsem pomocí příkazu ‘OnErrorGoto()’ určil návěští, na které se má skočit, pokud dojde k chybě. Tento příkaz vám však neumožňuje se z tohoto návěští vrátit a pokračovat v programu, a to ani pokud použijete klíčové slovo ‘Return’. Právě tady se hodí příkaz ‘OnErrorGosub()’. Pomocí tohoto příkazu můžete jako obsluhu chyb určit návěští nebo proceduru a tento příkaz vám umožňuje se z nich příslušným klíčovým slovem vrátit. Zde je příklad s použitím procedury:
;Handle any system error that occurs
Procedure ErrorHandler()
Text.s = "Error count:" + #TAB$ + Str(GetErrorCounter()) + #CRLF$
Text.s + "Error ID number:" + #TAB$ + Str(GetErrorNumber()) + #CRLF$
Text.s + "Error description:" + #TAB$ + GetErrorDescription() + #CRLF$
Text.s + "Occurred on line:" + #TAB$ + Str(GetErrorLineNR()) + #CRLF$
Text.s + "Occurred in module:" + #TAB$ + GetErrorModuleName() + #CRLF$+#CRLF$
Text.s + "Would you like to continue execution of the program?"
ReturnValue.l = MessageRequester("ERROR", Text, #PB_MessageRequester_YesNo)
If ReturnValue = #PB_MessageRequester_No
End
EndIf
EndProcedure
;Set the error handler
OnErrorGosub(@ErrorHandler())
;Trigger a classic 'divide by zero' error.
Null.l = 0
TestVariable.l = 100 / Null
;If the program reaches here then the program was resumed
MessageRequester("STATUS", "The program was allowed to continue running.")
End
Zde ukazuji, jak po chybě obnovit provádění programu, což příkazem ‘OnErrorGoto()’ udělat nelze. Tento přístup má však jeden problém: pokud se rozhodnete v provádění programu pokračovat, chyba, ke které došlo, může program učinit nestabilním a způsobit jeho pád. Proto pokud svému programu dáte možnost pokračovat po chybě, měli byste v závislosti na její závažnosti uživatele informovat o tom, co se stalo, a vyzvat ho k restartování programu. Obnovení provádění programu by se mělo ideálně používat tehdy, pokud se domníváte, že by uživatel mohl po pádu programu přijít o svou práci. Pokračování mu dává příležitost uložit to, co v programu dělal (pokud program tuto funkci má), než ho restartuje.
Řekněme například, že jste napsali textový editor a Bob v něm píše dopis. Pokud po hodině psaní dojde k nevysvětlitelné chybě a program zobrazí chybovou zprávu, Bob rozhodně nechce, aby přišla vniveč celá ta hodina a kvůli chybě přišel o svůj dopis. V takovém případě lze Boba informovat o tom, co se stalo, a dát mu na výběr, zda chce pokračovat v provádění programu, aby mohl dopis před restartováním programu uložit do souboru. V chybové zprávě by se dokonce mohla zobrazit e-mailová adresa, na kterou by se Bob mohl obrátit a vysvětlit, co se pokazilo, aby to autor programu mohl opravit.
Vyvolávání a zachytávání vlastních chyb
Dosud jsem vám ukázal způsob, jak zachytit a zdokumentovat systémové chyby, ke kterým může ve vašem programu dojít, a tímto způsobem zachytíte téměř každou závažnou systémovou chybu, na kterou můžete narazit. Někdy však můžete chtít kvůli přizpůsobení vyvolat vlastní chybu. V takovém případě můžete k vytvoření a vyvolání vlastní chyby použít příkaz ‘SetErrorNumber()’.
Příkaz ‘SetErrorNumber()’ potřebuje ke správné funkci jeden parametr, kterým je číslo typu Long identifikující danou chybu. K definici vlastních čísel chyb obvykle používám konstanty, abych se na ně pak mohl odkazovat jménem, například takto:
#ERROR_READFILE = 1
#ERROR_WRITEFILE = 2
#FILE_TEXT = 1
;Set the error handler
OnErrorGoto(?ErrorHandler)
If ReadFile(#FILE_TEXT, "Report.txt") = #False
;If the file read fails then fire an error
SetErrorNumber(#ERROR_READFILE)
EndIf
End
;Handle any custom error that occurs
ErrorHandler:
Text.s = "Error count:" + #TAB$ + #TAB$ + Str(GetErrorCounter()) + #CRLF$
Text.s + "Error ID number:" + #TAB$ + #TAB$ + Str(GetErrorNumber()) + #CRLF$
Select GetErrorNumber()
Case #ERROR_READFILE
Description.s = "The file could not be read."
Case #ERROR_WRITEFILE
Description.s = "The file could not be written."
EndSelect
Text.s + "Error description:" + #TAB$ + #TAB$ + Description + #CRLF$
Text.s + "Error occurred on line:" + #TAB$ + Str(GetErrorLineNR()) + #CRLF$
Text.s + "Error occurred in module:" + #TAB$ + GetErrorModuleName() + #CRLF$
MessageRequester("ERROR", Text)
End
Pokud ve výše uvedeném příkladu nelze soubor ‘Report.txt’ přečíst pomocí příkazu ‘ReadFile()’, vyvolám vlastní chybu příkazem ‘SetErrorNumber()’. Tato chyba je identifikována konstantou ‘#ERROR_READFILE’, která má hodnotu ‘1’. Jakmile je chyba takto vyvolána, zavolá se návěští nebo procedura obsluhy chyb. V obsluze chyb můžete pomocí příkazu ‘GetErrorNumber()’ zjistit, jaké číslo chyby bylo vyvoláno. Podle výsledku tohoto příkazu pak můžete popis chyby přizpůsobit, jak se vám zlíbí. Zde testuji příkaz ‘GetErrorNumber()’ příkazem ‘Select’ a v závislosti na jeho hodnotě používám různé řetězce s popisem. Tento popis pak zobrazí vyskakovací chybová zpráva.
Jak je z těchto příkladů vidět, knihovna ‘OnError’ vám nabízí pokročilou kontrolu chyb, a přitom s velmi jednoduchou syntaxí.
IIGrafická uživatelská rozhraní
V této části se budu věnovat grafickým uživatelským rozhraním a tomu, jak se v PureBasicu vytvářejí. Téměř všechny moderní operační systémy mají vestavěné grafické uživatelské rozhraní, které uživateli umožňuje plynule pracovat s programy, jež ho využívají. Operační systém zpřístupňuje uživatelské rozhraní programům prostřednictvím rozhraní pro programování aplikací (Application Programming Interface, API), přes které program operačnímu systému sděluje, jak má vykreslit jeho uživatelské rozhraní. Zní to nesmírně složitě, ale v PureBasicu se to řeší jednoduše a elegantně pomocí knihoven ‘Window’, ‘Menu’ a ‘Gadget’.
PureBasic vytváří tato grafická rozhraní vašich programů pomocí nativního rozhraní pro programování aplikací toho systému, pro který byly zkompilovány. Jinými slovy: když naprogramujete rozhraní programu a zkompilujete ho v určitém systému, bude mít program správný vzhled a chování odpovídající operačnímu systému, pro který byl zkompilován. To je pro veškerý profesionální vývoj aplikací naprosto zásadní.
Tato část začíná vysvětlením a ukázkami programů, které jako uživatelské rozhraní používají konzoli, což je pravděpodobně nejjednodušší uživatelské rozhraní ze všech. Dále vysvětlím, jak vytvářet programy s nativním uživatelským rozhraním a jak do nich přidávat nabídky a grafiku. V posledním oddílu vám představím Visual Form Designer (vizuální návrhář formulářů) PureBasicu. S pomocí tohoto nástroje můžete navrhovat rozhraní vizuálně, jako byste ho malovali přímo na program.
Po přečtení této části byste měli dobře rozumět tomu, jak vytvářet grafická uživatelská rozhraní pro své programy a jak obsluhovat interakci s uživatelem.
9Tvorba uživatelských rozhraní
V této kapitole vysvětlím, jak pro své programy vytvářet grafická uživatelská rozhraní. PureBasic tento úkol velmi usnadňuje tím, že složitá rozhraní pro programování aplikací převádí na jednoduché a snadno naučitelné příkazy. Podrobně vysvětlím, jak naprogramovat grafické rozhraní včetně nabídek a někdy i grafiky. Probereme také, jak zpracovávat události z rozhraní vašeho programu, například když uživatel stiskne tlačítko nebo vybere položku nabídky. Doufám, že po přečtení této kapitoly budete dobře vybaveni k tomu, abyste vytvořili uživatelské rozhraní pro jakýkoli program, který se rozhodnete vyvíjet.
Konzolové programy
Nejdříve se musíme naučit chodit, než začneme běhat, a proto vám nejprve představím takzvaný konzolový program. Konzolové programy jsou, jak už název napovídá, programy, které jako své uživatelské rozhraní používají konzoli. Konzole je textové rozhraní, které dokáže přijímat zapsaný vstup a zobrazovat výstup pomocí textových znaků. V některých operačních systémech umí konzole zobrazovat i jednoduchou grafiku tak, že část znakové sady ASCII nahradí místo znaků grafickými symboly.
Konzolová rozhraní se obvykle používají v programech, kde není potřeba plnohodnotné uživatelské rozhraní. Takovými programy bývají obvykle nástroje příkazové řádky spouštěné z jiných konzolí nebo třeba programy CGI, které běží na pozadí webových serverů, a podobně. Konzole v zásadě slouží k zobrazování základních výstupních informací programu a k přijímání základního textového vstupu od uživatele. Příkazy, které vytvářejí konzolové rozhraní a pracují s ním, jsou soustředěny v knihovně ‘Console’ (Helpfile:Reference Manual->General Libraries->Console). Tato knihovna nabízí programátorům v PureBasicu různé příkazy pro výpis textu, přijímání vstupu od uživatele, mazání konzole, a dokonce i pro změnu jejích barev. Zde je příklad, jak v PureBasicu vytvořit konzolový program:
If OpenConsole()
Print("This is a test console program, press return to exit...")
Input()
CloseConsole()
EndIf
End
V tomto příkladu jsem použil příkazy ‘OpenConsole()’ a ‘CloseConsole()’ k otevření a zavření samotného okna konzole; ty jsou zřejmé samy o sobě. Druhým použitým příkazem je ‘Print()’, který přijímá jeden řetězcový parametr, jenž se vypíše do konzolového rozhraní. Tento příkaz je téměř totožný s jiným příkazem konzolové knihovny, ‘PrintN()’. ‘PrintN()’ také vypíše řádek textu, ale na jeho konec připojí znak konce řádku, takže se po vypsání textu přejde na nový řádek. Je to velmi podobné chování jako u příkazů pro zápis do souboru ‘WriteString()’ a ‘WriteStringN()’, o nichž byla řeč v kapitole 7 (Práce se soubory).
Posledním příkazem použitým ve výše uvedeném příkladu je ‘Input()’. Tento příkaz pozastaví běh programu, dokud se na klávesnici nestiskne klávesa Return. Poté vrátí všechny znaky (jako řetězec), které byly do konzole zadány před konečným stisknutím klávesy Return. Protože se v mém příkladu návratovou hodnotou tohoto příkazu nijak nezabývám, slouží zde čistě k tomu, aby konzole zůstala otevřená a lidé si mohli přečíst text, který jsem do ní vypsal. Kdyby tento příkaz chyběl, konzole by se zavřela téměř okamžitě poté, co se otevřela. Takové použití ‘Input()’ může být jednoduchým způsobem, jak udržet konzoli otevřenou, zatímco čteme, co je v ní vypsáno, pokud ovšem uživatele upozorníme, že pro pokračování programu musí stisknout Return.
Čtení vstupu od uživatele
Někdy budete ve svých konzolových programech chtít číst vstup od uživatele, ať už jde o jednoduché číslo, nebo o textový řetězec. Přestože získat vstup od uživatele je celkem jednoduché, musíte mít vždy na paměti, že příkaz ‘Input()’ vrací pouze řetězce. Ukazuje to následující kus kódu, který zároveň představuje některé nové konzolové příkazy:
If OpenConsole()
EnableGraphicalConsole(#True)
Repeat
ConsoleColor(10, 0)
PrintN("TIMES TABLES GENERATOR")
PrintN("")
ConsoleColor(7, 0)
PrintN("Please enter a number, then press Return...")
PrintN("")
Number.q = ValQ(Input())
If Number = 0
ClearConsole()
Continue
Else
Break
EndIf
ForEver
PrintN("")
For x.l = 1 To 10
PrintN(Str(x) + " x " + StrQ(Number) + " = " + StrQ(x * Number))
Next x
PrintN("")
Print("Press Return to exit...")
Input()
CloseConsole()
EndIf
End
Tento příklad vypadá dost složitě, ale ve skutečnosti takový není, pokud ho budete číst řádek po řádku. Prvním novým příkazem, který jsem zde použil, je ‘EnableGraphicalConsole()’. Ten zapíná nebo vypíná grafické schopnosti konzolového programu podle toho, zda mu jako parametr předáte konstantu ‘#True’, nebo ‘#False’. Protože později používáme příkaz ‘ClearConsole()’, který funguje pouze s grafickou konzolí, nastavíme ‘EnableGraphicalConsole()’ na pravdu (true).
Na některých místech jsem také změnil barvu textu konzole pomocí příkazu ‘ConsoleColor()’. Prvním parametrem je barva textu a druhým barva pozadí textu. Parametry jsou čísla v rozsahu od ‘0’ do ‘15’, která představují různé přednastavené barvy; jaká barva odpovídá kterému číslu, zjistíte v nápovědě (Helpfile:Reference Manual->General Libraries->Console- >ConsoleColor).
V tomto příkladu jsem rovněž použil cyklus pro ověřování vstupu od uživatele; slouží jako způsob, jak program v podstatě spustit znovu, pokud uživatel zadal nesprávnou hodnotu. Chci, aby bylo zadáno číslo, a proto příkazem ‘ValQ()’ převádím řetězec vrácený příkazem ‘Input()’ na typ Quad. Tato vrácená hodnota se pak otestuje: pokud je rovna ‘0’, uživatel musel zadat nečíselný řetězec nebo číslo ‘0’. V takovém případě vymažu z konzole veškerý výstup příkazem ‘ClearConsole()’ a přinutím cyklus pokračovat znovu od začátku, takže se celý původní text vykreslí znovu a znovu se vyžádá vstup od uživatele. Pokud je vstupem uživatele číslo větší než ‘0’, vyskočím z cyklu příkazem ‘Break’ a pokračuji ve zbytku programu, který pro toto číslo vypíše násobilku.
Čtení vstupu od uživatele v reálném čase
Předchozí příklad předvedl příkaz ‘Input()’, který vyhovuje, pokud potřebujete zadat řetězec nebo něco podobného, ale jeho jediným omezením je, že musíte stisknout klávesu Return, aby se vstup předal programu. Co kdybyste chtěli získávat vstup od uživatele v reálném čase a okamžitě zjistit, že byla stisknuta klávesa, aby se spustila nějaká akce? Toho lze dosáhnout pomocí příkazů ‘Inkey()’ a ‘RawKey()’. Podívejte se na následující kus kódu, který ukazuje použití obou:
Procedure DisplayTitle()
ConsoleColor(10, 0)
PrintN("KEY CODE FINDER")
PrintN("")
ConsoleColor(7, 0)
EndProcedure
Procedure DisplayEscapeText()
PrintN("")
ConsoleColor(8, 0)
PrintN("Press another key or press Escape to exit")
ConsoleColor(7, 0)
EndProcedure
If OpenConsole()
EnableGraphicalConsole(#True)
DisplayTitle()
PrintN("Press a key...")
Repeat
KeyPressed.s = Inkey()
RawKeyCode.l = RawKey()
If KeyPressed <> ""
ClearConsole()
DisplayTitle()
PrintN("Key Pressed: " + KeyPressed)
PrintN("Key Code: " + Str(RawKeyCode))
DisplayEscapeText()
ElseIf RawKeyCode
ClearConsole()
DisplayTitle()
PrintN("Key Pressed: " + "Non-ASCII")
PrintN("Key Code: " + Str(RawKeyCode))
DisplayEscapeText()
Else
Delay(1)
EndIf
Until KeyPressed = #ESC$
CloseConsole()
EndIf
End
Tento příklad se podobá předchozímu v tom, že otevíráme konzoli, přepínáme ji do grafického režimu a pak do ní vypisujeme nějaký text. Hlavní rozdíl spočívá v tom, že cyklus ‘Repeat’ neustále volá dva příkazy, aby zjistil, která klávesa (pokud vůbec nějaká) byla stisknuta. Těmito dvěma příkazy jsou ‘Inkey()’ a ‘RawKey()’.
První příkaz, ‘Inkey()’, vrací jednoznakový řetězec s klávesou, která byla držena v okamžiku volání tohoto příkazu. Pokud bych tedy při volání tohoto příkazu držel na klávesnici klávesu ‘D’, vrátil by ‘Inkey()’ řetězec ‘d’. Přestože je tento příkaz snadno pochopitelný, musíte mít na paměti, že klávesy na běžné klávesnici bývají popsány velkými písmeny, kdežto příkaz ‘Inkey()’ je vrací jako malá písmena, pokud současně nedržíte klávesu Shift. Je-li při volání tohoto příkazu držena klávesa, která neodpovídá znaku ASCII, vrací ‘Inkey()’ prázdný řetězec, dokud není držena klávesa se znakem ASCII.
Druhý příkaz pro zjišťování, která klávesa byla stisknuta, je doplňkem příkazu ‘Inkey()’ a jmenuje se ‘RawKey()’. Tento příkaz, jak už název napovídá, vrací číselný surový kód (raw key code) klávesy, která je při jeho volání držena. Ve výše uvedeném příkladu vidíte, jak oba příkazy použít k získání informací o tom, která klávesa je během cyklu držena. Je to skvělý způsob, jak číst vstup od uživatele v reálném čase a odpovídajícím způsobem reagovat, když je stisknuta určitá klávesa.
Trocha zdržení
Možná jste si všimli, že ve výše uvedeném příkladu jsem použil také příkaz ‘Delay()’, kterým programu říkám, aby se na ‘1’ milisekundu pozdržel. Ačkoli to vypadá trochu zvláštně a zbytečně, příkaz ‘Delay()’ tam má svůj důvod. Protože své programy budete spouštět ve víceúlohovém operačním systému, je dobrou programátorskou praxí nemonopolizovat čas procesoru, pokud se tomu dá vyhnout. Příkaz ‘Delay()’ dává ostatním programům příležitost využít procesor, zatímco je váš program pozdržen. I zdržení o ‘1’ milisekundu umožní operačnímu systému uvolnit procesor na dost dlouho, aby se ke slovu dostaly i jiné programy. Tento příkaz je užitečný zejména v cyklech, které stále dokola provádějí tutéž akci. Pokud se v takovém cyklu příkaz ‘Delay()’ nepoužije, zabere váš program až do svého ukončení veškeré prostředky procesoru a pro běh ostatních programů nezbude žádný výpočetní výkon. To může někdy způsobit, že se tyto ostatní programy budou jevit jako „zamrzlé“ a nebudou reagovat obvyklým způsobem.
Kompilace skutečného konzolového programu
Spouštěním příkladů konzolových programů v IDE vzniknou programy, které vypadají a chovají se jako skutečné konzolové programy, avšak konzolovými programy v pravém smyslu slova budou až tehdy, když je zkompilujete ve formátu spustitelného souboru ‘Console’.

Obr. 25 — Dialogové okno ‘Compiler Options’ (možnosti kompilátoru) tak, jak vypadá v systému Microsoft Windows.
Obr. 25 ukazuje, kde se v dialogovém okně ‘Compiler Options’ (Menu:Compiler->Compiler Options...) nachází volba formátu spustitelného souboru. Jakmile ji vyberete, klepněte na ‘Ok’ a zkompilujte program pomocí ‘Create Executable...’ (vytvořit spustitelný soubor; Menu:Compiler->Create Executable...), čímž vytvoříte výsledný spustitelný soubor. Kompilátor PureBasicu nyní sestaví skutečný konzolový program.
Hlavní rozdíl mezi těmito formáty spustitelných souborů spočívá v tom, že IDE ve výchozím nastavení kompiluje všechny programy v nativním formátu spustitelných souborů operačního systému. Takové programy při spuštění, ať už poklepáním, nebo vyvoláním z rozhraní příkazové řádky, vždy nejprve otevřou nové okno konzole. Pomocí formátu spustitelného souboru ‘Console’ můžete výslovně určit, že se má program zkompilovat jako skutečný konzolový program. To znamená, že po poklepání poběží program normálně, ale při spuštění z rozhraní příkazové řádky neotevře nové okno konzole a chová se správně jako nástroj v rámci právě otevřeného rozhraní příkazové řádky.
A to je vlastně vše, co se týká programování rozhraní konzolových programů. Nejsou určena pro složitá rozhraní (i když v minulosti se v grafickém režimu konzole psaly i hry). Dnes se tato rozhraní používají hlavně k zobrazování jednoduchého výstupu nástrojů příkazové řádky.
Tvorba nativních uživatelských rozhraní
V této části vám ukážu, jak vytvářet uživatelská rozhraní, která mají stejný nativní vzhled a chování jako všechny programy běžící ve vašem operačním systému. Říká se jim „nativní“ rozhraní, protože PureBasic ke kreslení součástí rozhraní používá API příslušného operačního systému. Jako příklad takového rozhraní si prohlédněte IDE PureBasicu, které bylo celé od základu napsáno v PureBasicu, jenž zase využívá API operačního systému.
Všechny ty řeči o API operačního systému vás možná odrazují a máte pocit, že to celé zní velmi složitě, ale nepanikařte. Dobrou zprávou je, že nemusíte vědět nic o tom, „co se děje pod kapotou“, protože PureBasic to vše řeší automaticky a veškeré složitosti před vámi skrývá. Jen s pomocí vestavěných knihoven PureBasicu můžete vytvářet výkonné aplikace, které se vyrovnají aplikacím v jakémkoli jiném programovacím jazyce. Programy v PureBasicu jsou v průměru rychlejší a kompilují se do menších spustitelných souborů než v mnoha průmyslově nasazovaných jazycích. To se mnohokrát prokázalo v malých soutěžích, které pořádali členové oficiálních online fór PureBasicu.
Pusťme se tedy do toho a vytvořme v PureBasicu své první nativní uživatelské rozhraní.
Hello World
Jak je ve světě programování zvykem, prvním příkladem příkazů pro tvorbu rozhraní v jakémkoli programovacím jazyce bývá program ‘Hello World’. Ten se skládá z jednoduchého okna, které uživatele pozdraví a nabídne mu způsob, jak program zavřít. V IDE založte nový soubor a napište do něj toto:
#WINDOW_MAIN = 1
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN, 0, 0, 300, 200, "Hello World", #FLAGS)
Repeat
Event.l = WaitWindowEvent()
Until Event = #PB_Event_CloseWindow
EndIf
End
Spustíte-li tento kus kódu, uvidíte okno podobné tomu na obr. 26 na další straně. Okno zavřete klepnutím na zavírací tlačítko v pravém horním rohu. Přestože se tento příklad skládá jen z prázdného okna a zavíracího tlačítka v záhlaví, představuje začátek všech nativních uživatelských rozhraní v PureBasicu.
Ve výše uvedeném příkladu používám příkaz ‘OpenWindow()’ k samotnému otevření okna a k určení, jaké vlastnosti má mít. Pokud otevřete nápovědu, vyhledáte příkaz ‘OpenWindow()’ (Helpfile:Reference Manual->General Libraries->Window->OpenWindow) a podíváte se na příklad syntaxe, uvidíte, že jsem použil příznaky okna ‘#PB_Window_SystemMenu’ a ‘#PB_Window_ScreenCentered’,

Obr. 26 — (příklad z Microsoft Windows)
abych určil, že okno má mít funkční systémovou nabídku včetně zavíracího tlačítka a že má být po otevření vystředěno na obrazovce. Používáte-li takto více příznaků, spojujete je bitovým operátorem ‘OR’, jak je vidět ve výše uvedeném kódu. Tento operátor kombinuje hodnoty všech použitých příznaků na binární úrovni (podrobnější vysvětlení najdete v kapitole 3).
Po příkazu ‘OpenWindow()’ jsem použil cyklus ‘Repeat’, který slouží jako hlavní smyčka zpracovávající všechny události, s nimiž se toto okno může setkat.
Hlavní smyčka
Hlavní smyčka programu je to, co program udržuje „naživu“. Umožňuje programu nepřetržitě běžet, překreslovat rozhraní (pokud jím pohybujete po pracovní ploše) a zpracovávat všechny události, které rozhraní může vyvolat. PureBasic naštěstí veškeré překreslování rozhraní obstarává automaticky, takže hlavní smyčku potřebujeme jen k tomu, aby program běžel a zpracovával ostatní události.
Ve svém malém programu ‘Hello World’ jsem jako hlavní smyčku použil cyklus ‘Repeat’. Ten mi umožňuje nechat smyčku běžet donekonečna, dokud není splněna určitá podmínka – v tomto případě dokud nenarazím na událost typu ‘#PB_Event_CloseWindow’, což je událost vyvolaná klepnutím na zavírací tlačítko. Jakmile tuto událost obdržím, smyčka skončí, a tím skončí i program.
Pochopení událostí
Každý program, který napíšete v jakémkoli programovacím jazyce, bude zpracovávat události zhruba stejným způsobem. Spočívá to v tom, že se během hlavní smyčky zjistí událost a program se pak podle toho, o jakou událost šlo, nasměruje ke spuštění jiného kusu kódu. Jaké druhy událostí tedy existují? Událost může být ve vašich programech vyvolána mnoha akcemi: klepnutím na gadget, stisknutím klávesy na klávesnici, výběrem položky z nabídky nebo prostě přesunutím či zavřením programu. Celý trik spočívá v tom, vědět, která událost nastala, abyste ji mohli správně zpracovat. K tomu používáme příkazy ‘WaitWindowEvent()’ a ‘WindowEvent()’.
Tyto dva příkazy jsou téměř totožné, protože oba při výskytu události vracejí identifikátor události v podobě čísla typu Long. Rozdíl mezi nimi je v tom, že příkaz ‘WaitWindowEvent()’ pozastaví váš program, dokud není zjištěna nějaká událost, pak vrátí identifikátor události a nechá program normálně pokračovat až do svého dalšího volání. (To se skvěle hodí pro grafická uživatelská rozhraní, protože program tak využívá procesor co nejméně – jen tehdy, když skutečně nastane nějaká událost.) Příkaz ‘WindowEvent()’ naproti tomu program vůbec nepozastavuje, pouze zjistí, zda existují nějaké události k vrácení. Pokud ano, vrátí identifikátor události. Tento příkaz se v uživatelských rozhraních používá velmi zřídka, protože je může učinit velmi „hladovými“ po čase procesoru, takže zaberou výpočetní výkon počítače, na kterém běží. Příkaz ‘WindowEvent()’ se často používá tehdy, když potřebujete udržet hlavní smyčku za každou cenu v chodu, například pokud ve svém programu zobrazujete dynamickou grafiku, kterou je třeba neustále překreslovat, a podobně. Pokud je tomu tak a příkaz ‘WindowEvent()’ použít musíte, dobrý programátorský styl velí, abyste s ním zkusili použít trik s ‘Delay(1)’ (jak bylo vysvětleno v části o konzolových programech), a zajistili tak, že váš program bude k procesoru šetrný. Pokud nejsou zjištěny žádné události, použijte ‘Delay(1)’, aby měly šanci využít procesor i ostatní programy.
V programu ‘Hello World’ jsem uvnitř cyklu ‘Repeat’ použil příkaz ‘WaitWindowEvent()’, který program pozastaví, dokud není vyvolána nějaká událost. Jakmile k ní dojde, vrátí ‘WaitWindowEvent()’ její identifikátor, který se uloží do proměnné typu Long nazvané ‘Event’. Cyklus je pak naprogramován tak, aby skončil, pokud se ‘Event’ rovná hodnotě ‘#PB_Event_CloseWindow’, což je vestavěná konstanta obsahující identifikátor události „zavření okna“ z rozhraní. Jsou-li si tyto dvě hodnoty rovny, musela nastat událost „zavření okna“, takže cyklus skončí a program se ukončí.
Události nastávají neustále
Přestože se v tomto malém příkladu žádné jiné události nezpracovávají, neznamená to, že nenastávají. Vezmeme-li stejný program ‘Hello World’ a přidáme do něj další řádek s příkazem ‘Debug’, bude za běhu zobrazovat identifikátory událostí v okně Debug Output (výstup ladění).
Spusťte následující kus kódu a pak oknem pohybujte a klepejte do něj i kolem něj. Uvidíte, že nastává spousta událostí.
#WINDOW_MAIN = 1
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN, 0, 0, 300, 200, "Hello World", #FLAGS)
Repeat
Event.l = WaitWindowEvent()
Debug Event
Until Event = #PB_Event_CloseWindow
EndIf
End
To příkaz ‘WaitWindowEvent()’ vrací identifikátory všech vyvolaných událostí, i když je váš program nezpracovává. Je to zcela normální a váš program to ani v nejmenším znatelně nezpomalí.
Přidávání gadgetů
Dosud jsme viděli vytvoření jednoduchého okna, které v záhlaví zobrazovalo ‘Hello World’. Přestože je to pěkný úvod do uživatelských rozhraní, kromě možnosti zavřít okno vlastně neukazuje žádnou formu interakce s uživatelem. V této části vám ukážu, jak do okna programu přidávat gadgety, a zvýšit tak jeho funkčnost a interaktivitu.
V následujícím kusu kódu jsem přidal dvě tlačítka a předvedl, jak zjišťovat události, které vyvolávají.
Enumeration
#WIN_MAIN
#BUTTON_INTERACT
#BUTTON_CLOSE
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WIN_MAIN, 0, 0, 300, 200, "Interaction", #FLAGS)
If CreateGadgetList(WindowID(#WIN_MAIN))
ButtonGadget(#BUTTON_INTERACT, 10, 170, 100, 20, "Click me")
ButtonGadget(#BUTTON_CLOSE, 190, 170, 100, 20, "Close window")
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_INTERACT
Debug "The button was pressed."
Case #BUTTON_CLOSE
Quit = #True
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
End
Když si tento kód pročtete, měl by pro vás být celkem snadno pochopitelný, a proto projdu jen některé klíčové části, které pro vás budou nové. Obr. 27 ukazuje, jak toto okno vypadá.

Obr. 27 — (příklad z Microsoft Windows)
V tomto příkladu jsem po vytvoření hlavního okna použil příkaz ‘CreateGadgetList()’. Ten je potřeba k tomu, abyste oknu sdělili, že na něj chcete kreslit gadgety. Tento příkaz přijímá jen jeden parametr, a to identifikátor OS hlavního okna rozhraní, který získám pomocí příkazu ‘WindowID()’, takto:
...
CreateGadgetList(WindowID(#WIN_MAIN))
...
Identifikátory OS byly podrobně probrány v kapitole 7 (PB čísla a identifikátory OS).
Jakmile v hlavním okně vytvoříme seznam gadgetů, můžeme na okno gadgety kreslit. Příkazem ‘ButtonGadget()’ jsem vytvořil dvě tlačítka. Pokud v nápovědě otevřete stránku ‘ButtonGadget()’ (Helpfile:Reference Manual->General Libraries->Gadget->ButtonGadget), uvidíte v příkladu syntaxe přesně, jaké parametry tento příkaz očekává.
Pomocí parametrů polohy v příkazu ‘ButtonGadget()’ jsem tlačítka umístil podél spodního okraje okna.
Upozorním ještě na další klíčovou část: podíváte-li se na hlavní smyčku, uvidíte, že poté, co příkaz ‘WaitWindowEvent()’ vrátí identifikátor události a ten se přiřadí do proměnné ‘Event’, testuji jeho hodnotu příkazem ‘Select’, takto:
...
Select Event
Case #PB_Event_Gadget
...
EndSelect
...
Všimněte si, že první příkaz ‘Case’ testuje hodnotu ‘#PB_Event_Gadget’. To je zvláštní globální hodnota události, pomocí níž se u identifikátoru zjišťuje, zda pochází od gadgetu. Jinými slovy, pokud se ‘Event’ rovná ‘#PB_Event_Gadget’, musí ‘Event’ obsahovat identifikátor události pocházející od gadgetu.
Jakmile víme, že událost pochází od gadgetu, musíme rozlišit, od kterého. To uděláme pomocí příkazu ‘EventGadget()’, který vrací PB číslo gadgetu, od něhož událost pochází. V tomto příkladu tedy testuji návratovou hodnotu ‘EventGadget()’ dalším příkazem ‘Select’.
...
Select EventGadget()
Case #BUTTON_INTERACT
Debug "The button was pressed."
Case #BUTTON_CLOSE
Quit = #True
EndSelect
...
Zde mám dva příkazy ‘Case’: jeden testuje ‘#BUTTON_INTERACT’ a druhý ‘#BUTTON_CLOSE’. Pokud se návratová hodnota ‘EventGadget()’ rovná ‘#BUTTON_INTERACT’, bylo stisknuto tlačítko ‘Click me’. Víme to proto, že ‘EventGadget()’ vrátil PB číslo tohoto gadgetu. Kód, který chci po stisknutí tohoto tlačítka provést, pak napíšu na další řádek za příkaz ‘Case’.
Stejný princip platí i pro další příkaz ‘Case’. Pokud se návratová hodnota rovná ‘#BUTTON_CLOSE’, bylo stisknuto tlačítko ‘Close window’. V takovém případě přiřadím proměnné ‘Quit’ hodnotu pravda, což způsobí ukončení hlavní smyčky a nakonec i programu.
Právě proto je používání bloku konstant ‘Enumeration’ tak nesmírně užitečné. Jakmile na začátku zdrojového kódu definuji číselné konstanty pro všechny gadgety, mohu se pak na každý z nich odkazovat jménem konstanty místo čísla, díky čemuž je zdrojový kód nesrovnatelně přehlednější a čitelnější.
Přijímání textového vstupu
Rozšiřme předchozí příklad ještě o něco dál a přidejme řetězcový gadget (String gadget), abychom mohli zadat nějaký text, který program může použít. Řetězcové gadgety jsou velmi praktické, protože představují jednoduchý způsob, jak programu umožnit přijímat textové řetězce. Následující příklad vám ukáže, jak získat hodnotu řetězcového gadgetu, tj. jeho text, a použít ji ve svém programu. Vytvořme takový gadget přes celou šířku okna. Obr. 28 na další straně ukazuje, jak by měl zkompilovaný program vypadat; zde je kód:
Enumeration
#WIN_MAIN
#TEXT_INPUT
#STRING_INPUT
#BUTTON_INTERACT
#BUTTON_CLOSE
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WIN_MAIN, 0, 0, 300, 200, "Interaction", #FLAGS)
If CreateGadgetList(WindowID(#WIN_MAIN))
TextGadget(#TEXT_INPUT, 10, 10, 280, 20, "Enter text here:")
StringGadget(#STRING_INPUT, 10, 30, 280, 20, "")
ButtonGadget(#BUTTON_INTERACT, 10, 170, 120, 20, "Echo text")
ButtonGadget(#BUTTON_CLOSE, 190, 170, 100, 20, "Close window")
SetActiveGadget(#STRING_INPUT)
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_INTERACT
Debug GetGadgetText(#STRING_INPUT)
Case #BUTTON_CLOSE
Quit = #True
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
End
V této aktualizované verzi jsem do bloku ‘Enumeration’ přidal několik dalších konstant, abych mohl snadno přidat pár dalších gadgetů. Prvním novým gadgetem je textový gadget, který na okně doslova zobrazuje needitovatelný textový řetězec; jeden takový používám k zobrazení řetězce ‘Enter text here:’. Druhým novým gadgetem je řetězcový gadget, který na okně vytvoří vstupní pole, do něhož můžete zadat vlastní text.
Pokud v nápovědě PureBasicu otevřete stránku ‘StringGadget()’ (Helpfile:Reference Manual->General Libraries->Gadget->StringGadget), uvidíte parametry, které tento gadget přijímá. Pomocí parametrů polohy a velikosti jsem řetězcový gadget zarovnal k hornímu okraji okna, těsně pod textový gadget. Jako parametr ‘Content$’ jsem předal prázdný řetězec, který se zapisuje jako dvojice dvojitých uvozovek, mezi nimiž nic není. Je to stále řetězec, ale řetězec bez obsahu. Udělal jsem to proto, že parametr ‘Content$’ nastavuje počáteční text řetězcového gadgetu, a já chci, aby na začátku nebylo zadáno nic.

Obr. 28 — (příklad z Microsoft Windows)
Jakmile program spustíte, všimnete si, že textový kurzor okamžitě bliká v řetězcovém gadgetu. To není výchozí chování – normálně byste museli na gadget klepnout, aby získal fokus a objevil se v něm kurzor. Ve svém programu jsem tento gadget nastavil jako aktivní hned při spuštění pomocí příkazu ‘SetActiveGadget()’. Tento příkaz přijímá jako parametr PB číslo gadgetu, kterému chcete předat fokus, a učiní ho právě aktivním gadgetem. V tomto malém příkladu jsem to udělal proto, abych uživateli pomohl a ušetřil mu jedno klepnutí myší.
Chcete-li vyzkoušet interaktivitu tohoto programu, zadejte po jeho spuštění do řetězcového gadgetu nějaký text a pak stiskněte tlačítko ‘Echo text’. Uvidíte, že se text vypíše do okna Debug Output. Je to proto, že jsem upravil příkaz ‘Case’ pro ‘#BUTTON_INTERACT’ a změnil, co se stane po stisknutí tlačítka ‘Echo text’. Tento řádek kódu teď zní ‘Debug GetGadgetText(#STRING_INPUT)’.
Příkaz ‘GetGadgetText()’ přijímá jeden parametr, a to PB číslo gadgetu, z něhož chcete získat text; zde ho používám k získání textu z řetězcového gadgetu. Tento příkaz lze v PureBasicu použít s mnoha gadgety, ale u řetězcového gadgetu prostě vrátí text jako řetězec, který pak ihned vypíšu příkazem ‘Debug’.
Zobrazování textu
Rozšiřme tento program ještě dál: místo vypisování textu z řetězcového gadgetu do okna Debug Output přidejme gadget, který text zobrazí přímo v našem programu. V následujícím příkladu jsem přidal gadget seznamu (list view gadget), který zobrazuje zadaný text jako seznam needitovatelných řetězců.
Gadget seznamu je skvělý způsob, jak zobrazovat seznamy řetězců, protože každý řetězec má v gadgetu vlastní řádek.
PureBasic nabízí pro práci s gadgety seznamu mnoho příkazů, od přidávání a odebírání až po počítání a řazení položek, které tento typ gadgetu obsahuje. V následujícím malém příkladu jsem k přidávání nových řetězců do svého gadgetu použil pouze příkaz ‘AddGadgetItem()’. Obr. 29 na další straně ukazuje běžící nový program; zde je kód:
Enumeration
#WIN_MAIN
#TEXT_INPUT
#STRING_INPUT
#LIST_INPUT
#BUTTON_INTERACT
#BUTTON_CLOSE
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WIN_MAIN, 0, 0, 300, 200, "Interaction", #FLAGS)
If CreateGadgetList(WindowID(#WIN_MAIN))
TextGadget(#TEXT_INPUT, 10, 10, 280, 20, "Enter text here:")
StringGadget(#STRING_INPUT, 10, 30, 280, 20, "")
ListViewGadget(#LIST_INPUT, 10, 60, 280, 100)
ButtonGadget(#BUTTON_INTERACT, 10, 170, 120, 20, "Enter text")
ButtonGadget(#BUTTON_CLOSE, 190, 170, 100, 20, "Close window")
SetActiveGadget(#STRING_INPUT)
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_INTERACT
AddGadgetItem(#LIST_INPUT, -1, GetGadgetText(#STRING_INPUT))
SetGadgetText(#STRING_INPUT, "")
SetActiveGadget(#STRING_INPUT)
Case #BUTTON_CLOSE
Quit = #True
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
End
Tento příklad je velmi podobný předchozímu; jediným skutečným rozdílem je ve skutečnosti přidání gadgetu seznamu. Když si v nápovědě PureBasicu přečtete stránku ‘ListViewGadget()’ (Helpfile:Reference Manual->General Libraries->Gadget->ListViewGadget), získáte dobrý přehled o tomto gadgetu a o tom, čeho s ním můžete dosáhnout. Z příkladu syntaxe, který tam najdete, se také přesně dozvíte, jaké parametry tento gadget přijímá. Pomocí parametrů polohy a velikosti jsem gadget seznamu umístil doprostřed hlavního okna, nad tlačítka, ale pod řetězcový gadget.

Obr. 29 — (příklad z Microsoft Windows)
Jakmile program spustíte, zadejte do řetězcového gadgetu nějaký text a stiskněte tlačítko ‘Enter text’. Tím se text z řetězcového gadgetu převezme a přidá do gadgetu seznamu. Poté program řetězcový gadget vymaže, aby byl připraven na další vstup.
Toho všeho je dosaženo tím, že jsem opět upravil příkaz ‘Case’ pro ‘#BUTTON_INTERACT’ a změnil, co se stane po stisknutí přejmenovaného tlačítka ‘Enter text’. Zde jsou tři nové řádky, které jsem do příkazu ‘Case’ pro ‘#BUTTON_INTERACT’ přidal:
...
Case #BUTTON_INTERACT
AddGadgetItem(#LIST_INPUT, -1, GetGadgetText(#STRING_INPUT))
SetGadgetText(#STRING_INPUT, "")
SetActiveGadget(#STRING_INPUT)
...
První řádek za příkazem ‘Case’ přidá položku do gadgetu seznamu. Pokud v nápovědě otevřete stránku ‘AddGadgetItem()’ (Helpfile:Reference Manual->General Libraries->Gadget-> AddGadgetItem), uvidíte parametry, které tento příkaz přijímá. Prvním parametrem je PB číslo gadgetu, do něhož chcete položku přidat; v našem případě je to ‘#LIST_INPUT’, konstanta, která obsahuje číslo našeho gadgetu. Druhým parametrem je pozice v seznamu (existujících či neexistujících hodnot), na kterou chcete novou položku přidat; nezapomeňte, že indexy začínají od ‘0’. Ve výše uvedeném příkladu chci, aby se text přidal na konec seznamu bez ohledu na to, jaký index to bude, a proto tento parametr zadávám jako ‘-1’. Tím příkazu říkám, ať se nezabývá vkládáním na konkrétní index a prostě položku přidá na konec aktuálního seznamu, ať je jakkoli velký.
Třetím parametrem je samotný řetězec, který chcete do gadgetu přidat. Zde jsem použil příkaz ‘GetGadgetText()’, který vrátí aktuální hodnotu řetězcového gadgetu ‘#STRING_INPUT’ a předá ji jako parametr. ‘AddGadgetItem()’ přijímá více parametrů, než jsem zde použil, ale ostatní jsou nepovinné, a tudíž nejsou nutné, proto jsem je nepoužil.
Druhý řádek kódu za příkazem ‘Case’ používá příkaz ‘SetGadgetText()’, který pomocí prázdného řetězce nastaví hodnotu řetězcového gadgetu na nic. Je to proto, že jakmile je text vložen do gadgetu seznamu, chci řetězcový gadget vymazat, aby byl připraven na zadání nového řetězce.
Poslední řádek znovu používá příkaz ‘SetActiveGadget()’, aby předal fokus řetězcovému gadgetu ‘#STRING_INPUT’ a textový kurzor se v něm objevil připravený na další vstup, což uživateli ušetří jedno či dvě klepnutí myší.
Co jsme se zatím naučili?
Doufám, že posledních několik příkladů bylo dobrým úvodem do nativních grafických uživatelských rozhraní a poskytlo vám dobrý výchozí bod pro další studium. V této knize vám nemohu dát příklady všech rozhraní, která budete pravděpodobně chtít vytvořit; mohu vám jen dát základní stavební kameny rozhraní a nechat vás na nich stavět.
Začátek každého nativního rozhraní v PureBasicu je stejný. Nejprve musíte příkazem ‘OpenWindow()’ otevřít okno. Zadruhé, chcete-li na toto okno umístit gadgety, musíte příkazem ‘CreateGadgetList()’ vytvořit seznam gadgetů, a zatřetí musíte mít hlavní smyčku, která udržuje program v chodu a zpracovává všechny události, které mohou nastat. Všechny události, které nastanou, vrací příkaz ‘WaitWindowEvent()’ nebo ‘WindowEvent()’ v hlavní smyčce.
Přečtěte si v nápovědě oddíl o gadgetech
Pokud jste pochopili, co bylo dosud napsáno, jste na dobré cestě k úplnému porozumění tomu, jak v PureBasicu vytvářet nativní rozhraní. Jakmile pochopíte základy, zbývá už jen zjistit, jaké gadgety jsou k dispozici, a naučit se je používat. Toho dosáhnete pročtením nápovědy PureBasicu v oddílu ‘Gadget’ (Helpfile:Reference Manual->General Libraries->Gadget). Doporučuji přečíst si tento oddíl od začátku do konce, abyste věděli, co máte k dispozici, a pochopili, které příkazy fungují s kterým gadgetem.
Vezměte si například příkaz ‘SetGadgetText()’, který lze použít s mnoha různými gadgety. Podíváte-li se v nápovědě na stránku ‘SetGadgetText()’ (Helpfile:Reference Manual->General Libraries- >Gadget->SetGadgetText), najdete tam seznam všech gadgetů, se kterými tento příkaz funguje, spolu se zvláštními pokyny pro použití s určitým gadgetem.
Probrat zde všechny gadgety a příkazy, které s nimi pracují, by trvalo příliš dlouho a nejspíš by to vydalo na samostatnou knihu. Myslím si proto, že bude lepší, když se s oddílem ‘Gadget’ v nápovědě seznámíte sami.
Pokud mezitím potřebujete rychlý přehled o tom, jaké gadgety jsou v PureBasicu k dispozici, podívejte se do přílohy B (Užitečné tabulky), kde najdete úplný seznam všech gadgetů se stručným popisem každého z nich.
Přidání nabídky
Přidání nativní nabídky do rozhraní je v PureBasicu velmi snadné a velmi podobné přidávání gadgetů. Výběr položek nabídky vyvolává události stejně jako gadgety a tyto události se zpracovávají v hlavní smyčce společně s událostmi gadgetů.
Všechny položky nabídky se stejně jako gadgety definují s vlastním PB číslem, které se později používá k rozlišení, která položka nabídky vyvolala událost. Zde je malý příklad:
Enumeration
#WINDOW_MAIN
#MENU_MAIN
#MENU_QUIT
#MENU_ABOUT
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN, 0, 0, 300, 200, "Menu Example", #FLAGS)
If CreateMenu(#MENU_MAIN, WindowID(#WINDOW_MAIN))
MenuTitle("File")
MenuItem(#MENU_QUIT, "Quit")
MenuTitle("Help")
MenuItem(#MENU_ABOUT, "About...")
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Menu
Select EventMenu()
Case #MENU_QUIT
Quit = #True
Case #MENU_ABOUT
MessageRequester("About", "This is where you describe your program.")
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
End
Tento malý příklad ukazuje nativní nabídku přidanou do prázdného okna. Nabídka má dva nadpisy a každý z nich obsahuje jednu položku. Z výše uvedeného příkladu vidíte, jak takovou nabídku vytvořit.
Nejprve je třeba otevřít okno, což je asi zřejmé, ale potřebujeme ho zde proto, že k němu bude nabídka připojena. Jakmile je okno vytvořeno, vytvoříme kostru nabídky příkazem ‘CreateMenu()’. Tento příkaz přijímá dva parametry: prvním je PB číslo tohoto objektu nabídky a druhým identifikátor OS okna, ke kterému má být připojena. Syntaxe je velmi podobná syntaxi příkazu ‘CreateGadgetList()’ a i zde jsem k získání identifikátoru OS hlavního okna použil příkaz ‘WindowID()’.
Po úspěšném vytvoření kostry nabídky ji můžete naplnit samotnými nadpisy a položkami nabídky. K tomu nejprve použiji příkaz ‘MenuTitle()’. Ten vytvoří nadpis nabídky, který se zobrazuje v horní části okna (nebo v případě Mac OS X v horní části obrazovky). Tento příkaz přijímá jeden řetězcový parametr, kterým je název nadpisu.
Jakmile je nadpis nabídky definován, všechny položky nabídky, které od té chvíle ve svém programu vytvoříte, se objeví pod tímto nadpisem. Položky nabídky se vytvářejí příkazem ‘MenuItem()’. Ten přijímá dva parametry: prvním je PB číslo, ke kterému bude tato položka přiřazena, a druhým řetězec, který chcete pro tuto položku v nabídce zobrazit.
Ve svém příkladu jsem pod nadpisem nabídky ‘File’ definoval jednu položku s názvem ‘Quit’ a pak jsem znovu použil příkaz ‘MenuTitle()’ k vytvoření dalšího nadpisu nabídky s názvem ‘Help’. Jakmile takto vytvoříte další nadpis nabídky, všechny následující položky se opět vytvářejí pod tímto novým nadpisem, stejně jako nově vytvořená položka ‘About...’.
Zjišťování událostí nabídky
Jakmile je nabídka vytvořena včetně všech nadpisů a položek, zjišťujeme v hlavní smyčce události, které vyvolávají. Téměř přesně jako při zjišťování událostí od gadgetů používáme globální hodnotu události nazvanou ‘#PB_Event_Menu’.
Pokud se událost vrácená příkazem ‘WaitWindowEvent()’ rovná ‘#PB_Event_Menu’, pochází tato událost od položky nabídky. Tento příkaz jsem použil v příkazu ‘Select’ takto:
...
Select Event
Case #PB_Event_Menu
Select EventMenu()
Case #MENU_QUIT
Quit = #True
Case #MENU_ABOUT
MessageRequester("About", "This is where you describe your program.")
EndSelect
EndSelect
...
Abychom přesně zjistili, která položka nabídky tuto událost vyvolala, musíme použít příkaz ‘EventMenu()’. Ten vrací PB číslo položky nabídky, která událost vyvolala. Tento příkaz jsem použil v dalším příkazu ‘Select’, který zpracovává více případů událostí, takže mohu elegantně zpracovat události od libovolné položky nabídky. Pokud se v tomto příkazu ‘Select’ hodnota vrácená příkazem ‘EventMenu()’ rovná ‘#MENU_QUIT’, byla vybrána položka nabídky ‘Quit’ a já přiřadím proměnné ‘Quit’ hodnotu pravda, což ukončí hlavní smyčku, a tím i program. Pokud se hodnota vrácená příkazem ‘EventMenu()’ rovná ‘#MENU_ABOUT’, byla vybrána položka nabídky ‘About...’ a já zobrazím okno se zprávou, které obsahuje informace o mém programu.
Položky podnabídek
Dosud jsem předvedl, jak vytvářet standardní nabídky, ale můžete vytvářet i takzvané podnabídky. Jsou to nabídky, které z nadřazené nabídky odbočují do další, připojené podřízené nabídky. Vzniká tak stromová struktura nabídek, podobně jako u nabídky ‘Start’ v Microsoft Windows. Všechny položky v těchto nových podřízených nabídkách vyvolávají události přesně stejným způsobem jako kterákoli jiná položka nabídky a v hlavní smyčce je lze stejně zachytit. Zde je příklad:
Enumeration
#WINDOW_MAIN
#MENU_MAIN
#MENU_CHILD
#MENU_QUIT
#MENU_ABOUT
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN, 0, 0, 300, 200, "Menu Example", #FLAGS)
If CreateMenu(#MENU_MAIN, WindowID(#WINDOW_MAIN))
MenuTitle("File")
OpenSubMenu("Parent Menu Item")
MenuItem(#MENU_CHILD, "Sub Menu Item")
CloseSubMenu()
MenuBar()
MenuItem(#MENU_QUIT, "Quit")
MenuTitle("Help")
MenuItem(#MENU_ABOUT, "About...")
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Menu
Select EventMenu()
Case #MENU_CHILD
Debug "Sub menu item selected."
Case #MENU_QUIT
Quit = #True
Case #MENU_ABOUT
MessageRequester("About", "This is where you describe your program.")
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
End
Podnabídka se vytváří příkazem ‘OpenSubMenu()’ za příkazem ‘MenuTitle()’. Je tomu tak proto, aby podnabídka patřila k nadpisu nabídky stejně jako kterákoli jiná položka nabídky. Příkaz ‘OpenSubMenu()’ přijímá jeden parametr, a to řetězec, který se v nabídce zobrazuje před šipkou podnabídky. Jakmile použijete příkaz ‘OpenSubMenu()’, všechny následně použité příkazy ‘MenuItem()’ budou umísťovat nové položky do podnabídky. Chcete-li tuto podnabídku uzavřít, abyste mohli přidávat další položky do hlavní nabídky, musíte zavolat příkaz ‘CloseSubMenu()’. Ten přepne vytváření položek nabídky zpět do nadřazené nabídky.
Nové položky přidané do podnabídek vyvolávají události, které lze v hlavní smyčce zachytit stejným způsobem jako u kterékoli jiné položky nabídky. Podíváte-li se na příkaz ‘Select’ pro ‘EventMenu()’, uvidíte, že jsem přidal novou zpracovávanou hodnotu: ‘#MENU_CHILD’. Pokud se návratová hodnota ‘EventMenu()’ rovná hodnotě ‘#MENU_CHILD’, musela být vybrána položka podřízené nabídky, a proto to dám najevo vypsáním textu do okna Debug Output.
Oddělování položek nabídky
Podíváte-li se na výše uvedený příklad pozorněji, zjistíte, že jsem přidal ještě jeden nový příkaz. Ten v nabídce nakreslí pěknou grafickou oddělovací čáru, která se hodí k oddělení určitých položek nabídky. Tímto novým příkazem je ‘MenuBar()’. Nepřijímá žádné parametry a používá se všude tam, kde chcete v aktuální nabídce umístit oddělovač. Obvykle se jím odděluje položka ‘Quit’ od ostatních položek v nabídce ‘File’, a přesně to jsem v tomto příkladu udělal.
Kombinace gadgetů a nabídek v jednom programu
Zahrnout do jednoho programu nabídky i gadgety je snadné. Nejprve otevřete okno a vytvoříte nabídku. Pak vytvoříte seznam gadgetů a nakreslíte své gadgety – tak jednoduché to je. Zde je příklad kódu:
Enumeration
#WINDOW_MAIN
#MENU_MAIN
#MENU_QUIT
#MENU_ABOUT
#TEXT_INPUT
#STRING_INPUT
#LIST_INPUT
#BUTTON_INTERACT
#BUTTON_CLOSE
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN, 0, 0, 300, 222, "Interaction", #FLAGS)
If CreateMenu(#MENU_MAIN, WindowID(#WINDOW_MAIN))
MenuTitle("File")
MenuItem(#MENU_QUIT, "Quit")
MenuTitle("Help")
MenuItem(#MENU_ABOUT, "About...")
If CreateGadgetList(WindowID(#WINDOW_MAIN))
TextGadget(#TEXT_INPUT, 10, 10, 280, 20, "Enter text here:")
StringGadget(#STRING_INPUT, 10, 30, 280, 20, "")
ListViewGadget(#LIST_INPUT, 10, 60, 280, 100)
ButtonGadget(#BUTTON_INTERACT, 10, 170, 120, 20, "Enter text")
ButtonGadget(#BUTTON_CLOSE, 190, 170, 100, 20, "Close window")
SetActiveGadget(#STRING_INPUT)
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Menu
Select EventMenu()
Case #MENU_QUIT
Quit = #True
Case #MENU_ABOUT
MessageRequester("About", "This is your program description.")
EndSelect
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_INTERACT
AddGadgetItem(#LIST_INPUT, -1, GetGadgetText(#STRING_INPUT))
SetGadgetText(#STRING_INPUT, "")
SetActiveGadget(#STRING_INPUT)
Case #BUTTON_CLOSE
Quit = #True
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
EndIf
End
Ke zpracování událostí od položek nabídky i od gadgetů můžete použít různé globální konstanty událostí. Ve výše uvedeném příkladu jsem použil obě ve stejném příkazu ‘Select’, který testuje proměnnou ‘Event’, takto:
...
Select Event
Case #PB_Event_Menu
Select EventMenu()
...
;Menu events are handled here
...
EndSelect
...
Case #PB_Event_Gadget
Select EventGadget()
...
;Gadget events are handled here
...
EndSelect
EndSelect
...
Je-li událost vyvolána položkou nabídky, zpracuje se v příkazu ‘Case’ pro ‘#PB_Event_Menu’ a konkrétní položku nabídky lze určit příkazem ‘EventMenu()’. Je-li událost vyvolána gadgetem, zpracuje se v příkazu ‘Case’ pro ‘#PB_Event_Gadget’ a konkrétní gadget lze určit příkazem ‘EventGadget()’. Díky tomu můžete zpracovávat všechny události nabídek i gadgetů v jednom vnořeném příkazu ‘Select’, jak ukazuje úryvek na předchozí straně.
Klávesové zkratky v nabídkách
Většina dnešního softwaru nabízí nějakou formu klávesových zkratek pro výběr položek nabídky. Tyto zkratky jsou prostě kombinace kláves, které můžete stisknout na klávesnici, abyste vyvolali položku nabídky, aniž byste ji museli fyzicky vybírat z nabídky. PureBasic je do vašeho programu dokáže snadno vložit.
Abychom si to předvedli, musíme vytvořit okno s nabídkou. V této nabídce definujeme položky, tentokrát však s akcelerátory. Akcelerátor je počítačový termín pro řetězec na

Obr. 30
konci položky nabídky, který popisuje, jakou zkratku je třeba stisknout, aby se položka vyvolala. Obr. 30 ukazuje akcelerátory definované v nabídce File v IDE PureBasicu. Je z něj vidět, že pokud chcete v IDE PureBasicu vytvořit nový dokument, můžete stisknout ‘Ctrl+N’, tedy současně klávesu ‘Control’ a klávesu ‘N’ na klávesnici, a tak dále.
Na obr. 30 si také všimnete, že akcelerátory jsou zarovnány k pravé straně nabídky. Je tomu tak proto, aby byly zřetelně označené a aby nabídka sama zůstala přehledná.
V následujícím kusu kódu rozšířím předchozí příklad s nabídkou a přidám akcelerátory a klávesové zkratky; spusťte ho a vyzkoušejte si je sami.
Enumeration
#WIN_MAIN
#MENU_MAIN
#M_QUIT
#M_ABOUT
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WIN_MAIN, 0, 0, 300, 200, "Menu Example", #FLAGS)
If CreateMenu(#MENU_MAIN, WindowID(#WIN_MAIN))
MenuTitle("File")
MenuItem(#M_QUIT, "Quit" + #TAB$ + "Ctrl+Q")
MenuTitle("Help")
MenuItem(#M_ABOUT, "About..." + #TAB$ + "Ctrl+A")
AddKeyboardShortcut(#WIN_MAIN,#PB_Shortcut_Control|#PB_Shortcut_Q,#M_QUIT)
AddKeyboardShortcut(#WIN_MAIN,#PB_Shortcut_Control|#PB_Shortcut_A,#M_ABOUT)
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Menu
Select EventMenu()
Case #M_QUIT
Quit = #True
Case #M_ABOUT
MessageRequester("About", "This is where you describe your program.")
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
End
Když příklad spustíte, uvidíte, že vedle položek nabídky jsou nyní akcelerátory. Ty se definují pomocí znaku tabulátoru v řetězci položky nabídky, takto:
...
MenuItem(#M_QUIT, "Quit" + #TAB$ + "Ctrl+Q")
...
Tento příkaz stále přijímá dva parametry, ale druhý, řetězcový parametr se skládá ze tří částí. První částí je řetězec položky nabídky, v tomto případě ‘Quit’. Na jeho konec pak připojíme znak tabulátoru pomocí vestavěné řetězcové konstanty ‘#TAB$’. Tato konstanta obsahuje hodnotu ASCII ‘9’ v podobě řetězce. Poté připojíme další řetězec, kterým je akcelerátor nabídky: ‘Ctrl+Q’.
Místo mezery se zde používá tabulátor proto, aby byly akcelerátory vždy zarovnány k pravé straně nabídky bez ohledu na délku řetězců položek nabídky.
Jakmile jsou akcelerátory zadány vedle položek nabídky, je vizuální část hotová – akcelerátory jsou koneckonců určeny jen k tomu, aby se na ně uživatel mohl podívat. Abychom akcelerátorům dodali funkčnost zkratek, musíme použít příkaz ‘AddKeyboardShortcut()’. Ve svém kódu jsem tyto příkazy použil takto:
...
AddKeyboardShortcut(#WIN_MAIN,#PB_Shortcut_Control|#PB_Shortcut_Q,#M_QUIT)
AddKeyboardShortcut(#WIN_MAIN,#PB_Shortcut_Control|#PB_Shortcut_A,#M_ABOUT)
...
Tento příkaz přijímá tři parametry. Prvním je PB číslo okna, ke kterému je zkratka přiřazena, v tomto případě ‘#WIN_MAIN’. Druhým parametrem je hodnota, která představuje samotnou klávesovou zkratku. Tato hodnota se skládá z vestavěných konstant, které představují různé kombinace kláves na klávesnici. Na prvním řádku výše uvedeného úryvku jsem zkombinoval konstanty ‘#PB_Shortcut_Control’ a ‘#PB_Shortcut_Q’, abych určil, že zkratkou má být ‘Control+Q’. Tyto konstanty se kombinují obvyklým způsobem pomocí bitového operátoru ‘Or’ (‘|’). Všechny konstanty zkratek, které můžete použít k vytvoření ostatních kombinací kláves, jsou uvedeny v nápovědě PureBasicu na stránce ‘AddKeyboardShortcut()’ (Helpfile:Reference Manual->General Libraries- >Window->AddKeyboardShortcut). Třetím parametrem je PB číslo položky nabídky, ke které chcete tuto zkratku přiřadit. Na prvním řádku výše uvedeného úryvku jsem použil ‘#M_QUIT’, což je stejné PB číslo, jaké jsem předtím použil k vytvoření položky nabídky ‘Quit’. To znamená, že po stisknutí této zkratky na klávesnici se vyvolá událost se stejnou hodnotou, jako kdyby byla vybrána položka nabídky ‘Quit’.
Na dalším řádku úryvku jsem tento příkaz zopakoval s jinými parametry, abych vytvořil klávesovou zkratku pro položku nabídky ‘About’.
Události vyvolané klávesovými zkratkami se zpracovávají přesně stejně, jako kdyby byly vyvolány výběrem položky nabídky, a v hlavní smyčce není absolutně žádný rozdíl, jak je vidět z příkladu se zkratkami.
Klávesové zkratky bez nabídky
Pomocí stejných příkazů pro klávesové zkratky můžete vytvářet klávesové zkratky i bez nabídky, o kterou by se opíraly. Stačí příkazem ‘AddKeyboardShortcut()’ vytvořit zkratku přiřazenou k oknu a ve třetím parametru místo PB čísla položky nabídky použít nějakou jedinečnou hodnotu. Tuto hodnotu pak v hlavní smyčce testujete jako událost nabídky, přestože žádná nabídka neexistuje. Zde je příklad:
#WIN_MAIN = 1
#SC_EVENT = 2
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WIN_MAIN, 0, 0, 300, 200, "Hello World", #FLAGS)
AddKeyboardShortcut(#WIN_MAIN,#PB_Shortcut_Control|#PB_Shortcut_Z, #SC_EVENT)
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Menu
Select EventMenu()
Case #SC_EVENT
Debug "The shortcut was pressed"
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow
EndIf
End
Zatímco výše uvedený příklad běží, stiskněte na klávesnici ‘Control+Z’ a v okně Debug Output by se měl objevit text ‘The shortcut was pressed’. Tento příklad funguje proto, že příkaz ‘AddKeyboardShortcut()’ vyvolá událost nabídky, která se v hlavní smyčce správně zpracuje, i když k oknu není fyzicky připojena žádná nabídka. Je to šikovný trik, který se vám bude hodit, pokud budete někdy chtít do svých programů přidat klávesové zkratky, aniž byste chtěli nabídku.
Začlenění grafiky do programu
Někdy budete chtít do svých programů zahrnout určité obrázky a PureBasic to velmi usnadňuje. V této části vám ukážu, jak přidat obrázky do rozhraní jedním ze dvou způsobů. Zaprvé je můžete načíst z externího zdroje, například obrázek může ležet ve stejném adresáři jako váš program. Zadruhé můžete obrázek vložit přímo do programu, takže budete mít jen jeden spustitelný soubor. Oba způsoby vedou ke stejnému výsledku, záleží však na tom, jak chcete se samotným souborem obrázku zacházet. Obě metody vyžadují, aby bylo na okně umístěn obrázkový gadget (image gadget), který obrázek zobrazí. Ten se na okno umísťuje stejně jako kterýkoli jiný gadget a řídí se stejnými pravidly.
Načítání obrázků do programu
Tato metoda načítání obrázků pro použití v rozhraní spoléhá na externí obrázky. Na rozdíl od vkládání obrázků vyžaduje, abyste všechny použité obrázky distribuovali spolu se spustitelným souborem. Zde je příklad:
Enumeration
#WIN_MAIN
#IMAGE_FILE
#IMAGE_DISPLAY
#BUTTON_CLOSE
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WIN_MAIN, 0, 0, 300, 200, "Image Example", #FLAGS)
If CreateGadgetList(WindowID(#WIN_MAIN))
If LoadImage(#IMAGE_FILE, "image.bmp")
ImageGadget(#IMAGE_DISPLAY, 10, 10, 280, 150, ImageID(#IMAGE_FILE))
ButtonGadget(#BUTTON_CLOSE, 100, 170, 100, 20, "Close window")
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_CLOSE
Quit = #True
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
EndIf
End
Aby tento příklad správně fungoval, budete potřebovat obrázek o rozměrech ‘280’ × ‘150’ pixelů, uložený ve formátu Bitmap ve stejném adresáři jako zdrojový kód nebo výsledný zkompilovaný spustitelný soubor. Jakmile ho tam máte, bude program (po spuštění) vypadat zhruba jako na obr. 31 na další straně.
V tomto příkladu jsem příkazem ‘LoadImage()’ načetl obrázek z určitého místa na pevném disku do paměti, aby byl připraven k zobrazení v programu, takto:
...
LoadImage(#IMAGE_FILE, "image.bmp")
...
Podíváte-li se na příkaz ‘LoadImage()’ v nápovědě PureBasicu (Helpfile:Reference Manual- >General Libraries->Image->LoadImage), uvidíte, že tento příkaz přijímá tři parametry. Prvním je PB číslo, které bude k načtenému obrázku přiřazeno, a druhým místo na pevném disku, odkud se obrázek načte. Pokud druhý parametr neobsahuje žádné informace o cestě k souboru, předpokládá se, že umístění souboru je relativní vzhledem k samotnému programu. Třetí, nepovinný parametr jsem v tomto příkladu nepoužil. Jako obvykle jsem návratovou hodnotu tohoto příkazu otestoval příkazem ‘If’, abych se ujistil, že se obrázek správně načetl, a teprve pak pokračoval se zbytkem programu.
Jakmile je obrázek správně načten, můžete ho zobrazit ve svém rozhraní pomocí obrázkového gadgetu. Podíváte-li se na příklad s obrázkovým gadgetem, uvidíte, že po vytvoření seznamu gadgetů jsem použil příkaz ‘ImageGadget’, takto:
...
ImageGadget(#IMAGE_DISPLAY, 10, 10, 280, 150, ImageID(#IMAGE_FILE))
...
‘ImageGadget()’ je snadno pochopitelný příkaz. Prvním parametrem je PB číslo přiřazené tomuto gadgetu, nikoli načtenému obrázku. Další čtyři parametry se týkají polohy a velikosti gadgetu, podobně jako u ostatních gadgetů. Pátým parametrem určujeme, jaký obrázek bude gadget zobrazovat, takže tento parametr musí být identifikátorem OS dříve načteného obrázku. Protože vhodný obrázek už máme načtený, můžeme jeho identifikátor OS získat příkazem ‘ImageID()’. Ve výše uvedeném kódu jsem příkazem ‘ImageID()’ získal identifikátor OS obrázku ‘#IMAGE_FILE’, který byl předtím načten příkazem ‘LoadImage()’.

Obr. 31 — (příklad z Microsoft Windows)
Tento způsob načítání obrázků a jejich zobrazování v obrázkovém gadgetu je jednoduchý, musíte však mít na paměti, že pokud takto začleňujete obrázky do svých rozhraní, musíte použité obrázky vždy distribuovat spolu s výsledným spustitelným souborem. Váš program totiž bude externí obrázky k načtení hledat vždy, i když je zkompilovaný. Chcete-li obrázky do programu vložit úplně, čtěte dál.
Vkládání obrázků do programu
Předchozí metoda načítání obrázků je v pořádku, ale někdy potřebujete vytvořit zcela samostatný spustitelný soubor, do kterého jsou všechny použité obrázky kompletně vloženy, aby nebyl závislý na žádných dalších externích médiích. Tato metoda využívá takzvanou datovou sekci, do níž můžete vložit binární soubory, které spustitelný soubor v případě potřeby použije. Zde je příklad:
Enumeration
#WIN_MAIN
#IMAGE_MEMORY
#IMAGE_DISPLAY
#BUTTON_CLOSE
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WIN_MAIN, 0, 0, 300, 200, "Image Example", #FLAGS)
If CreateGadgetList(WindowID(#WIN_MAIN))
If CatchImage(#IMAGE_MEMORY, ?Image)
ImageGadget(#IMAGE_DISPLAY, 10, 10, 280, 150, ImageID(#IMAGE_MEMORY))
ButtonGadget(#BUTTON_CLOSE, 100, 170, 100, 20, "Close window")
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_CLOSE
Quit = #True
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
EndIf
End
DataSection
Image:
IncludeBinary "image.bmp"
EndDataSection
Tento příklad je velmi podobný předchozímu, jen s tím rozdílem, že tento při kompilaci vkládá obrázek do datové sekce. Po spuštění programu se obrázek čte z datové sekce, a ne z pevného disku. Podíváte-li se na příklad, uvidíte datovou sekci na konci zdrojového kódu; vypadá takto:
...
DataSection
Image:
IncludeBinary "image.bmp"
EndDataSection
Příkazy ‘DataSection’ a ‘EndDataSection’ označují začátek a konec sekce. Do ní pak můžete příkazem ‘IncludeBinary’ vkládat binární soubory. Tento příkaz nepoužívá žádné závorky, jen se za něj uvede řetězec, který určuje soubor k vložení.
V tomto případě jsem vložil soubor s názvem ‘image.bmp’. Všimnete si také, že jsem před příkaz ‘IncludeBinary’ umístil návěští, velmi podobně jako při definici podprogramu. Toto návěští umožní vašemu programu najít v paměti začátek tohoto obrázku, jakmile je s programem načten. Jakmile je obrázek takto vložen, můžeme ho snadno použít v hlavním kódu.
V hlavním kódu už k načtení obrázku do paměti nepoužíváme příkaz ‘LoadImage()’. Jakmile je obrázek umístěn v datové sekci, je při běhu programu už načtený. K získání obrázku z datové sekce proto použijeme příkaz ‘CatchImage()’, takto:
...
CatchImage(#IMAGE_MEMORY, ?Image)
...
Podíváte-li se na příkaz ‘CatchImage()’ v nápovědě PureBasicu (Helpfile:Reference Manual- >General Libraries->Image->CatchImage), uvidíte, že tento příkaz přijímá tři parametry. Prvním je PB číslo, které bude k tomuto obrázku přiřazeno. Druhým parametrem je adresa v paměti, kde se obrázek nachází. Jak si jistě vzpomínáte, k jejímu označení jsem v datové sekci použil návěští, takže potřebuji získat adresu tohoto návěští v paměti. Udělám to tak, že při použití návěští jako parametru před něj napíšu otazník. Tento otazník je zvláštní jednoznaková funkce, která vrací adresu v paměti libovolného návěští. Podrobněji je to vysvětleno později v kapitole 13 (Ukazatele). Třetí parametr jsem v tomto příkladu nepoužil, protože je nepovinný.
Zobrazení obrázku načteného příkazem ‘CatchImage()’ je přesně stejné jako při použití příkazu ‘LoadImage()’. Opět použijeme obrázkový gadget a jeho parametry vyplníme stejně jako předtím:
...
ImageGadget(#IMAGE_DISPLAY, 10, 10, 280, 150, ImageID(#IMAGE_MEMORY))
...
Po spuštění by měl tento příklad opět vypadat jako na obr. 31. Je to proto, že jde o stejný program, který však už nepotřebuje externí soubor ‘image.bmp’.
Jaké formáty obrázků lze používat?
V několika posledních příkladech jsem načítal a vkládal obrázky ve formátu Bitmap (*.bmp), ale nejste omezeni jen na tento jediný formát.
Standardně dokáže PureBasic načítat a zobrazovat soubory ve formátu Bitmap (.bmp) a Icon (.ico), což ale může být někdy omezující. Potřebujete-li používat jiné formáty, můžete použít volitelné příkazy dekodérů, které rozšíří funkčnost příkazů PureBasicu pro načítání obrázků. Tyto další dekodéry se používají nesmírně snadno: stačí na začátku zdrojového kódu použít příkaz dekodéru a od té chvíle mají všechny příkazy pro načítání obrázků ve vašem programu plnou podporu formátu obrázků, který použitý dekodér zpracovává. Více informací o dekodérech najdete v nápovědě PureBasicu (Helpfile:Reference Manual->General Libraries->ImagePlugin).
Zde jsou další příkazy dekodérů:
‘UseJPEGImageDecoder()’ Tento dekodér přidává podporu formátu obrázků Jpeg (.jpg/.jpeg).
‘UsePNGImageDecoder()’ Tento dekodér přidává podporu formátu obrázků Png (*.png).
‘UseTIFFImageDecoder()’ Tento dekodér přidává podporu formátu obrázků TIFF (.tif/.tiff).
‘UseTGAImageDecoder()’ Tento dekodér přidává podporu formátu obrázků Targa (*.tga).
Jak už bylo řečeno, používání těchto příkazů dekodérů je jednoduchost sama. Vezměme poslední příklad s vkládáním obrázku a přidejme do něj podporu formátu Jpeg, abychom mohli místo souboru Bitmap vložit soubor Jpeg:
UseJPEGImageDecoder()
Enumeration
#WIN_MAIN
#IMAGE_MEMORY
#IMAGE_DISPLAY
#BUTTON_CLOSE
EndEnumeration
Global Quit.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WIN_MAIN, 0, 0, 300, 200, "Image Example", #FLAGS)
If CreateGadgetList(WindowID(#WIN_MAIN))
If CatchImage(#IMAGE_MEMORY, ?Image)
ImageGadget(#IMAGE_DISPLAY, 10, 10, 280, 150, ImageID(#IMAGE_MEMORY))
ButtonGadget(#BUTTON_CLOSE, 100, 170, 100, 20, "Close window")
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_CLOSE
Quit = #True
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
EndIf
End
DataSection
Image:
IncludeBinary "image.jpg"
EndDataSection
Jedinou změnou, kterou jsem v tomto příkladu provedl ve zdrojovém kódu, aby podporoval soubory Jpeg, je přidání příkazu ‘UseJPEGImageDecoder()’ jako prvního řádku kódu a záměna obrázku v datové sekci za obrázek ve formátu Jpeg. Tento program nyní místo obrázku Bitmap vkládá obrázek Jpeg.
Všechny ostatní dekodéry se používají stejně: stačí na začátek zdrojového kódu přidat příkaz dekodéru, a tím přidat podporu dalších formátů souborů.
První pohled na nový Visual Designer
Součástí PureBasicu je výkonný Visual Designer (vizuální návrhář, VD), který vám umožňuje vytvářet rozhraní vizuálně a dynamicky. Řečeno prostými slovy to znamená, že můžete gadgety doslova nakreslit na okno a vytvořit tak své rozhraní, přičemž veškerý příslušný kód v PureBasicu se pro vás vygeneruje automaticky a v reálném čase.
Použití takového nástroje vám může při navrhování rozhraní ušetřit značné množství času, protože upravujete vzhled a chování rozhraní a výsledky vidíte okamžitě. Kód byste také měli být schopni později znovu načíst, pokud potřebujete něco přidat nebo programu dodat další funkčnost. Při načítání existujících zdrojových kódů však v současné době platí jedno omezení: kód, který nenapsal vizuální návrhář, se při otevření k dalším úpravám nemusí načíst správně. Je to proto, že vizuální návrhář generuje kód určitým způsobem, a pokud se ručně psaný soubor od tohoto formátu odchyluje, může mít návrhář s jeho načtením potíže. Vizuální návrhář je stejně jako ostatní dodávané nástroje napsán celý od základu v PureBasicu a komunita PureBasicu mu barvitě říká „VD“.
Proč jste se o něm nezmínil dříve?
Považoval jsem za velmi důležité, abyste se nejprve naučili, jak v PureBasicu fungují gadgety, nabídky a události, a získali tak pevnější základ pro pochopení kódu, který VD generuje. Proto jsem se rozhodl zmínit se o něm v této kapitole až nakonec.
Hlavní okno
Když vizuální návrhář spustíte, bude vypadat zhruba jako na obr. 32. Hlavní okno je rozhraní pro více dokumentů (multiple document interface), které obsahuje všechny nástroje, jež budete k návrhu rozhraní potřebovat. Vizuální návrhář se skládá z nabídky nahoře a panelu nástrojů pod ní. Na levé straně obrazovky je dlouhý panel nástrojů s paletou gadgetů (Gadget Tool Box) a panelem vlastností (Properties). Uprostřed se nachází právě navrhované rozhraní a pod ním automaticky generovaný kód.
Používání vizuálního návrháře
Podíváte-li se na obr. 32, uvidíte rozpracované rozhraní, na které ukazuje šipka vpravo. Toto okno snadno poznáte, protože je pokryto drobnými tečkami. Tyto tečky tvoří „přichytávací mřížku“ (snap grid), díky níž se umísťované gadgety přichytávají k pevné mřížce, takže je lze zarovnávat mnohem rychleji a snadněji. V hotovém programu se tyto tečky nezobrazují.

Obr. 32
Jakmile změníte velikost okna rozhraní na požadované rozměry, můžete na něj začít umísťovat gadgety. Uděláte to tak, že vyberete nástroj z palety gadgetů (Gadget Tool Box) a tímto nástrojem kreslíte na rozhraní. Přímo na okno tak kreslíte gadget zvoleného typu, jehož velikost se dynamicky mění. Jakmile gadget nakreslíte, uvidíte, že je obklopen velkými modrými tečkami. Jsou to úchyty, které vám umožňují po nakreslení měnit velikost gadgetu a přesouvat ho. Při přidávání gadgetů do rozhraní si všimnete, že se v prohlížeči kódu (Code Viewer) u dolního okraje obrazovky automaticky generuje kód v PureBasicu.
Jakmile jsou všechny gadgety umístěny a návrh uživatelského rozhraní je hotový, můžete projekt uložit klepnutím na tlačítko s disketou na panelu nástrojů. Automaticky vygenerovaný kód tak uložíte do standardního souboru PureBasicu, který pak můžete v IDE PureBasicu obvyklým způsobem otevírat, upravovat a kompilovat.
Výhody a nevýhody vizuálního návrháře
Přestože je vizuální návrhář skvělý nástroj k rychlému a snadnému sestavení uživatelských rozhraní, formát generovaného kódu nelze změnit. Musíte se proto smířit s tím, jak je program naprogramován, a pokud je potřeba provést ruční úpravy v IDE, musíte se tomuto formátu přizpůsobit. Pro zkušené uživatele PureBasicu to ve skutečnosti není problém, ale pro začátečníka může být exportovaný kód dost složitý a pokročilý.
Skutečnou předností vizuálního návrháře je rychlost. Užitečné uživatelské rozhraní dokážete sestavit během několika sekund, podívat se, jak vypadá, a pak stejně snadno přesouvat gadgety a měnit jejich velikost, dokud není vše přesně tak, jak má být. To nelze dost zdůraznit. Množství času, které můžete při navrhování uživatelského rozhraní pomocí VD ušetřit, je ohromující, jednoduše proto, že odpadá nutnost program kompilovat, abyste viděli, jak vypadá.
Někdo má vizuální návrháře rád a někdo ne, tak prosté to je. Někteří tvrdí, že je nejlepší veškerý kód psát sám, abyste skutečně věděli, co se děje „pod kapotou“, jiní zase namítají, že v dnešním konkurenčním světě potřebujete rychlé řešení pro navrhování rozhraní. Tento spor bude jistě zuřit dál, ale je jen na vás, co budete chtít používat. Nástroje jsou k dispozici a je na vás, zda je chcete používat.
Jak se dozvědět více o vizuálním návrháři
Visual Designer PureBasicu se dodává s rozsáhlou nápovědou, která pokrývá veškeré fungování VD v podobném stylu jako nápověda k IDE. Chcete-li ji zobrazit, stiskněte ve vizuálním návrháři klávesu ‘F1’ a nápověda se načte. Doporučuji přečíst si ji celou alespoň jednou.
O nové verzi vizuálního návrháře (zobrazené na obr. 32), která se v současnosti vyvíjí, si můžete přečíst a stáhnout ji z webu vizuálního návrháře PureBasicu. Internetový odkaz na něj najdete v příloze A (Užitečné internetové odkazy).
IIIGrafika a zvuk
V dnešním světě počítačových her a interaktivních aplikací jsou programy využívající grafiku a zvuk samozřejmostí. Když chcete programovat takové skvělé věci, potřebujete programovací jazyk, který vám poskytne nástroje nutné k uskutečnění vašich nápadů. PureBasic nabízí jednoduché, výkonné a plnohodnotné příkazy, s nimiž lze vytvářet hry, dema, spořiče obrazovky a další interaktivní programy profesionální kvality. V této části vám ukážu základy používání grafiky a zvuku ve vašich programech v PureBasicu.
Nejprve vysvětlím příkazy pro 2D kreslení, které umožňují kreslit jednoduché tvary, čáry a text, a pak předvedu, jak takové obrázky uložit. Poté vám ukážu, jak otevřít celoplošné grafické obrazovky, na které lze kreslit grafiku. Seznámím vás také se sprity a s tím, jak s jejich pomocí vytvářet pěkné grafické efekty.
Potom přejdeme ke 3D grafice: představím vám 3D engine, který PureBasic převzal, a ukážu základy práce s 3D grafikou v PureBasicu. Tento engine se jmenuje OGRE a jde o profesionální engine od třetí strany, který dokáže vytvářet úchvatnou grafiku a efekty.
Poslední kapitola této části se věnuje zvuku. Probírá, jak načítat a přehrávat zvuky, se zaměřením na soubory WAV, trackerové moduly, soubory MP3 a zvuková CD.
Kapitoly v této části nejsou úplnými návody, jak dosáhnout každého grafického efektu nebo jak psát hry – to přenechám jiným publikacím. Jsou tu proto, aby vás seznámily s knihovnami příkazů, které tyto věci umožňují, a poskytly vám výchozí bod, abyste mohli experimentovat a trochu se pobavit. Doufám, že vám tato část dá ochutnat, co všechno lze v PureBasicu graficky dokázat, a inspiruje vás k vytvoření nějakého skvělého dema nebo hry.
102D grafika
V této kapitole vysvětlím, jak v PureBasicu kreslit 2D grafiku. Pojem „2D grafika“ zahrnuje poměrně rozsáhlou oblast a pod tento popisný deštník spadá mnoho kreslicích operací. Když v této knize mluvím o 2D grafice, mám na mysli jednoduchou dvojrozměrnou grafiku, kterou lze kreslit na grafická uživatelská rozhraní, obrazovky, obrázky v paměti RAM nebo dokonce na tiskárnu. Tyto druhy grafiky mohou mít různou složitost – od jediného pixelu až po plnobarevný obrázek. Veškerá 2D grafika je, jak napovídá název, dvojrozměrná, na rozdíl od 3D grafiky, která zobrazuje 3D modely s třetím rozměrem – „hloubkou“.
S pomocí 2D grafiky lze dosáhnout velmi působivých vizuálních efektů, a proto v PureBasicu vzniklo mnoho her, spořičů obrazovky a dem. Doufám, že příklady z této kapitoly budete moci okopírovat, poučit se z nich a upravit je tak, abyste ve svých programech vytvořili skvělou grafiku.
Příkazy pro 2D kreslení
PureBasic obsahuje příkazy, které vám umožní kreslit ve vašich programech základní tvary a barvy. Všechny tyto jednoduché příkazy pro 2D kreslení se nacházejí v knihovně ‘2D Drawing’ (Helpfile:Reference Manual->General Libraries->2DDrawing). Hodí se ke kreslení jednoduchých tvarů a textu v různých barvách a je mezi nimi dokonce i několik příkazů pro kreslení pomocí dříve vytvořeného nebo načteného obrázku.
Na co mohu kreslit?
Vestavěné příkazy pro 2D kreslení lze použít ke kreslení na různé výstupy, například na okno grafického uživatelského rozhraní, na obrazovku PureBasicu, na sprite, na nově vytvořený obrázek v paměti, na texturu 3D modelu nebo přímo na tiskárnu. Těchto šest možností pokrývá prakticky vše, na co byste mohli potřebovat kreslit, a každá z nich se používá stejně snadno jako ostatní. Používání těchto různých výstupů je v PureBasicu triviální záležitost, protože stačí jednou určit, kam má kreslení směřovat, a pak na tento výstup kreslit pomocí kreslicích příkazů. Aby to bylo ještě jednodušší, všechny výstupy sdílejí stejnou syntaxi kreslicích příkazů.
Kreslení na okno
V tomto prvním příkladu vám ukážu, jak kreslit 2D grafiku přímo na okno. Ve skutečné aplikaci to nejspíš nikdy dělat nebudete, ale jde o jednoduché cvičení, na kterém pochopíte a naučíte se syntaxi. Podívejte se na tento kód:
#WINDOW_MAIN = 1
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN, 0, 0, 200, 240, "Window Drawing", #FLAGS)
If StartDrawing(WindowOutput(#WINDOW_MAIN))
Box(15, 15, 75, 75, RGB(255, 0, 0))
Circle(140, 125, 45, RGB(35, 158, 70))
;The next 2D drawing commands draw a triangle
LineXY(62, 140, 112, 220, RGB(0, 0, 255))
LineXY(112, 220, 12, 220, RGB(0, 0, 255))
LineXY(12, 220, 62, 140, RGB(0, 0, 255))
FillArea(62, 180, RGB(0, 0, 255), RGB(0, 0, 255))
StopDrawing()
EndIf
Repeat
Event.l = WaitWindowEvent()
Until Event = #PB_Event_CloseWindow
EndIf
End
Když výše uvedený příklad spustíte, otevře se okno podobné obr. 33 a na něm bude nakreslen červený čtverec, zelený kruh a modrý trojúhelník. Tyto tvary jsou nakresleny přímo na samotné okno a nejsou při tom použity žádné gadgety. Abyste výše uvedenému kódu plně porozuměli, musím syntaxi kreslicích příkazů vysvětlit podrobněji.

Obr. 33
Nejprve si všimněte, že jsem použil nový příkaz ‘StartDrawing()’. Tento příkaz sděluje PureBasicu, že chci začít kreslit pomocí příkazů pro 2D grafiku, a určuje, na co mají kreslicí příkazy kreslit. Podíváte-li se na stránku nápovědy k příkazu ‘StartDrawing()’ (Helpfile:Reference Manual->General Libraries->2DDrawing->StartDrawing), uvidíte, že tento příkaz může jako parametr přijmout šest jiných příkazů, které určují způsob výstupu kreslení. Jsou to:
‘WindowOutput()’ Slouží ke kreslení na okna uživatelského rozhraní PureBasicu. Tento výstup vyžaduje jako parametr PB číslo, které určuje, na jaké okno se má kreslit.
‘ScreenOutput()’ Slouží ke kreslení přímo na obrazovku PureBasicu.
‘SpriteOutput()’ Slouží ke kreslení na sprite PureBasicu. Tento výstup vyžaduje jako parametr PB číslo, které určuje, na jaký sprite se má kreslit.
‘ImageOutput()’ Slouží ke kreslení na načtený nebo nově vytvořený obrázek v paměti. Tento výstup vyžaduje jako parametr PB číslo, které určuje, na jaký obrázek se má kreslit.
‘PrinterOutput()’ Slouží ke kreslení přímo na tiskárnu.
‘TextureOutput()’ Slouží ke kreslení na texturu 3D modelu. Tento výstup vyžaduje jako parametr PB číslo, které určuje, na jakou texturu se má kreslit.
V mém příkladu jsem určil, že chci začít kreslit na okno, a to takto:
...
StartDrawing(WindowOutput(#WINDOW_MAIN))
...
Jakmile takto nastavím výstup kreslení, mohu na něj volně kreslit kterýmkoli z příkazů pro 2D kreslení. Jinými slovy, vše, co příkazy pro 2D kreslení nakreslí, se nyní nakreslí na okno určené parametrem příkazu ‘WindowOutput’. Jakmile použijete příkaz ‘StartDrawing()’, musíte kreslicí operace vždy ukončit příkazem ‘StopDrawing()’. Ten sděluje kompilátoru PureBasicu, že už nechci používat příkazy pro 2D kreslení a chci normálně pokračovat ve zbytku programu. To je nezbytné, protože pokud kompilátoru neoznámíte, že jste přestali kreslit, může to ve vašem programu způsobit chyby.
Uvnitř kreslicího bloku jsem ke skutečnému nakreslení tvarů na okno použil čtyři příkazy pro 2D kreslení. Jsou to ‘Box()’, ‘Circle()’, ‘LineXY()’ a ‘FillArea()’. Všechny tyto příkazy pro 2D kreslení jsou podrobně vysvětleny na stránkách, na něž vedou odkazy ze stránky nápovědy ‘2D Drawing’ (Helpfile:Reference Manual- >General Libraries->2DDrawing). Téměř všechny 2D příkazy mají podobné parametry. Obvykle mají parametry pro pozici ‘x’ a ‘y’, někdy různé parametry velikosti a posledním parametrem bývá obvykle barva, kterou má tvar mít. Vezmeme-li například příkaz ‘Box()’, první dva parametry udávají pozici obdélníku na výstupu. Třetí a čtvrtý parametr udávají šířku a výšku obdélníku a pátý parametr jeho barvu.
Práce s barvami
Barvy se v PureBasicu zadávají jedinou 24bitovou hodnotou barvy. Tato hodnota je velké číslo, které představuje různé kombinace červené, zelené a modré. Abychom získali 24bitovou hodnotu barvy, musíme použít příkaz ‘RGB()’. Tento příkaz přijímá tři parametry, které jednotlivě určují hodnoty červené, zelené a modré složky. Každý z těchto parametrů má rozsah hodnot od ‘0’ do ‘255’. Díky tomu může příkaz ‘RGB()’ vrátit přes 16,7 milionu barev v podobě jednotlivých 24bitových hodnot. Takto jsem ho použil v příkladu s kreslením na okno z obr. 33:
...
Box(15, 15, 75, 75, RGB(255, 0, 0))
...
Zde jsem příkaz ‘RGB()’ použil přímo jako parametr příkazu ‘Box()’. Když se podíváte pozorně, uvidíte, že jsem pro parametr červené složky zadal maximální hodnotu a pro parametry zelené a modré nejnižší hodnotu ‘0’. To znamená, že příkaz ‘RGB()’ vrátí 24bitovou hodnotu popisující plnou červenou barvu, která není smíchána s žádnou zelenou ani modrou. Totéž platí pro trojúhelník:
...
LineXY(62, 140, 112, 220, RGB(0, 0, 255))
LineXY(112, 220, 12, 220, RGB(0, 0, 255))
LineXY(12, 220, 62, 140, RGB(0, 0, 255))
FillArea(62, 180, RGB(0, 0, 255), RGB(0, 0, 255))
...
Tyto čtyři řádky tvoří modrý trojúhelník nakreslený na okně na obr. 33. První tři jsou příkazy ‘LineXY()’, které kreslí tři strany trojúhelníku. Poslední je příkaz ‘FillArea()’, který vybere bod uprostřed trojúhelníku a vyplní ho stejnou barvou, jakou mají strany. Vidíte, že barva je ve všech čtyřech kreslicích příkazech stejná. První a druhý parametr příkazu ‘RGB()’, představující červenou a zelenou, mají hodnotu ‘0’, zatímco třetí parametr, představující modrou, má hodnotu ‘255’. To znamená, že příkaz ‘RGB()’ zde vrátí 24bitovou hodnotu popisující plnou modrou barvu, která není smíchána s žádnou červenou ani zelenou. Zelený kruh na obr. 33 je trochu jiný, protože k dosažení požadované barvy používám všechny tři složky, a to takto:
...
Circle(140, 125, 45, RGB(35, 158, 70))
...
Zde jsem použil směs hodnot červené, zelené a modré, abych místo plné jasně zelené získal pěknou trávově zelenou. Takové zadávání barev dělá v PureBasicu věci jednoduchými a pro začátečníky velmi snadno pochopitelnými. Pomocí příkazu ‘RGB()’ můžete získat téměř jakoukoli barvu, kterou lidské oko dokáže rozlišit.
Zatímco příkaz ‘RGB()’ přijímá hodnoty červené, zelené a modré a vrací kombinovanou 24bitovou hodnotu, může nastat situace, kdy budete chtít z jediné 24bitové hodnoty barvy naopak získat hodnoty jednotlivých složek – červené, zelené a modré. V takovém případě k tomu můžete použít příkazy ‘Red()’, ‘Green()’ a ‘Blue()’. Podívejte se na tento příklad:
ColorValue.l = RGB(35, 158, 70)
Debug "The 24 bit color value is made up of: "
Debug "Red: " + Str(Red(ColorValue))
Debug "Green: " + Str(Green(ColorValue))
Debug "Blue: " + Str(Blue(ColorValue))
Každý z příkazů ‘Red()’, ‘Green()’ a ‘Blue()’ přijímá jako parametr jednu 24bitovou hodnotu barvy a vrací hodnotu odpovídající barevné složky. Na prvním řádku výše uvedeného příkladu skládám 24bitovou hodnotu barvy mimo jiné s hodnotou červené složky ‘35’. Kdybych chtěl později z této 24bitové hodnoty barvy získat zpět hodnotu červené složky, mohl bych ji předat příkazu ‘Red()’, který vrátí hodnotu červené složky použitou při jejím skládání, v tomto případě ‘35’. Ostatní příkazy pro barvy fungují úplně stejně.
Proč není kreslení na okna vhodné
Kreslení na okna sice je možné, ale nemusí to být správný způsob zobrazování grafiky nakreslené příkazy pro 2D kreslení. Je to hlavně kvůli tomu, jak různé operační systémy řeší překreslování obsahu oken. Pokud například v Microsoft Windows nakreslíte grafiku přímo na okno a pak přes něj přesunete jiné okno, grafika z původního okna zmizí. Důvodem je interní zpracování událostí, které v Microsoft Windows probíhá. Systém rozhoduje, zda obsah okna automaticky překreslí, či nikoli, a někdy se rozhodne, že ne. Překreslení grafiky poté, co přes okno přejelo jiné okno, si sice můžete vynutit, ale to už je pokročilá záležitost, která vyžaduje znalost API konkrétního operačního systému, s nímž pracujete. Elegantnějším způsobem zobrazení nakreslené grafiky je vytvořit v paměti nový obrázek, nakreslit na něj, co potřebujete, a pak tento obrázek zobrazit v okně pomocí obrázkového gadgetu. Použití obrázkového gadgetu zajistí, že se okno automaticky postará o veškeré překreslování, které je potřeba k tomu, aby obrázek zůstal viditelný.
Kreslení na obrázek
Práce s novými obrázky je v PureBasicu snadná, protože k vytváření a úpravám obrázků slouží celá samostatná knihovna. V následujícím příkladu se pokusím napodobit předchozí program, ale s jedním rozdílem. Pomocí příkazu ‘CreateImage()’ vytvořím nový obrázek, nakreslím na něj barevné tvary a hotový výsledek pak zobrazím v obrázkovém gadgetu. Tím bychom se měli vyhnout jakýmkoli problémům s překreslováním okna a program by se měl chovat tak, jak očekáváme. O příkazech pro práci s obrázky, které PureBasic obsahuje, si můžete přečíst více na stránce knihovny ‘Image’ v nápovědě (Helpfile:Reference Manual->General Libraries->Image). Zde je náš příklad:
Enumeration
#WINDOW_MAIN
#IMAGE_GADGET
#IMAGE_MAIN
EndEnumeration
If CreateImage(#IMAGE_MAIN, 180, 220)
If StartDrawing(ImageOutput(#IMAGE_MAIN))
;Because a new image has a Black background, draw a white one instead:
Box(0, 0, 180, 220, RGB(255, 255, 255))
;Now, continue drawing the shapes:
Box(5, 5, 75, 75, RGB(255, 0, 0))
Circle(130, 115, 45, RGB(35, 158, 70))
LineXY(52, 130, 102, 210, RGB(0, 0, 255))
LineXY(102, 210, 2, 210, RGB(0, 0, 255))
LineXY(2, 210, 52, 130, RGB(0, 0, 255))
FillArea(52, 170, RGB(0, 0, 255), RGB(0, 0, 255))
StopDrawing()
EndIf
EndIf
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN, 0, 0, 200, 240, "Drawing On A New Image", #FLAGS)
If CreateGadgetList(WindowID(#WINDOW_MAIN))
ImageGadget(#IMAGE_GADGET, 10, 10, 180, 220, ImageID(#IMAGE_MAIN))
Repeat
Event.l = WaitWindowEvent()
Until Event = #PB_Event_CloseWindow
EndIf
EndIf
End
Většina tohoto kódu by měla být zřejmá sama o sobě, protože jediný rozdíl oproti předchozímu příkladu spočívá v tom, že nyní příkazem ‘CreateImage()’ vytváříme nový obrázek a kreslíme na něj místo na okno. Příkaz ‘CreateImage()’ přijímá čtyři parametry: první je PB číslo přiřazené tomuto novému obrázku. Druhý a třetí udávají šířku a výšku nového obrázku (v pixelech) a čtvrtý parametr je barevná hloubka nového obrázku, která je nepovinná. Pokud čtvrtý parametr nepoužijete, jako v mém příkladu, použije se stejná barevná hloubka, jakou má vaše plocha.
Po vytvoření nového obrázku sdělím programu, že na něj chci kreslit, tímto řádkem:
...
StartDrawing(ImageOutput(#IMAGE_MAIN))
...
Zde jsem pomocí příkazu ‘StartDrawing()’ s výstupem ‘ImageOutput()’ určil, že všechny kreslicí příkazy mají nyní kreslit na obrázek, jehož PB číslo je ‘#IMAGE_MAIN’.
Tento způsob určení obrázku, na který se má kreslit, není omezen jen na nově vytvořené obrázky. Stejně tak můžete do programu načíst obrázek a kreslit i na něj. Pokud má obrázek přiřazené PB číslo, můžete na něj nastavit výstup kreslení.
Jakmile je obrázek vytvořen a výstup kreslení nastaven, mohu na obrázek volně kreslit. Protože všechny nově vytvořené obrázky mají v PureBasicu na začátku černé pozadí, musí být mou první kreslicí operací vybarvení pozadí na bílo. Udělám to příkazem ‘Box()’, který nakreslí bílý obdélník stejně velký jako samotný nový obrázek a zakryje tak všechnu černou. Poté nakreslím čtverec, kruh a trojúhelník jako předtím. Po dokončení všech potřebných kreslicích operací zavolám nesmírně důležitý příkaz ‘StopDrawing()’.
Abych tento obrázek zobrazil správně a vyhnul se dřívějším problémům s překreslováním při kreslení přímo na okno, použiji obrázkový gadget. Díky tomu se o překreslování obsahu gadgetu, když přes něj přejedou jiná okna apod., postará operační systém.
Změna režimu kreslení
V dalším příkladu vám ukážu, jak změnit režim kreslení u některých příkazů včetně textu. Pomocí příkazu ‘DrawingMode()’ můžete u příkazů pro tvary přepnout do režimu obrysů, kreslit text s průhledným pozadím nebo dokonce výstup kreslicího příkazu smíchat (XOr) s pozadím. Zde je příklad s režimy kreslení:
Enumeration
#WINDOW_MAIN
#IMAGE_GADGET
#IMAGE_MAIN
#FONT_MAIN
EndEnumeration
Global ImageWidth = 401
Global ImageHeight = 201
Global XPos.l, YPos.l, Width.l, Height.l, Red.l, Green.l, Blue.l
Global Text.s = "PureBasic - 2D Drawing Example"
Procedure.l MyRandom(Maximum.l)
Repeat
Number.l = Random(Maximum)
Until (Number % 10) = 0
ProcedureReturn Number
EndProcedure
If CreateImage(#IMAGE_MAIN, ImageWidth, ImageHeight)
If StartDrawing(ImageOutput(#IMAGE_MAIN))
For x.l = 0 To 1500
XPos.l = MyRandom(ImageWidth) + 1
YPos.l = MyRandom(ImageHeight) + 1
Width.l = (MyRandom(100) - 1) + 10
Height.l = (MyRandom(100) - 1) + 10
Red.l = Random(255)
Green.l = Random(255)
Blue.l = Random(255)
Box(XPos, YPos, Width, Height, RGB(Red, Green, Blue))
DrawingMode(#PB_2DDrawing_Outlined)
Box(XPos - 1, YPos - 1, Width + 2, Height + 2, RGB(0, 0, 0))
DrawingMode(#PB_2DDrawing_Default)
Next x
LineXY(ImageWidth - 1, 0, ImageWidth - 1, ImageHeight, RGB(0, 0, 0))
LineXY(0, ImageHeight - 1, ImageWidth, ImageHeight - 1, RGB(0, 0, 0))
Box(10, 10, 230, 30, RGB(90, 105, 134))
DrawingMode(#PB_2DDrawing_Outlined)
Box(10, 10, 231, 31, RGB(0, 0, 0))
DrawingMode(#PB_2DDrawing_Transparent)
DrawText(21, 18, Text, RGB(0, 0, 0))
DrawText(19, 18, Text, RGB(0, 0, 0))
DrawText(21, 16, Text, RGB(0, 0, 0))
DrawText(19, 16, Text, RGB(0, 0, 0))
DrawText(20, 17, Text, RGB(255, 255, 255))
StopDrawing()
EndIf
EndIf
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN,0,0,ImageWidth+20,ImageHeight+20,"Abstract",#FLAGS)
If CreateGadgetList(WindowID(#WINDOW_MAIN))
ImageGadget(#IMAGE_GADGET,10,10,ImageWidth,ImageHeight,ImageID(#IMAGE_MAIN))
EndIf
Repeat
Event.l = WaitWindowEvent()
Until Event = #PB_Event_CloseWindow
EndIf
End
Tento příklad je v podstatě rozšířenou verzí předchozího: vytvořím v něm nový, i když o něco větší obrázek a nakreslím po celé jeho ploše náhodné obdélníky. U každého nakresleného obdélníku přepnu režim kreslení na obrysy a nakreslím přes něj černý obrys stejných rozměrů. Díky tomu obdélníky opravdu vyniknou. Každý obdélník má nejen náhodnou barvu, ale i černý obrys. K přepínání režimů během kreslení slouží příkaz ‘DrawingMode()’ spolu s jednou z několika různých konstant, která se použije jako parametr. Zde jsou tyto konstanty a jejich účinek:
‘#PB_2DDrawing_Default’ Výchozí režim: text se zobrazuje s plnou barvou pozadí a grafické tvary jsou vyplněné.
‘#PB_2DDrawing_Outlined’ Tento režim zapíná u příkazů pro tvary, jako jsou ‘Box()’, ‘Circle()’ a ‘Ellipse()’, kreslení obrysů.
‘#PB_2DDrawing_Transparent’ Nastaví pozadí textu jako průhledné, takže se použije pouze parametr barvy popředí příkazu ‘DrawText()’.
‘#PB_2DDrawing_XOr’ Tento režim zapíná režim XOr, což znamená, že veškerá grafika se s aktuálním pozadím kombinuje operací XOR.
Používání tohoto příkazu je velmi snadné. Když chcete uvnitř bloku příkazu ‘StartDrawing()’ změnit režim kreslení, stačí tento příkaz zavolat s vybranou konstantou jako parametrem a režim se okamžitě změní. Tyto konstanty lze také kombinovat pomocí bitového operátoru ‘Or’. Projděte si kód a uvidíte, že jsem režimy přepínal poměrně často.
Po spuštění tohoto příkladu uvidíte okno velmi podobné obr. 34, na němž jsou barevné obdélníky s černými obrysy a v levém horním rohu bílý text.

Obr. 34 — (příklad v Microsoft Windows)
Při kreslení textu na obrázek jsem použil režim kreslení ‘#PB_2DDrawing_Transparent’, takže text má místo plné barvy průhledné pozadí. K samotnému vykreslení textu jsem použil příkaz ‘DrawText()’. Ten přijímá pět parametrů: pozici ‘x’ a ‘y’ na výstupu, řetězec, který se má vykreslit, a hodnoty barvy popředí a pozadí. Protože jsem použil průhledné pozadí, pátý parametr se ignoruje.
Obrysu textu jsem dosáhl tak, že jsem nakreslil čtyřikrát černý text s různými posuny a teprve navrch bílý text. Udělal jsem to takto proto, že režim kreslení ‘#PB_2DDrawing_Outlined’ zatím text nepodporuje.
Kreslení textu
Text se na výstup kreslí příkazem ‘DrawText()’ (Helpfile:Reference Manual- >General Libraries->2DDrawing->DrawText). V předchozím příkladu vidíte, že jsem tento příkaz použil několikrát. První a druhý parametr udávají umístění ‘x’ a ‘y’ kresleného textu na výstupu. Třetí parametr je samotný řetězec textu, který se má vykreslit. Čtvrtý a pátý parametr jsou barvy popředí a pozadí textu. Barvou popředí se rozumí vlastní barva textu a barvou pozadí barva podkladu. Pokud poslední dva nepovinné parametry nepoužijete, převezmou se informace o barvách z výchozích hodnot, které lze změnit příkazy ‘FrontColor()’ a ‘BackColor()’. Tyto parametry barev jsou 24bitové hodnoty barev, které snadno složíte pomocí příkazu ‘RGB()’.
Kreslení pomocí obrázku
V několika předchozích příkladech jsem předvedl, jak kreslit jednoduché tvary a čáry pomocí vestavěných příkazů pro 2D kreslení, ty však mohou být někdy trochu omezující. V dalším příkladu vám ukážu, jak můžete vzít externí obrázek a nakreslit ho na jiný, nově vytvořený obrázek, a to na libovolnou pozici.
Enumeration
#WINDOW_MAIN
#IMAGE_GADGET
#IMAGE_SMALL
#IMAGE_MAIN
#FONT_MAIN
EndEnumeration
Global ImageWidth = 400
Global ImageHeight = 200
Global XPos.l, YPos.l, LoadedImageWidth.l, LoadedImageHeight.l
Global File.s
Global RequesterText.s = "Choose an image"
Global DefaultFile.s = ""
Global Pattern.s = "Bitmap (*.bmp)|*.bmp|Icon (*.ico)|*.ico"
File = OpenFileRequester(RequesterText, DefaultFile, Pattern, 0)
If File
LoadImage(#IMAGE_SMALL, File)
LoadedImageWidth = ImageWidth(#IMAGE_SMALL)
LoadedImageHeight = ImageHeight(#IMAGE_SMALL)
If CreateImage(#IMAGE_MAIN, ImageWidth,ImageHeight)
If StartDrawing(ImageOutput(#IMAGE_MAIN))
Box(0, 0,ImageWidth, ImageHeight, RGB(255, 255, 255))
For x.l = 1 To 1000
XPos = Random(ImageWidth) - (ImageWidth(#IMAGE_SMALL) / 2)
YPos = Random(ImageHeight) - (ImageHeight(#IMAGE_SMALL) / 2)
DrawImage(ImageID(#IMAGE_SMALL), XPos, YPos)
Next x
DrawingMode(#PB_2DDrawing_Outlined)
Box(0, 0, ImageWidth, ImageHeight, RGB(0, 0, 0))
StopDrawing()
EndIf
EndIf
#TEXT = "Drawing Using Images"
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN,0,0,ImageWidth+20,ImageHeight+20,#TEXT,#FLAGS)
If CreateGadgetList(WindowID(#WINDOW_MAIN))
ImageGadget(#IMAGE_GADGET,10,10,ImageWidth,ImageHeight,ImageID(#IMAGE_MAIN))
EndIf
Repeat
Event.l = WaitWindowEvent()
Until Event = #PB_Event_CloseWindow
EndIf
End
EndIf
Ve výše uvedeném kódu umožňuji uživateli otevřít obrázek ve formátu Bitmap nebo Icon pomocí příkazu ‘OpenFileRequester()’. Jakmile tento dialog správně vrátí název souboru s obrázkem, načtu tento soubor příkazem ‘LoadImage()’, velmi podobně jako v příkladu s obrázkovým gadgetem v kapitole 9. Po načtení souboru mohu vytvořit nový obrázek, na který budu kreslit, a příkazem ‘DrawImage()’ na něj načtený obrázek mnohokrát nakreslit. Výsledný obrázek se zobrazí v okně pomocí obrázkového gadgetu. Na obr. 35 vidíte, jak to vypadá poté, co jsem načetl ikonu ve tvaru koule, která se pak náhodně nakreslí po celé ploše nového obrázku a ten se zobrazí.

Obr. 35 — (příklad v Microsoft Windows)
Chcete-li nakreslit načtený obrázek na nově vytvořený obrázek, použijete příkaz ‘DrawImage()’. Tento příkaz přijímá pět parametrů a je velmi snadno pochopitelný. Prvním je identifikátor OS obrázku, kterým chcete kreslit; ten lze získat příkazem ‘ImageID()’. Druhý a třetí parametr udávají vodorovnou a svislou pozici kresleného obrázku v pixelech. Čtvrtý a pátý parametr jsou nepovinné a zde jsem je nepoužil; udávají šířku a výšku kresleného obrázku v pixelech. Použijete je, pokud potřebujete obrázek před nakreslením dynamicky změnit velikost. V mém příkladu jsem většinu parametrů nastavil náhodně, aby se nový obrázek náhodně zaplnil tisícem kopií načteného obrázku.
Myslím také, že příkaz ‘OpenFileRequester()’ vidíte poprvé, takže ho pro jistotu vysvětlím trochu podrobněji, aby nevznikly nejasnosti. Tento příkaz otevře standardní dialog operačního systému pro výběr souboru, v němž uživatel snadno vybere soubor. Jakmile je soubor vybrán, vrátí příkaz ‘OpenFileRequester()’ jeho název jako řetězec. Ukazuje to tento malý samostatný úryvek kódu:
Global File.s
Global RequesterText.s = "Choose an image"
Global DefaultFile.s = ""
Global Pattern.s = "Bitmap (*.bmp)|*.bmp|Icon (*.ico)|*.ico"
File = OpenFileRequester(RequesterText, DefaultFile, Pattern, 0)
Debug File
Podíváte-li se na stránku ‘OpenFileRequester()’ v nápovědě (Helpfile:Reference Manual->General Libraries->Requester->OpenFileRequester), zjistíte, že tento příkaz přijímá čtyři parametry. Prvním je řetězec, který se po otevření dialogu zobrazí v jeho titulkovém pruhu. Druhým je řetězcový parametr s názvem souboru, který může dialog hledat. Je-li tento parametr zadán, bude tento název souboru po otevření dialogu již vyplněn ve výběrovém poli. Třetím parametrem je vzor souborů, kterým programátor určí, které soubory se mají a které nemají v dialogu nabízet k výběru. Čtvrtý parametr určuje, který typ souboru ze vzoru bude po otevření dialogu vybrán jako první. V tomto úryvku je jako první vybrán ‘Bitmap’, protože indexování vzoru souborů začíná od ‘0’.
Vzor souborů vypadá dost složitě, ale jakmile ho pochopíte, je velmi jednoduchý. Typy souborů jsou v řetězci vzoru rozděleny na úseky, oddělené svislými čarami ‘|’, tedy stejným znakem jako bitový operátor Or. Tyto úseky fungují ve dvojicích: první určuje řetězec popisující příponu souboru a druhý samotnou příponu. Například ve výše uvedeném úryvku vypadá vzor takto:
"Bitmap (*.bmp)|*.bmp|Icon (*.ico)|*.ico"
Když ho rozdělíme na úseky s použitím svislých čar jako oddělovačů, uvidíme jasněji, co je zadáno:
Bitmap (*.bmp) *.bmp Icon (*.ico) *.ico
První úsek je řetězec, který se zobrazí ve výběrovém poli ‘Files of type’ (typ souborů) v dialogu, a když je vybrán, použije se další úsek, který dialogu sdělí, jaký typ souborů má zobrazit v hlavním okně, v tomto případě všechny soubory ‘.bmp’. Nezapomeňte, že hvězdička je zde zástupný znak řetězce, který označuje libovolný název. Třetí úsek je další řetězec, který se zobrazí ve výběrovém poli ‘Files of type’, a když je vybrán, zobrazí dialog soubory s příponou uvedenou ve čtvrtém úseku, a tak dále. Potřebujete-li pro jeden konkrétní typ souborů zadat více přípon, můžete je v rámci jednoho úseku oddělit středníkem, takto:
"JPEG|*.jpg;*.jpeg"
Nyní se, když je v dialogu vybrán řetězec ‘JPEG’, zobrazí všechny soubory s příponou ‘.jpg’ nebo ‘.jpeg’. Musíte pamatovat na to, že pokud chcete načítat i jiné typy obrázků než Bitmap nebo Icon, budete muset použít další dekodér obrázků, jak je vysvětleno v kapitole 9 (Začlenění grafiky do programu).
Kreslení obrázků s alfa kanálem
Někdy můžete potřebovat nakreslit obrázek, který obsahuje alfa kanál, aby se zachoval vržený stín nebo aby byly některé části obrázku průhledné. Na obr. 35 jsem ke kreslení po celé ploše nově vytvořeného obrázku použil ikonu a PureBasic standardně zachovává veškeré informace alfa kanálu, které v ikoně najde. Co se ale stane, když potřebujete nakreslit obrázek ve formátu Png nebo Tiff a zachovat jeho alfa kanál? K tomu slouží příkaz ‘DrawAlphaImage()’. Tento příkaz zachová alfa kanál v obrazových formátech, které ho podporují, například v 32bitových souborech Png nebo Tiff.
Příkaz ‘DrawAlphaImage()’ se používá úplně stejně jako příkaz ‘DrawImage()’; jediný rozdíl je v tom, že příkaz ‘DrawAlphaImage()’ má pouze tři parametry, a proto neumožňuje dynamicky měnit velikost obrázku při kreslení. Zde je příklad, jak lze tento příkaz použít:
...
DrawAlphaImage(ImageID(#IMAGE_PNG), XPos, YPos)
...
Výše uvedený řádek by zobrazil obrázek ve formátu Png se zachováním jeho alfa kanálu, takže by se pěkně prolnul s jakýmkoli pozadím. Jednu věc si však vždy pamatujte: při načítání obrázků v jiném formátu než Bitmap nebo Icon musíte použít příslušný příkaz dekodéru, který tuto funkčnost do programu přidá, jak je vysvětleno v kapitole 9.
Ukládání obrázků
Jakmile v programu vytvoříte obrázek, možná ho budete chtít uložit na disk. PureBasic tento úkol usnadňuje příkazem ‘SaveImage()’ (Helpfile:Reference Manual->General Libraries->Image->SaveImage). Tento příkaz uloží jakýkoli obrázek ve vašem programu v PureBasicu, který má PB číslo. Příkaz ‘SaveImage()’ přijímá čtyři parametry. Prvním je PB číslo obrázku, který chcete uložit. Druhým je název souboru, pod nímž chcete obrázek uložit. Třetí parametr je nepovinný a určuje, v jakém obrazovém formátu se má obrázek uložit. Čtvrtý parametr slouží k zadání nepovinné hodnoty, která se použije se zvoleným formátem souboru.
Kdybychom chtěli uložit obrázek vytvořený v předchozím příkladu, mohli bychom na konec kódu příkladu přidat tento řádek. Po skončení programu by se náš obrázek uložil:
...
SaveImage(#IMAGE_MAIN, "Image.bmp")
...
Pokud tento příkaz použijete bez posledních dvou nepovinných parametrů, uloží PureBasic ve výchozím nastavení soubor obrázku ve formátu Bitmap. Název souboru tedy bude při ukládání muset mít správnou příponu (*.bmp).
Ukládání obrázků v jiných formátech
Obrázky můžete ukládat i v jiných grafických formátech, pokud formát zadáte jako třetí parametr. Může jít o jednu z těchto tří vestavěných konstant:
‘#PB_ImagePlugin_BMP’ Uloží obrázek ve formátu Bitmap. Jde o výchozí nastavení, které vlastně není nutné zadávat.
‘#PB_ImagePlugin_JPEG’ Uloží obrázek ve formátu Jpeg. (Aby to správně fungovalo, musí být před použitím tohoto příkazu zavolán příkaz ‘UseJPEGImageEncoder()’.)
‘#PB_ImagePlugin_PNG’ Uloží obrázek ve formátu Png. (Aby to správně fungovalo, musí být před použitím tohoto příkazu zavolán příkaz ‘UsePNGImageEncoder()’.)
Při ukládání obrázku s konstantou ‘#PB_ImagePlugin_JPEG’ nebo ‘#PB_ImagePlugin_PNG’ musíte před použitím příkazu ‘SaveImage()’ umístit na začátek zdrojového kódu příslušný příkaz kodéru, aby program věděl, jak daný formát zakódovat. Kodéry stačí zavolat jen jednou a požadovaná funkčnost se tím přidá do celého programu. Jsou to:
‘ UseJPEGImageEncoder()’ Tento kodér přidává podporu formátu souborů obrázků Jpeg (.jpg/.jpeg).
‘ UsePNGImageEncoder()’ Tento kodér přidává podporu formátu souborů obrázků Png (*.png).
Když pomocí ‘ UseJPEGImageEncoder()’ přidáte podporu formátu Jpeg, můžete volitelně použít čtvrtý parametr příkazu ‘SaveImage()’ k zadání míry komprese ukládaného obrázku. Jde o jediný typ obrázku, který tento čtvrtý parametr v současnosti podporuje.
Zde je několik příkladů použití příkazu ‘SaveImage()’:
SaveImage(#IMAGE_MAIN, "Image.bmp")
Tento první příklad uloží obrázek s názvem ‘Image.bmp’ ve výchozím 24bitovém formátu Bitmap. Všimněte si, že není potřeba žádný kodér, protože PureBasic obrázky ve formátu Bitmap podporuje standardně.
UseJPEGImageEncoder()
...
SaveImage(#IMAGE_MAIN, "Image.jpg", #PB_ImagePlugin_JPEG)
Druhý příklad uloží obrázek s názvem ‘Image.jpg’ ve formátu JPEG s výchozí hodnotou komprese ‘7’, protože jsme žádnou sami nezadali.
UseJPEGImageEncoder()
...
SaveImage(#IMAGE_MAIN, "Image.jpg", #PB_ImagePlugin_JPEG, 10)
Tento třetí příklad uloží obrázek s názvem ‘Image.jpg’ ve formátu JPEG a použije maximální hodnotu komprese ‘10’ zadanou ve čtvrtém parametru.
UsePNGImageEncoder()
...
SaveImage(#IMAGE_MAIN, "Image.png", #PB_ImagePlugin_PNG)
Tento čtvrtý příklad uloží obrázek s názvem ‘Image.png’ ve formátu PNG.
Seznámení s obrazovkami (screens)
Pokud jste někdy chtěli v PureBasicu vytvořit vlastní hru nebo napsat vlastní spořič obrazovky, vždy začnete otevřením obrazovky (‘Screen’). Tato obrazovka je čistě grafické prostředí, vytvořené s jediným účelem: zobrazovat grafiku, například výstup 2D kreslení, načtené obrázky, načtené sprity a načtené 3D modely a světy.
Obrazovky se obvykle otevírají tak, že zabírají celou šířku a výšku vašeho monitoru, ale pokud to potřebujete, můžete obrazovku otevřít i v již vytvořeném okně. Takové obrazovce se říká obrazovka v okně (Windowed Screen). Současně může být otevřen pouze jeden typ obrazovky – buď jedna celoobrazovková, nebo jedna obrazovka v okně.
Důvodem, proč se k zobrazování grafiky při tvorbě her a podobně dává přednost obrazovkám (místo prostého kreslení na okna), je to, že obrazovky jsou rychlé, ...velmi rychlé! Na každé platformě, pro kterou je PureBasic k dispozici, jsou jeho obrazovky optimalizovány tak, aby poskytovaly co nejvyšší výkon bez ohledu na to, jaký operační systém běží pod nimi.
Otevření první obrazovky
K vytvoření a otevření obrazovky v PureBasicu musíte dodržet základní šablonu kódu. Práce s obrazovkami a se sprity spolu velmi úzce souvisí, takže před otevřením obrazovky musíte vždy inicializovat engine spritů. Tím zajistíte, že se interně vše správně inicializuje a obrazovka bude připravena na kreslicí operace. Jakmile je engine spritů inicializován a obrazovka skutečně otevřena, potřebujete hlavní cyklus, který udržuje program v chodu, stejně jako u programu s grafickým uživatelským rozhraním.
Níže uvedený kód ukazuje kostru programu s obrazovkou, která obsahuje všechny zásadní části kódu: inicializaci enginu spritů, otevření obrazovky, vytvoření hlavního cyklu a inicializaci příkazů pro klávesnici, které poskytují způsob, jak program ukončit.
Global Quit.b = #False
;Simple error checking procedure
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
HandleError(InitSprite(), "InitSprite() command failed.")
HandleError(InitKeyboard(), "InitKeyboard() command failed.")
HandleError(OpenScreen(1024, 768, 32, "Fullscreen"), "Could not open screen.")
Repeat
ClearScreen(RGB(0, 0, 0))
;Drawing operations go here
FlipBuffers(2)
ExamineKeyboard()
If KeyboardReleased(#PB_Key_Escape)
Quit = #True
EndIf
Until Quit = #True
End
Podíváte-li se nejprve do oddílu o spritech a obrazovkách v nápovědě PureBasicu (Helpfile:Reference Manual->2D Games Libraries->Sprite & Screen), najdete tam další informace o všech nových příkazech použitých v tomto příkladu.
Tento příklad vlastně nedělá nic jiného, než že otevře prázdnou obrazovku; pokud se na ni právě díváte, můžete program ukončit stisknutím klávesy ‘Esc’. Z tohoto příkladu se rodí všechny hry a podobné programy, takže mi dovolte projít jeho důležité části a průběžně vysvětlit, co se děje.
Nejprve jsem vytvořil jednoduchou proceduru pro kontrolu chyb, jak je vysvětleno v kapitole 8 (Jak minimalizovat a ošetřovat chyby), a pomocí ní ověřuji, že příkazy ‘InitSprite()’, ‘InitKeyboard()’ a ‘OpenScreen()’ nevrátí ‘0’. Pokud kterýkoli z nich ano, považuje se daný příkaz za neúspěšný, a proto program okamžitě ukončím. Pokud k takovému selhání z jakéhokoli důvodu dojde, je vždy nejlepší program zavřít a uživatele o problému informovat. Kdyby program jinak pokračoval, pravděpodobně by došlo k vážným pádům.
Příkazy potřebné k inicializaci enginu spritů a klávesnice jsou jen jednoduchá volání příkazů, a to ‘InitSprite()’ a ‘InitKeyboard()’; pamatujte, že engine spritů musíme inicializovat před otevřením obrazovky. Příkaz ‘OpenScreen()’ přijímá čtyři parametry: šířku, výšku a barevnou hloubku obrazovky a navíc její textový popisek. Tento popisek se zobrazí na hlavním panelu, pokud obrazovku minimalizujete.
Parametry šířky, výšky a barevné hloubky je velmi důležité zadat správně, protože určují, jakou velikost a barevnou hloubku bude vaše obrazovka mít. Jakýkoli počítač, na kterém tento program poběží a otevře tuto obrazovku, musí použitou velikost a barevnou hloubku podporovat. Hodnoty šířky a výšky se souhrnně nazývají rozlišení a to musí být plně podporováno grafickou kartou i monitorem připojeným k cílovému počítači, jinak dojde k chybě a příkaz ‘OpenScreen()’ neuspěje. Hodnoty, které jsem v tomto příkladu použil, podporuje většina počítačů a neměly by způsobovat žádné problémy. Na to je dobré pamatovat při psaní programu, který na obrazovce závisí.
Obr. 36 ukazuje běžná rozlišení obrazovky a barevné hloubky, které by měly fungovat téměř na každém moderním počítači. Stejně jako u počítačových her platí, že čím vyšší je rozlišení obrazovky, tím ostřeji obraz vypadá, ale protože je třeba vykreslit více pixelů, může se program zpomalit. Čím vyšší je barevná hloubka, tím více barev lze zobrazit a tím realističtější grafiku lze vykreslit.
| Šířka | Výška | Barevné hloubky |
|---|---|---|
640 |
480 |
8, 16 a 32 |
800 |
600 |
8, 16 a 32 |
1024 |
768 |
8, 16 a 32 |
Obr. 36: Běžná rozlišení obrazovky
Místo napevno zapsaných hodnot, jako jsou tyto, je samozřejmě vždy lepší otestovat, zda je cílový počítač dokáže použít. Různá rozlišení a barevné hloubky, které dokáže libovolný počítač zobrazit, si můžete vypsat tímto kódem:
InitSprite()
If ExamineScreenModes()
While NextScreenMode()
Width.l = ScreenModeWidth()
Height.l = ScreenModeHeight()
BitDepth.l = ScreenModeDepth()
Debug Str(Width)+" x "+Str(Height)+" x "+Str(BitDepth)
Wend
EndIf
I v tomto úryvku inicializujeme engine spritů dříve, než použijeme příkaz ‘ExamineScreenModes()’; tím se vše správně inicializuje, abychom mohli tyto příkazy pro práci s obrazovkou používat. Poté pomocí cyklu ‘While’ procházím jednotlivé podporované režimy obrazovky a pomocí příkazů ‘ScreenModeWidth()’, ‘ScreenModeHeight()’ a ‘ScreenModeDepth()’ sestavím řetězec popisující každý režim. Ten se pak vypíše do okna Debug Output, kde si ho můžeme prohlédnout. Je to jednoduchý příklad, kterému byste měli porozumět sami, když si přečtete příslušné stránky nápovědy k použitým příkazům (Helpfile:Reference Manual->2D Games Libraries->Sprite & Screen).
Vykreslování s dvojitým bufferováním
Při zobrazování grafiky na obrazovce vždy potřebujete hlavní cyklus, který udržuje program v chodu, kreslí grafiku, testuje vstup od uživatele atd., a i ten musí při použití obrazovky odpovídat určité šabloně. Zde je hlavní cyklus převzatý z kostry programu s obrazovkou na předchozí stránce:
...
Repeat
ClearScreen(0)
;Drawing operations go here
FlipBuffers(2)
ExamineKeyboard()
If KeyboardReleased(#PB_Key_Escape)
Quit = #True
EndIf
Until Quit = #True
...
Na první pohled vidíte, že se velmi podobá běžnému hlavnímu cyklu jakéhokoli jiného programu, ale je tu několik rozdílů. Jsou v něm dva příkazy, které jsou zásadní pro to, aby obrazovka vykreslovala grafiku správně: ‘ClearScreen()’ a ‘FlipBuffers()’. Než se k těmto dvěma příkazům dostanu podrobněji, musím vysvětlit grafickou techniku zvanou dvojité bufferování.
Dvojité bufferování je grafická technika, kterou obrazovky PureBasicu používají, aby se zabránilo poškozené grafice a blikání obrazu. Protože monitory počítačů neustále překreslují obraz, obvykle šedesátkrát až sedmdesátkrát (někdy i víckrát) za sekundu, je obtížné na obrazovce provádět změny, například přesouvat a kreslit novou grafiku, aniž by obraz ukázal změny dříve, než je skutečně dokončíte. Výsledkem je roztrhaná, poškozená grafika a další podivné vizuální artefakty. Kdybyste se chtěli tomuto problému vyhnout tím, že obrazovku před každým novým překreslením celé obrazovky vymažete, problém s poškozenou grafikou by to vyřešilo, ale obrazovka by blikala.
PureBasic tyto problémy řeší pomocí dvojitého bufferování. Jakmile je obrazovka otevřena, jsou jí automaticky přiděleny dva video buffery v paměti, přesně stejně velké jako otevřená obrazovka. Když na obrazovku kreslíte grafiku pomocí grafických příkazů PureBasicu, kreslíte ve skutečnosti do zadního bufferu, zatímco přední buffer je zobrazován na obrazovce. Když monitor dokončí zobrazení předního bufferu a kreslicí operace v zadním bufferu jsou hotové, oba buffery se prohodí. Přední se nyní stane zadním a zadní předním, který se pak zobrazí. Když program znovu kreslí grafiku, kreslí do nově prohozeného zadního bufferu. Tento nový zadní buffer bude pravděpodobně obsahovat starou grafiku, protože už byla zobrazena, a proto je standardním postupem zadní buffer před dalším kreslením celý vymazat jednou barvou (obvykle černou). Obr. 37 ukazuje tuto techniku v praxi na třech cyklech bufferů.

Obr. 37: Vykreslování s dvojitým bufferováním — (Buffer B je zobrazen na obrazovce)(Buffer A je zobrazen na obrazovce)
Na tomto diagramu vidíte, že při startu programu (krok 1) není v předním bufferu (‘Buffer A’) nakreslena žádná grafika, takže se na obrazovce nic nezobrazuje. Když kreslíme pomocí kreslicích příkazů PureBasicu, kreslíme do zadního bufferu, označeného ‘Buffer B’. Jakmile je veškeré kreslení hotovo, můžeme zavolat příkaz ‘FlipBuffers()’ a buffery se prohodí. To ukazuje krok 2. Nyní je na obrazovce zobrazen ‘Buffer B’ a my pokračujeme v kreslení do ‘Buffer A’, který je teď novým zadním bufferem. Jakmile jsou opět všechny kreslicí operace hotové, můžeme buffery znovu prohodit příkazem ‘FlipBuffers()’ a dostaneme se ke kroku 3, kdy se na obrazovku vykresluje ‘Buffer A’ a ‘Buffer B’ je opět zadním bufferem.
Když se buffery prohodí příkazem ‘FlipBuffer()’, bude v bufferu, který se ocitne vzadu, stále nakreslena stará grafika. Chceme-li vytvořit iluzi pohybu a grafiku animovat, musíme ji vymazat a nakreslit na novém místě dříve, než buffery znovu prohodíme. K vymazání staré grafiky slouží příkaz ‘ClearScreen()’. ‘ClearScreen()’ přijímá jeden parametr, a to 24bitovou hodnotu barvy, kterou chcete obrazovku vymazat. Tu lze snadno získat příkazem ‘RGB()’.
Příkaz ‘FlipBuffers()’ (Helpfile:Reference Manual->2D Games Libraries->Sprite & Screen- >FlipBuffers) má také nepovinný parametr, který může nabývat těchto hodnot:
‘0’ : vypne vertikální synchronizaci monitoru ‘1’ : zapne vertikální synchronizaci monitoru (výchozí hodnota) ‘2’ : zapne vertikální synchronizaci monitoru s režimem šetření procesoru (pouze v celoobrazovkovém režimu).
Pokud je jako parametr použita hodnota ‘0’, prohazuje ‘FlipBuffers()’ buffery tak rychle, jak jen dokáže, aby se dosáhlo nejvyšší snímkové frekvence vykreslované grafiky. Jedinou nevýhodou je, že obnovovací frekvence monitoru nemusí být dost vysoká, aby novou grafiku vykreslovala v reálném čase, takže se může objevit vizuální trhání obrazu, když se monitor snaží s prohazovanými buffery držet krok.
Pokud je jako parametr použita hodnota ‘1’, prohazuje příkaz ‘FlipBuffers()’ buffery v dokonalé synchronizaci s obnovovací frekvencí monitoru, což zajišťuje, že se veškerá grafika na monitor vykreslí správně a plynule. Jedinou nevýhodou je, že snímková frekvence nikdy nemůže překročit obnovovací frekvenci monitoru. Toto je výchozí režim, pokud není použit žádný parametr.
Použití hodnoty ‘2’ jako parametru má stejný účinek jako hodnota ‘1’, ale navíc se přepne do režimu šetření procesoru, aby procesor neběžel na sto procent a i ostatní programy dostaly příležitost běžet.
Kreslení na obrazovku
Zde je příklad vykreslování s dvojitým bufferováním a animace, vytvořené kreslením aktualizované grafiky mezi jednotlivými příkazy ‘FlipBuffers()’ (program ukončíte stisknutím klávesy ‘Esc’):
#IMAGE_MAIN = 1
;Set the width, height and bit depth of the screen
;Abbreviated variables are used here due to page width constraints :(
Global ScrW.l = 1024
Global ScrH.l = 768
Global ScrD.l = 32
Global Quit.b = #False
XOrigin.f = (ScrW / 2) - 64 : YOrigin.f = (ScrH / 2) - 64
;Simple error checking procedure
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
;Initialize environment
HandleError(InitSprite(), "InitSprite() command failed.")
HandleError(InitKeyboard(), "InitKeyboard() command failed.")
HandleError(OpenScreen(ScrW, ScrH, ScrD, "Blobs"), "Could not open screen.")
SetFrameRate(60)
;Create an image
If CreateImage(#IMAGE_MAIN, 128, 128)
If StartDrawing(ImageOutput(#IMAGE_MAIN))
For x.l = 255 To 0 Step -1
Circle(64, 64, x / 4, RGB(0, 0, 255 - x))
Next x
StopDrawing()
EndIf
EndIf
;Convert Degrees to Radians
Procedure.f DegToRad(Angle.f)
ProcedureReturn Angle.f * #PI / 180
EndProcedure
;Main loop
Repeat
ClearScreen(RGB(0, 0, 0))
Angle.f + 2.0
Radius.f = ((ScrH / 2) - 100) * Sin(DegToRad(Angle))
StartDrawing(ScreenOutput())
For x.l = 0 To 359 Step 45
XPos.f = XOrigin + (Radius * Cos(DegToRad(Angle + x)))
YPos.f = YOrigin + (Radius * Sin(DegToRad(Angle + x)))
DrawImage(ImageID(#IMAGE_MAIN), XPos, YPos)
Next x
StopDrawing()
FlipBuffers()
ExamineKeyboard()
If KeyboardReleased(#PB_Key_Escape)
Quit = #True
EndIf
Until Quit = #True
End
V tomto příkladu jsem příkazem ‘CreateImage()’ vytvořil nový obrázek a později ho v bloku ‘StartDrawing()’ nakreslil na obrazovku. I když tento kód vypadá trochu složitě, zejména při výpočtu hodnot ‘x’ a ‘y’ kresleného obrázku, slouží tento příklad čistě k předvedení prohazování bufferů.
V hlavním cyklu vidíte, že nejprve vymažu obrazovku příkazem ‘ClearScreen()’. Díky tomu mohu začít s čistým bufferem, v němž nezůstala žádná stará grafika z předchozích kreslicích operací. Poté pomocí trochy matematiky vypočítám nové souřadnice svých obrázků kuliček a v cyklu je nakreslím. Po nakreslení se nacházejí v zadním bufferu, takže je musím zobrazit na obrazovce příkazem ‘FlipBuffers()’. A tak to pokračuje dál – mazání, kreslení a prohazování – a mezi jednotlivými prohozeními měním pozici grafiky.
Možná jste si všimli dalšího nového příkazu, který jsem v tomto příkladu použil, a to ‘SetFrameRate()’ (Helpfile:Reference Manual->2D Games Libraries->Sprite & Screen- >SetFrameRate). Tento příkaz má jeden parametr, který nastavuje, kolikrát za sekundu může být příkaz ‘FlipBuffers()’ proveden. Slouží k zajištění jednotné snímkové frekvence i na jiných počítačích, na kterých může tento kód běžet. Tento příklad by tak měl aktualizovanou grafiku zobrazovat šedesátkrát za sekundu.
Takto vzniká veškerá animace na počítačích, velmi podobně jako u kreslených seriálů nebo filmů. Na obrazovce se ve skutečnosti nic nepohybuje; je to vlastně promítání různých obrázků (bufferů), na nichž je grafika v mírně odlišných pozicích. Protože se to vše děje velmi rychle (šedesátkrát a víckrát za sekundu), zdá se, že se obrázky pohybují.
Jednoduché hvězdné pole
Toto je jeden z efektů, které umí nakreslit každý programátor dem nebo her. Hvězdné pole jako toto bylo použito ve stovkách dem a her, aby navodilo dojem cestování vesmírem. Jde o efekt, který na obrazovce kreslí a animuje stovky pixelů v různých odstínech barvy, aby vytvořil iluzi hloubky a pohybu. Tento efekt lze naprogramovat různými způsoby; zde je můj příklad:
#APP_NAME = "Stars v1.0"
#NUMBER_OF_STARS = 10000
;Set the width, height and bit depth of the screen
;Abbreviated variables are used here due to page width constraints :(
Global ScrW.l = 1024
Global ScrH.l = 768
Global ScrD.l = 32
Global Quit.b = #False
Structure STAR
xPos.f
yPos.f
xStep.f
Color.l
EndStructure
Global Dim Stars.STAR(#NUMBER_OF_STARS)
;Simple error checking procedure
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
;init stars
Procedure InitializeStars()
For x = 0 To #NUMBER_OF_STARS
Stars(x)\xPos = Random(ScrW - 1)
Stars(x)\yPos = Random(ScrH - 1)
If x < #NUMBER_OF_STARS / 3
Stars(x)\xStep = (Random(10) / 100) + 0.2
Stars(x)\Color = RGB(40, 40, 40)
ElseIf x >= #NUMBER_OF_STARS / 3 And x < (#NUMBER_OF_STARS / 3) * 2
Stars(x)\xStep = (Random(10) / 100) + 0.6
Stars(x)\Color = RGB(100, 100, 100)
Else
Stars(x)\xStep = (Random(10) / 100) + 1.2
Stars(x)\Color = RGB(255, 255, 255)
EndIf
Next x
EndProcedure
;move stars on the 'x' axis
Procedure MoveStarsX()
For x = 0 To #NUMBER_OF_STARS
Stars(x)\xPos - Stars(x)\xStep
If Stars(x)\xPos < 0
Stars(x)\xPos = ScrW - 1
Stars(x)\yPos = Random(ScrH - 1)
EndIf
Next x
EndProcedure
;Initialize environment
HandleError(InitSprite(), "InitSprite() command failed.")
HandleError(InitKeyboard(), "InitKeyboard() command failed.")
HandleError(OpenScreen(ScrW, ScrH, ScrD, #APP_NAME), "Could not open screen.")
SetFrameRate(60)
InitializeStars()
Repeat
ClearScreen(RGB(0, 0, 0))
StartDrawing(ScreenOutput())
For x = 0 To #NUMBER_OF_STARS
Plot(Stars(x)\xPos, Stars(x)\yPos, Stars(x)\Color)
Next x
DrawingMode(#PB_2DDrawing_Transparent)
DrawText(20, 20, #APP_NAME, #White)
DrawText(20, 40, Str(#NUMBER_OF_STARS)+" Animated stars", #White)
DrawText(20, 60, "Screen Resolution: "+Str(ScrW)+" x "+Str(ScrH), #White)
DrawText(20, 80, "Screen Bit depth: "+Str(ScrD)+"bit", #White)
StopDrawing()
FlipBuffers()
MoveStarsX()
ExamineKeyboard()
If KeyboardReleased(#PB_Key_Escape)
Quit = 1
EndIf
Until Quit = 1
End
Tento příklad používá příkaz pro 2D kreslení ‘Plot()’, který kreslí vždy jediný pixel (Helpfile:Reference Manual->General Libraries->2DDrawing->Plot). Tento příkaz má tři parametry, z nichž třetí je nepovinný. Tyto parametry určují pozici ‘x’ a ‘y’ a barvu kresleného pixelu. Pokud poslední parametr nepoužijete, použije tento příkaz výchozí barvu popředí, kterou lze nastavit příkazem ‘FrontColor()’.
Ve výše uvedeném příkladu jsem použil strukturu, která drží pohromadě všechny informace o jednom pixelu, a pak jsem s pomocí této struktury vytvořil pole proměnných. Každý prvek pole popisuje pozici, barvu a hodnotu kroku jednoho pixelu. Pole pak procházím v cyklu a každý pixel kreslím na obrazovku podle informací (pozice, barva atd.) uložených v příslušném prvku strukturovaného pole. Po dokončení kreslení prohodím buffery a aktualizuji pozice pixelů v poli pomocí příslušných hodnot kroku. Jakmile je to hotovo, vymažu obrazovku a znovu kreslím, ...a tak to jde stále dokola. Díky takovému postupu vypadá kód čistěji, mnohem snáz se čte a umožňuje vám ho později snadno upravit.
Otevření obrazovky v okně
Někdy se vám může hodit otevřít obrazovku v okně, zejména pokud chcete vytvořit hru nebo demo běžící v okně. To lze udělat příkazem ‘OpenWindowedScreen()’. Chcete-li otevřít obrazovku v okně, musíte nejprve vytvořit okno a pak v hlavním cyklu kromě kreslení zpracovávat i události tohoto okna. Zde je příklad použití obrazovky v okně:
#WINDOW_MAIN = 1
#IMAGE_MAIN = 1
;Set the width, height and bit depth of the screen
;Abbreviated variables are used here due to page width constraints :(
Global ScrW.l = 800
Global ScrH.l = 600
Global ScrD.l = 32
Global Quit.b = #False
Global XOrigin.f = (ScrW / 2) - 64
Global YOrigin.f = (ScrH / 2) - 64
;Simple error checking procedure
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
;Convert Degrees to Radians
Procedure.f DegToRad(Angle.f)
ProcedureReturn Angle.f * #PI / 180
EndProcedure
;Initialize environment
HandleError(InitSprite(), "InitSprite() command failed.")
HandleError(InitKeyboard(), "InitKeyboard() command failed.")
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_MAIN, 0, 0, ScrW, ScrH, "Windowed Screen", #FLAGS)
If OpenWindowedScreen(WindowID(#WINDOW_MAIN), 0, 0, ScrW, ScrH, 0, 0, 0)
SetFrameRate(60)
;Create an image
If CreateImage(#IMAGE_MAIN, 128, 128)
If StartDrawing(ImageOutput(#IMAGE_MAIN))
For x.l = 255 To 0 Step -1
Circle(64, 64, x / 4, RGB(255 - x, 0, 0))
Next x
StopDrawing()
EndIf
EndIf
;Main loop
Repeat
Event.l = WindowEvent()
ClearScreen(RGB(0, 0, 0))
Angle.f + 2.0
Radius.f = ((ScrH / 2) - 100) * Sin(DegToRad(Angle))
StartDrawing(ScreenOutput())
For x.l = 0 To 359 Step 45
XPos.f = XOrigin + (Radius * Cos(DegToRad(Angle + x)))
YPos.f = YOrigin + (Radius * Sin(DegToRad(Angle + x)))
DrawImage(ImageID(#IMAGE_MAIN), XPos, YPos)
Next x
StopDrawing()
FlipBuffers()
ExamineKeyboard()
If KeyboardReleased(#PB_Key_Escape)
Quit = #True
EndIf
Until Event = #PB_Event_CloseWindow Or Quit = #True
EndIf
EndIf
End
Tento příklad by měl být docela srozumitelný, protože většinu tohoto kódu jste už viděli. Hlavním rozdílem je příkaz ‘OpenWindowedScreen()’, který přijímá osm parametrů! Prvním parametrem je identifikátor OS okna, ve kterém se má obrazovka otevřít. Druhý a třetí parametr udávají pozici ‘x’ a ‘y’ nové obrazovky v okně. Čtvrtý a pátý parametr udávají šířku a výšku nové obrazovky. Šestý parametr je příznak automatické změny velikosti neboli automatického roztažení. Je-li tento parametr nastaven na ‘0’, k žádné automatické změně velikosti nedochází, ale je-li nastaven na ‘1’, obrazovka automaticky změní svou velikost na maximální, jakou okno dovolí, bez ohledu na čtvrtý a pátý parametr. To znamená, že i když změníte velikost rodičovského okna, obrazovka automaticky změní svou velikost tak, aby vždy vyplňovala celou plochu rodičovského okna. Sedmý a osmý parametr jsou okraje, které můžete zadat pro případ, kdy je automatické roztažení zapnuto. Ty automaticky zvětšovanou obrazovku trochu odsunou od pravého, resp. dolního okraje, aby v okně zůstalo místo pro stavový řádek nebo jiné gadgety.
Při použití obrazovky v okně je také velmi důležité vždy správně zpracovávat události pomocí příkazu ‘WindowEvent()’. Jak si možná pamatujete z kapitoly 9, tento příkaz před návratem nečeká, až nastane nějaká událost, ale vždy se pokusí zjistit a vrátit jakékoli události, které je třeba zpracovat. Použití tohoto příkazu místo ‘WaitWindowEvent()’ je nutností, protože nechcete kreslení a prohazování bufferů zastavovat na jakkoli dlouhou dobu.
Sprity
Sprity jsou v PureBasicu obrázky, které lze kreslit na libovolné místo obrazovky. Na rozdíl od obrázků však mají sprity vlastní sadu příkazů, jsou optimalizovány pro rychlost a lze je kreslit několika zvláštními způsoby, jimiž dosáhnete mnoha speciálních efektů. Všechny běžné příkazy pro sprity najdete v oddílu ‘Sprite & Screen’ v nápovědě (Helpfile:Reference Manual->2D Games Libraries->Sprite & Screen), ale některé další příkazy pro sprity se nacházejí také v oddílu ‘Sprite3D’ (Helpfile:Reference Manual->2D Games Libraries->Sprite3D). Abyste se plně seznámili s tím, co příkazy pro sprity dokážou, doporučuji přečíst si oba tyto oddíly.
Rozdíl mezi sprity a sprity Sprite3D
V PureBasicu existují dva různé typy spritů. Prvním je to, co byste považovali za běžný sprite: vytváří se z obrázku nakresleného uživatelem nebo načteného ze souboru a zobrazuje se a upravuje pomocí standardní knihovny pro sprity.
Druhý typ je téměř stejný, až na to, že PureBasic k zobrazování těchto spritů používá velmi malý 3D engine. Příkazy pro kreslení a úpravy tohoto typu navíc programátorovi umožňují dosáhnout grafických efektů, které s běžnými sprity možné nejsou. Mezi tyto efekty patří přibližování (zoom) v reálném čase, 3D transformace a prolínání spritů. 3D engine, který provádí transformace a zobrazování 3D spritů, není engine OGRE zmíněný v další kapitole, ale malý, samostatný 3D engine vytvořený speciálně pro práci s tímto typem spritů.
Používání běžných spritů
Chcete-li vytvořit sprite pro použití ve svém programu, můžete ho buď načíst příkazem ‘LoadSprite()’ (Helpfile:Reference Manual->2D Games Libraries->Sprite & Screen->LoadSprite), nebo vytvořit nový příkazem ‘CreateSprite()’ (Helpfile:Reference Manual->2D Games Libraries- >Sprite & Screen->CreateSprite).
K načtení existujících obrázků, které se mají použít jako sprity, slouží příkaz ‘LoadSprite()’, který se velmi podobá příkazu ‘LoadImage()’ a má tři parametry. Prvním je PB číslo, které chcete tomuto spritu přiřadit. Druhým je název souboru s obrázkem, který chcete načíst jako sprite – samozřejmě nezapomeňte v případě potřeby použít správný dekodér obrázků. Třetím je režim spritu, který určuje, jak se bude tento sprite používat; více o tom za chvíli.
K vytvoření vlastního spritu, na který můžete kreslit příkazy pro 2D kreslení, použijeme ‘CreateSprite()’. Tento příkaz se velmi podobá ‘CreateImage()’ a přijímá čtyři parametry. Prvním parametrem je PB číslo, které chcete tomuto spritu přiřadit. Druhý a třetí parametr udávají šířku a výšku nového spritu v pixelech a čtvrtým parametrem je režim spritu.
Oba tyto příkazy vytvářejí nový sprite a oba mají nepovinný parametr ‘Mode’ (režim). Tento parametr určuje interní formát spritu, aby bylo možné konkrétní sprity správně zobrazit pomocí dalších příkazů pro sprity. Tento parametr formátu se obvykle zadává jako vestavěná konstanta; obr. 38 ukazuje tyto konstanty režimů a popis každého z nich.
Podle toho, kterým příkazem chcete sprite zobrazit, s ním musíte použít sprite ve správném formátu, a tento formát se nastavuje při vytvoření nebo načtení spritu.
| Použitá konstanta | Popis režimu |
|---|---|
Žádná |
Výchozí režim. Sprite se načte do video paměti (Video RAM), je-li to možné. |
#PB_Sprite_Memory |
Sprite se místo do video paměti načte do běžné paměti RAM, aby se dal použít s příkazem ‘StartSpecialFX()’. |
#PB_Sprite_Alpha |
Sprite musí být 8bitový ve stupních šedi a bude připraven pro použití s příkazy ‘DisplayAlphaSprite()’ nebo ‘DisplayShadowSprite()’. Pokud budete používat příkaz ‘StartSpecialFX()’, je nutné zadat také ‘#PB_Sprite_Memory’. |
#PB_Sprite_Texture |
Sprite se vytvoří s podporou 3D, takže z něj můžete příkazem ‘CreateSprite3D()’ vytvořit 3D sprite. |
#PB_Sprite_AlphaBlending |
Sprite se vytvoří s podporou alfa kanálu. Načtený obrázek musí být v obrazovém formátu, který může obsahovat alfa kanál. Jedinými obrazovými formáty, které tento režim v současnosti podporuje, jsou Png a Tiff. (Pokud chcete tento sprite převést na 3D sprite, je nutné zadat také režim ‘#PB_Sprite_Texture’.) |
Obr. 38: Režimy spritů — Režimy lze jako obvykle kombinovat pomocí bitového operátoru Or ‘|’.
Zde jsou příklady, jak správně zadat režim pro jednotlivé příkazy zobrazující sprity. Kde to má smysl, uvádím příklad, jak sprite vytvořit a načíst se správným nastavením režimu, aby se při použití příkazu uvedeného nad příkladem správně zobrazil.
‘DisplaySprite()’ a ‘DisplayTransparentSprite()’
;Default format
CreateSprite(#PB_NUMBER, Width.l, Height.l)
LoadSprite(#PB_NUMBER, "Image.bmp")
‘DisplaySprite3D()’
;Without an alpha channel
CreateSprite(#PB_NUMBER, Width.l, Height.l, #PB_Sprite_Texture )
LoadSprite(#PB_NUMBER, "Image.bmp", #PB_Sprite_Texture )
;With an alpha channel
;NOTE: You can’t create sprites with an alpha channel in PureBasic yet.
LoadSprite(#PB_NUMBER,"Image.bmp",#PB_Sprite_Texture|#PB_Sprite_AlphaBlending)
‘DisplayTranslucentSprite()’
;Load in normal RAM for processing by the 'StartSpecialFX()' command
CreateSprite(#PB_NUMBER, Width.l, Height.l, #PB_Sprite_Memory)
LoadSprite(#PB_NUMBER, "Image.bmp", #PB_Sprite_Memory)
‘DisplayAlphaSprite()’, ‘DisplayShadowSprite()’ a ‘DisplaySolidSprite()’
;Load in normal RAM for processing by the 'StartSpecialFX()' command
;and specify as an alpha type sprite
CreateSprite(#PB_NUMBER, Width.l, Height.l, #PB_Sprite_Memory|#PB_Sprite_Alpha)
LoadSprite(#PB_NUMBER, "Image.bmp", #PB_Sprite_Memory | #PB_Sprite_Alpha)
Tyto příklady by vám měly dát dobrou představu o tom, jak načíst a vytvořit vlastní sprity pro každý zobrazovací příkaz.
Na sprity můžete také kreslit
Jakmile sprite vytvoříte nebo načtete, možná na něj budete chtít kreslit. Podobně jako při kreslení na obrázek to můžete udělat standardním příkazem ‘StartDrawing()’ s výstupem nastaveným na ‘SpriteOutput()’. To vám umožní kreslit na povrch spritu příkazy pro 2D kreslení. Můžete dokonce nakreslit jeden sprite na jiný sprite. K tomu musíte přepnout výstup kreslení spritů ze zadního bufferu na cílový sprite. K tomu potřebujete příkaz ‘UseBuffer()’. Tento příkaz přijímá jeden parametr, a to PB číslo spritu, na který chcete směrovat veškerý výstup spritů. Po přepnutí kreslí všechny další příkazy pro zobrazování spritů sprity na cílový sprite. Až skončíte, můžete výstup zobrazování spritů vrátit zpět do zadního bufferu opětovným použitím příkazu ‘UseBuffer()’, tentokrát však s parametrem ‘#PB_Default’.
Příkazy pro sprity ‘SpecialFX’
V příkladech režimů jsem zmínil sprity ‘SpecialFX’. Jsou to stále běžné sprity, ale pracují mnohem rychleji, pokud jsou uzavřeny mezi příkazy ‘StartSpecialFX()’. Všechny sprity, které takto používají speciální efekty, dokážou vytvářet pěkně vypadající grafiku, ale protože se vše vykresluje v hlavní paměti RAM počítače, nejsou tyto sprity tak rychlé jako sprity Sprite3D. Zde je krátký úryvek ukazující použití těchto příkazů:
...
StartSpecialFX()
DisplayAlphaSprite(#SPRITE_NUMBER, 64, 64)
DisplayRGBFilter(100, 100, 100, 100, 0, 255, 0)
DisplayTranslucentSprite(#SPRITE_NUMBER, 128, 128, 128)
;etc...
StopSpecialFX()
...
Jak vidíte, příkaz ‘StartSpecialFX()’ blok zahajuje a ‘StopSpecialFX()’ ho ukončuje. Všechny příkazy pro speciální efekty musí být mezi těmito dvěma příkazy. Účelem je zvýšit rychlost vykreslování těchto speciálních efektů; bez bloku ‘StartSpecialFX()’ by byl výkon zobrazování velmi slabý.
Používáte-li tyto příkazy, je velmi důležité pochopit, že musí být použity před všemi ostatními grafickými příkazy. Souvisí to se způsobem, jakým PureBasic interně řeší kreslení speciálních efektů. Pokud byste před blokem speciálních efektů použili jiné grafické příkazy, byly by v zadním bufferu přepsány, jakmile blok ‘StartSpecialFX()’ začne. Pokud před kreslením mažete buffer příkazem ‘ClearScreen()’, měli byste i ten umístit do bloku ‘StartSpecialFX()’. Další důležitou věcí je, že v každém hlavním cyklu by měl být vždy jen jeden blok ‘StartSpecialFX()’, protože to výkon ještě dále zvyšuje.
Příkazy, které používají blok ‘StartSpecialFX()’, jsou:
‘DisplayAlphaSprite()’ ‘DisplaySolidSprite()’ ‘DisplayShadowSprite()’ ‘DisplayRGBFilter()’ ‘DisplayTranslucentSprite()’
Podrobněji si o těchto příkazech můžete přečíst v nápovědě, v knihovně ‘Sprite & Screen’ (Helpfile:Reference Manual->2D Games Libraries->Sprite & Screen).
Zobrazování běžných spritů
Běžné sprity jsou základem tvorby 2D her v PureBasicu. Tento typ spritů se znovu a znovu používal k vytváření skvělých vizuálních efektů v mnoha špičkových hrách. Zde je jednoduchý příklad, který vytvoří nový sprite a vykreslí ho po celé obrazovce standardním příkazem ‘DisplayTransparentSprite()’:
#SPRITE_MAIN = 1
#NUMBER_OF_BALLS = 500
;Set the width, height and bit depth of the screen
;Abbreviated variables are used here due to page width constraints :(
Global ScrW.l = 1024
Global ScrH.l = 768
Global ScrD.l = 32
Global Quit.b = #False
Structure BALL
x.f
y.f
XOrigin.l
YOrigin.l
Radius.l
Angle.f
Speed.f
EndStructure
Global Dim Balls.BALL(#NUMBER_OF_BALLS)
;Simple error checking procedure
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
;Convert Degrees to Radians
Procedure.f DegToRad(Angle.f)
ProcedureReturn Angle.f * #PI / 180
EndProcedure
;Initialize all ball data
Procedure InitialiseBalls()
For x.l = 0 To #NUMBER_OF_BALLS
Balls(x)\XOrigin = Random(ScrW) - 32
Balls(x)\YOrigin = Random(ScrH) - 32
Balls(x)\Radius = Random(190) + 10
Balls(x)\Angle = Random(360)
Balls(x)\Speed = Random(2) + 1
Next x
EndProcedure
;Initialize environment
HandleError(InitSprite(), "InitSprite() command failed.")
HandleError(InitKeyboard(), "InitKeyboard() command failed.")
HandleError(OpenScreen(ScrW, ScrH, ScrD, "Blobs"), "Could not open screen.")
SetFrameRate(60)
;Create an image
Global Offset.f = 32
If CreateSprite(#SPRITE_MAIN, 64, 64)
If StartDrawing(SpriteOutput(#SPRITE_MAIN))
Box(0, 0, 64, 64, RGB(255, 255, 255))
For x.l = 220 To 1 Step -1
Offset + 0.025
Circle(Offset, 64 - Offset, x / 8, RGB(0, 255 - x, 0))
Next x
StopDrawing()
EndIf
EndIf
TransparentSpriteColor(#SPRITE_MAIN, RGB(255, 255, 255))
InitialiseBalls()
;Main loop
Repeat
ClearScreen(RGB(56, 76, 104))
For x.l = 0 To #NUMBER_OF_BALLS
Balls(x)\x=Balls(x)\XOrigin+(Balls(x)\Radius*Cos(DegToRad(Balls(x)\Angle)))
Balls(x)\y=Balls(x)\YOrigin+(Balls(x)\Radius*Sin(DegToRad(Balls(x)\Angle)))
Balls(x)\Angle + Balls(x)\Speed
DisplayTransparentSprite(#SPRITE_MAIN, Balls(x)\x, Balls(x)\y)
Next x
FlipBuffers()
ExamineKeyboard()
If KeyboardReleased(#PB_Key_Escape)
Quit = #True
EndIf
Until Quit = #True
End
Příkaz ‘DisplayTransparentSprite()’ umožňuje zobrazit sprite na obrazovce velmi podobně jako ‘DisplaySprite()’, ale při zobrazení spritu pomocí ‘DisplayTransparentSprite()’ se v obrázku vybere jedna barva, se kterou se zachází jako s průhlednou. Díky tomu nemusí sprite vždy vypadat jako čtverec.
V tomto příkladu jsem vytvořil nový sprite a hned ho vyplnil bílou barvou příkazem ‘Box()’. Poté na něj v cyklu příkazem ‘Circle()’ nakreslím stínovanou zelenou kouli. Tím získám zelenou kouli na bílém pozadí. Po dokončení kreslicích příkazů označím příkazem ‘TransparentSpriteColor()’ všechny bílé pixely nového spritu jako průhledné. Tento příkaz přijímá dva parametry: prvním je PB číslo spritu, který se má změnit, a druhým barva, kterou chcete označit jako průhlednou. Jakmile je barva vybrána, zobrazí další použití ‘DisplayTransparentSprite()’ sprite bez průhledné barvy. Po spuštění tohoto příkladu byste měli vidět obrazovku plnou zelených koulí, na které není vůbec vidět bílá. To je skvělý způsob, jak zobrazovat sprity s průhledností.
V tomto příkladu si také všimnete, že příkaz pro zobrazení běžného spritu nemusí být uzavřen v žádných zvláštních příkazech, jako je ‘StartSpecialFX()’ nebo ‘StartDrawing()’ apod. Běžné příkazy pro zobrazování spritů můžete používat samostatně. Pokud je engine spritů inicializován a obrazovka otevřena, můžete k zobrazení spritu používat standardní příkazy pro sprity. Standardní příkazy pro zobrazování spritů jsou:
‘DisplaySprite()’ ‘DisplayTransparentSprite()’
Používání spritů Sprite3D
PureBasic nazývá své 3D sprity trochu zkomoleným názvem ‘sprite3D’. Každý sprite3D je 2D plocha tvořená dvěma polygony. Tyto polygony se kreslí pomocí malého 3D enginu a lze je ve 3D transformovat, ale každý sprite3D se nakonec na obrazovku kreslí ve 2D. Jste zmatení? Dobře, pokračujme.
Sprite3D je v PureBasicu ve skutečnosti běžný sprite, kterému byla přidána podpora 3D, a proto tento odlišný typ potřebuje ke svému zobrazení malý 3D engine. Chcete-li ve svém programu používat sprity sprite3D, musíte před použitím jakýchkoli dalších příkazů souvisejících se sprity sprite3D inicializovat engine sprite3D. To se provádí příkazem ‘InitSprite3D()’. Tento příkaz je však podřízeným příkazem příkazu ‘InitSprite()’, který musí být zavolán před ním.
Každý sprite3D začíná svůj život jako běžný sprite, načtený nebo vytvořený, ale se zadaným režimem ‘#PB_Sprite_Texture’. Tato běžná verze se nikdy nezobrazuje; místo toho se tento běžný sprite příkazem ‘CreateSprite3D()’ převede na 3D verzi. Tento příkaz přijímá dva parametry: prvním je PB číslo, které chcete přiřadit novému spritu sprite3D. Druhým je dříve vytvořený nebo načtený sprite, který chcete převést na sprite3D.
Takto vypadá tento postup převodu v kódu PureBasicu:
LoadSprite(#NORMAL_SPRITE, "Image.bmp", #PB_Sprite_Texture)
CreateSprite3D(#SPRITE_3D, #NORMAL_SPRITE)
Jakmile je sprite3D takto vytvořen, můžeme ho zobrazit na obrazovce příkazem ‘DisplaySprite3D()’. Pro větší názornost zde je příklad zobrazování a úprav spritů sprite3D:
UsePNGImageDecoder()
Enumeration
#SPRITE_2D
#SPRITE_3D
EndEnumeration
#NUMBER_OF_FLOWERS = 150
;Set the width, height and bit depth of the screen
;Abbreviated variables are used here due to page width constraints :(
Global ScrW.l = 1024
Global ScrH.l = 768
Global ScrD.l = 32
;Other global variables
Global Quit.b = #False
Global XOrigin.l = ScrW / 2
Global YOrigin.l = ScrH / 2
Structure FLOWER
XPos.f
YPos.f
Width.f
Height.f
Angle.f
Radius.f
RadiusStep.f
EndStructure
Global Dim Flowers.FLOWER(#NUMBER_OF_FLOWERS)
;Simple error checking procedure
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
;Convert Degrees to Radians
Procedure.f DegToRad(Angle.f)
ProcedureReturn Angle.f * #PI / 180
EndProcedure
;Initialize all flowers
Procedure InitialiseAllFlowers()
For x.l = 0 To #NUMBER_OF_FLOWERS
Flowers(x)\Width = 0
Flowers(x)\Height = 0
Flowers(x)\Angle = Random(360)
Flowers(x)\Radius = 1.0
Flowers(x)\RadiusStep = (Random(30) / 10) + 1.0
Next x
EndProcedure
;Reset a flower
Procedure ResetFlower(Index.l)
Flowers(Index)\Width = 0
Flowers(Index)\Height = 0
Flowers(Index)\Angle = Random(360)
Flowers(Index)\Radius = 1.0
Flowers(Index)\RadiusStep = (Random(30) / 10) + 1.0
ProcedureReturn
EndProcedure
;Initialize environment
HandleError(InitSprite(), "InitSprite() command failed.")
HandleError(InitSprite3D(), "InitSprite3D() command failed.")
HandleError(InitKeyboard(), "InitKeyboard() command failed.")
HandleError(OpenScreen(ScrW, ScrH, ScrD, "Flowers"), "Could not open screen.")
SetFrameRate(60)
Sprite3DQuality(1)
;Load sprite
LoadSprite(#SPRITE_2D,"Flower.png",#PB_Sprite_Texture|#PB_Sprite_AlphaBlending)
CreateSprite3D(#SPRITE_3D, #SPRITE_2D)
InitialiseAllFlowers()
;Main loop
Repeat
ClearScreen(RGB(200, 100, 100))
HandleError(Start3D(), "Start3D() command failed.")
For x.l = 0 To #NUMBER_OF_FLOWERS
Flowers(x)\Width + 1.5
Flowers(x)\Height + 1.5
Flowers(x)\Angle + 1.0
If Flowers(x)\Width > 512.0 Or Flowers(x)\Height > 512.0
Flowers(x)\Width = 512.0
Flowers(x)\Height = 512.0
EndIf
If Flowers(x)\Radius > ScrW
ResetFlower(x)
EndIf
Flowers(x)\Radius + Flowers(x)\RadiusStep
Flowers(x)\XPos=XOrigin+(Flowers(x)\Radius*Cos(DegToRad(Flowers(x)\Angle)))
Flowers(x)\YPos=YOrigin+(Flowers(x)\Radius*Sin(DegToRad(Flowers(x)\Angle)))
Flowers(x)\XPos - Flowers(x)\Radius / 3.5
Flowers(x)\YPos - Flowers(x)\Radius / 3.5
ZoomSprite3D(#SPRITE_3D, Flowers(x)\Width, Flowers(x)\Height)
RotateSprite3D(#SPRITE_3D, Flowers(x)\Angle, 0)
DisplaySprite3D(#SPRITE_3D, Flowers(x)\XPos, Flowers(x)\YPos)
Next x
Stop3D()
FlipBuffers()
ExamineKeyboard()
If KeyboardReleased(#PB_Key_Escape)
Quit = #True
EndIf
Until Quit = #True
End
Abych mohl ve svém příkladu používat sprity sprite3D, inicializoval jsem běžný engine spritů a poté příkazem ‘InitSprite3D()’ engine sprite3D. To je nezbytné pro použití jakýchkoli příkazů souvisejících se sprity sprite3D. Potom jsem příkazem ‘LoadSprite()’ načetl obrázek ve formátu Png. Tento obrázek s názvem ‘Flower.png’ používá alfa kanál k vytvoření průhledného pozadí. Načtení obrázku ve formátu Png s alfa kanálem tímto způsobem vyžaduje, abyste v příkazu ‘LoadSprite()’ správně zadali režim spritu. Podíváte-li se na kód příkladu, uvidíte, že jsem režim zadal jako ‘#PB_Sprite_Texture|#PB_Sprite_AlphaBlending’. To kompilátoru sděluje, že chci tento sprite používat jako sprite3D a že obsahuje alfa kanál. Poté, co je sprite takto načten a správně definován, z něj mohu příkazem ‘CreatSprite3D()’ vytvořit sprite3D, přičemž jeho alfa kanál se zachová.
Jakmile jsou sprity vytvořeny, je čas je nakreslit na obrazovku. To se provádí příkazem ‘DisplaySprite3D()’ uvnitř bloku ‘Start3D()’. Vypadá to nějak takto:
...
Start3D()
DisplaySprite3D(#SPRITE_3D, x, y, Alpha)
Stop3D()
...
Podíváte-li se na příklad s květinou, uvidíte, že blok ‘Start3D()’ je kontrolován malou procedurou pro kontrolu chyb, aby se ověřilo, že se správně spustil. Pokud ano, můžeme pokračovat a sprity nakreslit. Pokud se nespustí správně, nesmíme kreslit žádné sprity sprite3D, jinak by mohlo dojít k vážnému pádu programu. K ukončení bloku sprite3D slouží příkaz ‘Stop3D()’. Uvnitř tohoto bloku nesmíte používat žádné příkazy z knihovny běžných spritů; tento blok je určen pouze pro příkazy sprite3D.
K samotnému zobrazení spritu sprite3D slouží příkaz ‘DisplaySprite3D()’, který přijímá čtyři parametry. Prvním je PB číslo spritu sprite3D, který chcete zobrazit. Druhý a třetí udávají pozici ‘x’ a ‘y’ spritu v bufferu. Čtvrtým, nepovinným parametrem je hodnota alfa spritu. Tato hodnota alfa určuje, jak průhledně se celý sprite na obrazovce vykreslí. Jde o celé číslo v rozsahu od ‘0’, což je úplně průhledný, až po ‘255’, což je zcela neprůhledný.
V příkladu s květinou jsem také použil příkazy ‘ZoomSprite3D()’ a ‘RotateSprite3D()’ ke změně velikosti a otáčení spritů sprite3D. Tyto příkazy jsou velmi snadno pochopitelné a podrobněji se o nich můžete dočíst v nápovědě PureBasicu v oddílu ‘Sprite3D’ (Helpfile:Reference Manual->2D Games Libraries->Sprite3D).
Kvalita spritů Sprite3D
Při používání spritů sprite3D ve vašem programu lze přepínat kvalitu jejich vykreslování. To se provádí příkazem ‘Sprite3DQuality()’. Tento příkaz přijímá jeden parametr, kterým je režim vykreslování všech spritů sprite3D ve vašem programu. Parametr je číselná hodnota, která odpovídá určitému režimu.
Zde jsou definice:
0 : Bez filtrování (rychlejší, ale při přibližování a otáčení velmi „kostičkované“) 1 : Bilineární filtrování (pomalejší, ale pixely se prolínají, takže při přibližování a otáčení vypadají lépe)
V mém příkladu jsem použil ‘Sprite3DQuality(1)’, což zapíná bilineární filtrování a dává spritům při změně velikosti a otáčení pěkný hladký vzhled. Pokud však tento příkaz nepoužijete, je výchozím nastavením kvality v programu ‘0’, což žádné filtrování nezapíná, takže sprity sprite3D při úpravách vypadají „kostičkovaně“.
113D grafika
V této kapitole se budu věnovat 3D grafice a tomu, jak PureBasic k jejímu vykreslování na obrazovku využívá engine OGRE. 3D grafika pracuje s pomyslnými trojrozměrnými modely, z nichž vytváří věrohodné světy působící dojmem šířky, výšky a hloubky; monitor počítače se pak obvykle chápe jako okno, kterým se do těchto 3D světů díváte. To samozřejmě není tak docela přesné. I já si rád představuji, že se monitorem dívám do trojrozměrného světa (zvlášť když hraji 3D hry), ale moc dobře vím, že ve skutečnosti jde o důmyslné matematické rutiny, které na monitor vykreslují pomyslné 3D modely tak, abych měl dojem tří rozměrů. PureBasic se naštěstí díky 3D enginu OGRE postará o veškerou matematiku potřebnou k vykreslení 3D grafiky na obrazovku. Vy tak můžete volat jednoduché vysokoúrovňové příkazy, které provádějí složité trojrozměrné grafické efekty. Programování 3D grafiky v PureBasicu je proto rychlé, zábavné a velmi snadné.
Tato kapitola bohužel nebude vyčerpávajícím výkladem programování 3D grafiky v PureBasicu, protože to by vydalo na samostatnou knihu. Je spíš úvodem do používání příslušných příkazů a nabízí i několik řešení běžných problémů, s nimiž se mohou začátečníci setkat.
Přehled enginu OGRE
Aby bylo možné vykreslit na obrazovku trojrozměrnou grafiku, je třeba, jak už jsem řekl, používat složité matematické rutiny, které počítají tvary modelů, jejich textury, polohy, osvětlení atd. To může být velmi časově náročné a pořádně to zaměstná mozek. Uživatelé PureBasicu však mají štěstí: o všechnu tuto únavnou práci se stará 3D engine OGRE, takže se můžete soustředit na psaní vlastního programu. OGRE (Open source GRaphics Engine) je open source engine pro vykreslování 3D grafiky v reálném čase, který vytvořila a vyvíjí společnost Torus Knot Software Limited. Engine je volně k dispozici na internetu a kdokoli ho může zdarma používat k jakémukoli účelu.
Když hlavní vývojář PureBasicu Frédéric Laboureur prozkoumal zdrojový kód enginu OGRE, usoudil, že je tak skvělé kvality, že ho začlenil do sady příkazů PureBasicu. Samotný engine se dodává spolu s PureBasicem jako dynamicky linkovaná knihovna (DLL) a vestavěná 3D knihovna PureBasicu tvoří jeho obal (wrapper). Jedinou nevýhodou je, že engine OGRE má aplikační programové rozhraní (API) se stovkami příkazů a PureBasic zdaleka nepodporuje všechny. Důvodem jsou jednak určité neslučitelnosti s jazykem, v němž je OGRE naprogramován, jednak čas, který týmu PureBasicu zabere implementace a testování nových příkazů. V budoucnu možná přibudou další, protože tým PureBasicu projevil zájem rozšířit sadu příkazů OGRE dostupnou uživatelům PureBasicu, takže uvidíme. Aktuální sadu příkazů OGRE najdete v nápovědě v oddílu ‘3D Games Libraries’ (Helpfile:Reference Manual->3D Games Libraries).
Formát sítí (mesh) OGRE
Chcete-li v programu pomocí OGRE zobrazovat 3D modely a manipulovat s nimi, musí být tyto modely v určitém formátu. Jde o formát OGRE ‘Mesh’ a soubory modelů mají příponu ‘*.mesh’.
V sekci ke stažení na webu OGRE najdete mnoho nástrojů a zásuvných modulů třetích stran, které rozšiřují funkce předních programů pro 3D modelování. Tyto nástroje umožňují uvedeným programům ukládat a exportovat načtené i nově vytvořené modely do správného formátu mesh. Než se rozhodnete, v jakém programu pro 3D modelování budete své sítě vytvářet, je vlastně dobré se nejprve podívat právě sem.
Formáty textur OGRE
Každý model zobrazovaný 3D enginem potřebuje texturu. Textury nejsou nic jiného než obrázky, které se obtáčejí kolem modelů a vytvářejí povrch, na němž se zobrazují detaily. Někteří lidé textury dokonce opravdu nazývají „skiny“ (kůže). Modely mají někdy i více textur, aby nabízely větší pestrost nebo detailnější vzhled.
Když textury používáte jako povrch svých 3D modelů, musíte použít správný obrazový formát, jinak se textury po zkompilování programu nezobrazí. Na to je důležité pamatovat, protože většina programů pro 3D modelování umí načítat a používat řadu obrazových formátů, které OGRE nepodporuje. Engine OGRE používaný PureBasicem pracuje se soubory Png, Tga a Jpg. Pokud jako textury svých modelů použijete tyto formáty, můžete si být jisti, že vše bude fungovat podle očekávání.
Souřadnicová soustava 3D prostoru OGRE
Při kreslení objektů ve 3D prostoru a manipulaci s nimi potřebujete dobrou souřadnicovou soustavu, abyste mohli sledovat polohu objektu v tomto prostoru. OGRE používá standardní pravotočivou souřadnicovou soustavu ‘x, y, z’; pro ty z vás, kdo nevědí, co to je, to vysvětlím. V takové soustavě je každému ze tří rozměrů přiřazeno jiné písmeno, odtud tedy ‘x, y, z’. Pro práci s touto soustavou je nezbytné vědět, které písmeno patří kterému rozměru. Obr. 39 ukazuje jednotlivé rozměry a písmena, která jsou jim přiřazena. Diagram také ukazuje, jak lze trojrozměrný prostor snadno rozdělit a popsat pomocí tří hodnot. Představíte-li si, že se celá 3D scéna nachází uvnitř této neviditelné krabice, pak lze libovolný bod scény popsat trojicí hodnot ‘x, y, z’.

Obr. 39: Souřadnice 3D prostoru OGRE
Samotné souřadnice jsou docela snadno pochopitelné: každý rozměr lze vyjádřit kladným nebo záporným číslem a engine OGRE je čísluje určitým způsobem. Levá krabice na obr. 39 to znázorňuje pomocí znaků ‘+’ a ‘-’. Představte si, že levý dolní roh vašeho monitoru leží na 3D souřadnicích ‘0, 0, 0’. Souřadnice ‘x’ se pak číselně zvětšuje, čím dál se posouváte doprava, a souřadnice ‘y’ se zvětšuje, čím výš po obrazovce monitoru stoupáte. Souřadnice ‘z’ je trochu jiná: její hodnota roste, čím dál se od obrazovky vzdalujete směrem k sobě. I to ukazuje pravá krabice, když se podíváte na čísla podél jejích stran.
Někteří lidé rádi používají souřadnice ‘0, 0, 0’ jako střed daného 3D prostoru; souřadnice ostatních objektů v tomto světě pak mohou být kladné nebo záporné podle toho, kterým směrem od středu se popisovaný bod nachází. Doufám, že vám tento jednoduchý diagram pomohl pochopit, jak se se souřadnicemi ‘x, y, z’ pracuje.
Identifikátory OGRE API
Když pomocí PureBasicu a OGRE vytváříte 3D grafiku, ve skutečnosti využíváte OGRE API (aplikační programové rozhraní), které vše obstarává v pozadí. PureBasic vám toto „syrové“ OGRE API nezpřístupňuje přímo, ale obaluje jeho příkazy do mnohem přívětivějších basicových příkazů. Občas však přesto budete muset na některé objekty OGRE odkazovat jejich identifikátorem OGRE. Tyto identifikátory jsou obyčejné hodnoty typu Long a velmi se podobají identifikátorům OS, které rovněž vyžaduje určité API (Win32 API). Identifikátory OGRE různých objektů získáte těmito příkazy PureBasicu:
‘MaterialID(#MATERIAL)’ Vrací identifikátor OGRE materiálu zadaného (jako PB číslo) v parametru.
‘MeshID(#MESH)’ Vrací identifikátor OGRE sítě (mesh) zadané (jako PB číslo) v parametru.
‘TextureID(#TEXTURE)’ Vrací identifikátor OGRE textury zadané (jako PB číslo) v parametru.
Pozvolný začátek
V následujícím příkladu vám ukážu, jak inicializovat 3D prostředí, načíst 3D síť, aplikovat na ni texturu a zobrazit ji na obrazovce. Aby to bylo trochu zajímavější, nechal jsem model otáčet a přidal jsem světlo, aby model při zobrazení nepůsobil příliš plochým dojmem.
Enumeration
#MESH
#TEX
#MAT
#ENTITY_INVADER
#LIGHT
#CAMERA_ONE
EndEnumeration
;Set the width, height and bit depth of the screen
;Abbreviated variables are used here due to page width constraints :(
Global ScrW.l = 1024
Global ScrH.l = 768
Global ScrD.l = 32
;Other global variables
Global Quit.b = #False
;Simple error checking procedure
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
;Initialize environment
HandleError(InitEngine3D(), "InitEngine3D() command failed.")
HandleError(InitSprite(), "InitSprite() command failed.")
HandleError(OpenScreen(ScrW, ScrH, ScrD, ""), "Could not open screen.")
HandleError(InitKeyboard(), "InitKeyboard() command failed.")
SetFrameRate(60)
Add3DArchive("Data\", #PB_3DArchive_FileSystem)
HandleError(LoadMesh(#MESH, "Invader.mesh"), "Can't load mesh")
HandleError(LoadTexture(#TEX, "Invader.png"), "Can't load texture")
HandleError(CreateMaterial(#MAT, TextureID(#TEX)), "Can't create Material")
CreateEntity(#ENTITY_INVADER, MeshID(#MESH), MaterialID(#MAT))
CreateLight(#LIGHT, RGB(255,255,255), 0, 5, 0)
CreateCamera(#CAMERA_ONE, 0, 0, 100, 100)
CameraLocate(#CAMERA_ONE, 0, 1, 2.5)
RotateCamera(#CAMERA_ONE, -15, 0, 0)
;Main loop
Repeat
y.l + 2
RotateEntity(#ENTITY_INVADER, 0, y, 0)
RenderWorld()
FlipBuffers()
ExamineKeyboard()
If KeyboardReleased(#PB_Key_Escape)
Quit = #True
EndIf
Until Quit = #True
End
Tento příklad by vám měl být docela užitečný, protože ukazuje všechny kroky nutné k zobrazení 3D modelu na obrazovce. Jako obvykle by měl být kód dost snadno pochopitelný, ale hlavní body projdu, abyste nic nepřehlédli.
Po deklaraci konstant, proměnných a procedur vidíte, že jsem k inicializaci 3D prostředí použil příkaz ‘InitEngine3D()’. Toto volání je nutné k načtení knihovny DLL, která obsahuje 3D engine, z adresáře kompilátoru. Tento soubor DLL obsahuje engine OGRE v předkompilované podobě, kterou lze v takové formě snadno používat ve vašich programech.
Po inicializaci 3D prostředí lze běžným způsobem vytvořit obrazovku: nejprve se inicializuje engine spritů a pak se otevře obrazovka. Musí se to udělat právě v tomto pořadí, jinak dojde k chybě kompilátoru a IDE začne protestovat. Pokud se to stane, budete možná muset program násilně ukončit a před dalším spuštěním přeuspořádat inicializace do správného pořadí.
Vytvoření 3D archivu pro média
Po dokončení všech inicializací můžeme začít používat 3D příkazy a úplně první věc, kterou musíme udělat, je určit „3D archiv“. Jde o cestu, na níž OGRE hledá externí soubory při načítání médií, jako jsou modely, textury, mapy atd. Ve 3D programu musíte mít určen alespoň jeden 3D archiv, jinak kompilátor ohlásí chybu. K určení takového archivu slouží příkaz ‘Add3DArchive()’ (Helpfile:Reference Manual->3D Games Libraries->Engine3D- >Add3DArchive). Příkaz má dva parametry: první je řetězec s cestou k souboru a druhý je vestavěná konstanta, která kompilátoru sděluje, o jaký druh cesty jde. Vestavěné konstanty jsou:
‘#PB_3DArchive_FileSystem’ Sděluje kompilátoru, že zadaná cesta je běžná složka.
‘#PB_3DArchive_Zip’ Sděluje kompilátoru, že zadaná cesta je komprimovaný soubor ZIP.
V příkladu Invader jsem vytvořil 3D archiv pomocí relativní cesty; ta říká enginu OGRE, aby hledal ve stejném adresáři, v jakém je můj program, a v něm ve složce ‘Data\’. Po takovém nastavení musí být všechna potřebná média v této složce. Pak lze používat jednoduché příkazy jako:
...
LoadMesh(#MESH, "Invader.mesh")
...
Když program narazí na takový příkaz, který potřebuje načíst externí médium, OGRE hledá daný soubor ve všech určených 3D archivech; v tomto případě tedy hledá soubor ‘Invader.mesh’ ve složce ‘Data\’.
Chcete-li média uspořádat do přísnějšího systému a vytvořit ve složce ‘Data\’ další podadresáře, klidně to udělejte. Média pak budete muset načítat z jejich nových umístění takto:
...
LoadMesh(#MESH, "Meshes\Invader.mesh")
LoadTexture(#TEX, "Textures\Invader.png")
...
Tím se opět prohledá původní 3D archiv (‘Data\’), v něm se najdou tyto složky (‘Meshes\’ a ‘Textures\’) a média se načtou z nich. Pokud vám tato syntaxe připadá trochu těžkopádná, můžete místo uvádění názvů složek v načítacích příkazech stejně snadno přidat další 3D archivy, v nichž bude OGRE při požadavku na média hledat, například takto:
...
Add3DArchive("Data\", #PB_3DArchive_FileSystem)
Add3DArchive("Data\Meshes\", #PB_3DArchive_FileSystem)
Add3DArchive("Data\Textures\", #PB_3DArchive_FileSystem)
...
Nyní můžeme používat jednodušší načítací příkazy, například:
...
LoadMesh(#MESH, "Invader.mesh")
LoadTexture(#TEX, "Invader.png")
...
OGRE bude nyní tyto soubory hledat ve složkách ‘Data\’, ‘Data\Meshes\’ a ‘Data\Textures\’.
Jako 3D archivy můžete použít i soubory ZIP. To velmi pomáhá při distribuci programu, protože všechna média jsou uzavřena v jediném komprimovaném souboru. Chcete-li to udělat, musíte už při vytváření 3D archivu určit, že jde o soubor ZIP. To zajistíte vestavěnou konstantou ‘#PB_3DArchive_Zip’ jako parametrem typu v příkazu ‘Add3DArchive()’. Pokud máte v souboru ZIP podadresáře, můžete se k nim v načítacích příkazech dostat pomocí standardního zápisu:
...
Add3DArchive("Data.zip", #PB_3DArchive_Zip)
LoadMesh(#MESH, "Meshes\Invader.mesh")
LoadTexture(#TEX, "Textures\Invader.png")
...
Vytvoření 3D entity
Jakmile máte vytvořený 3D archiv, můžete vytvořit objekt, který bude vaše média používat. Tento objekt se bude zobrazovat na obrazovce a pomocí různých vestavěných příkazů s ním lze manipulovat ve třech rozměrech. OGRE takové 3D objekty nazývá „entity“.
Entita je objekt, který tvoří stavební kámen každé hry nebo dema; jde o 3D modely zobrazované na obrazovce, které jako konstrukci používají síť (mesh) a jako povrch texturu. Entitou může být cokoli, co je vymodelováno ve 3D – herní mapy i postavy, které je zabydlují.

Obr. 40: Postup vytvoření 3D entity
Vědět, jak tyto entity správně vytvářet, je nezbytné k zobrazení jakéhokoli 3D modelu na obrazovce. Obr. 40 ukazuje postup správného vytvoření 3D entity a pořadí, v jakém je třeba jednotlivé kroky provést. V předchozím příkladu Invader jsem se tímto vývojovým diagramem řídil přesně. V kódu to vypadá takto:
...
HandleError(LoadMesh(#MESH, "Invader.mesh"), "Can't load mesh")
HandleError(LoadTexture(#TEX, "Invader.png"), "Can't load texture")
HandleError(CreateMaterial(#MAT, TextureID(#TEX)), "Can't create Material")
CreateEntity(#ENTITY_INVADER, MeshID(#MESH), MaterialID(#MAT))
...
Příkazy, kterými se tento postup provádí, jsou jednoduché. Prvním je příkaz ‘LoadMesh()’ (Helpfile:Reference Manual->3D Games Libraries->Mesh->LoadMesh), který má dva parametry.
Prvním je PB číslo, které bude k této síti přiřazeno, a druhým je samotný soubor sítě, který se má načíst z 3D archivu. Dalším příkazem je ‘LoadTexture()’ (Helpfile:Reference Manual->3D Games Libraries->Texture->LoadTexture), který má rovněž dva parametry. Prvním je PB číslo přiřazené nově načtené textuře a druhým název obrázku, který se má jako textura použít. Při používání obrázků jako textur je třeba dát pozor na velikost obrázku v pixelech. Starší grafické karty podporují pouze čtvercové textury, jejichž velikost je mocninou čísla ‘2’. V zájmu maximální kompatibility se staršími kartami doporučuji používat tyto velikosti i vám. Obr. 41 ukazuje standardní velikosti obrázků textur, s nimiž můžete bezpečně vytvářet materiály.
| Šířka v pixelech | Výška v pixelech | Barevná hloubka obrázku |
|---|---|---|
32 |
32 |
8, 16 a 32 |
64 |
64 |
8, 16 a 32 |
128 |
128 |
8, 16 a 32 |
256 |
256 |
8, 16 a 32 |
512 |
512 |
8, 16 a 32 |
1024 |
1024 |
8, 16 a 32 |
Obr. 41: Standardní velikosti obrázků textur — Všechny standardní velikosti textur jsou mocninami čísla ‘2’.
Další příkaz nic nenačítá, pouze vytváří materiál. Materiál je speciální textura ve formátu OGRE, která může mít mnoho různých vlastností. Protože ho vytváříme z textury, jde o nejjednodušší formu materiálu. O pokročilejších materiálech se zmíním o něco později.
Materiál vytvoříte příkazem ‘CreateMaterial()’ (Helpfile:Reference Manual->3D Games Libraries->Material->CreateMaterial), který má dva parametry. Prvním je PB číslo, ke kterému bude materiál přiřazen, a druhým identifikátor OGRE textury. Tento identifikátor lze získat příkazem ‘TextureID()’, jehož parametrem je PB číslo textury.
Jakmile máme potřebné „ingredience“, můžeme vytvořit entitu. K tomu slouží příkaz ‘CreateEntity()’ (Helpfile:Reference Manual->3D Games Libraries->Entity->CreateEntity), a to takto:
...
CreateEntity(#ENTITY_INVADER, MeshID(#MESH), MaterialID(#MAT))
...
Jak je z tohoto řádku vidět, příkaz má tři parametry. Prvním je PB číslo, ke kterému bude entita přiřazena. Druhým je identifikátor OS sítě, ze které chceme entitu vytvořit, a třetím identifikátor OGRE materiálu, kterým chceme síť pokrýt.
Tyto dva identifikátory OGRE lze získat příkazy ‘MeshID()’, resp. ‘MaterialID()’. Oba příkazy mají jako parametr PB číslo a vracejí identifikátor OGRE.
Po vytvoření se 3D entita zařadí do fronty a je připravena k vykreslení na obrazovku na souřadnicích ‘0, 0, 0’ trojrozměrného prostoru. Do té doby budeme pokračovat v rozboru příkladu Invader.
Rozsviťme si cestu
Po vytvoření entity jsem vytvořil světlo, aby byla scéna lépe osvětlena. Toto světlo představuje jasný zdroj osvětlení libovolné barvy, díky němuž entita lépe vynikne. Když vytvoříte 3D prostředí, už obsahuje výchozí míru okolního (ambientního) světla, které však ve skutečnosti nevychází z žádného konkrétního bodu, ale je, jak název napovídá, rozptýlené všude kolem. Entita pak může působit plochým dojmem, protože nelze vypočítat, které strany mají zářit a které mají být ve stínu. Když do scény přidáte světlo, umožníte entitě měnit osvětlení jejích ploch tak, aby simulovala lesk a stín podle toho, kde se světlo nachází vzhledem k použité síti. K vytvoření světla jsem použil příkaz ‘CreateLight()’. (Helpfile:Reference Manual->3D Games Libraries->Light- >CreateLight)
...
CreateLight(#LIGHT, RGB(255,255,255), 0, 5, 0)
...
Tento příkaz má pět parametrů, z nichž první je PB číslo, které bude k tomuto světlu přiřazeno. Druhým je barva vyzařovaného světla, která se zadává jako 24bitová hodnota barvy (lze k tomu použít příkaz ‘RGB()’). Třetí, čtvrtý a pátý parametr jsou nepovinné a určují polohu světla ve 3D prostoru v souřadnicové soustavě ‘x, y, z’. Pokud je nepoužijete, světlo se vytvoří v poloze ‘0, 0, 0’, tedy ve středu 3D prostoru. V příkladu Invader jsem použil polohu ‘0, 5, 0’, která světlo zvedá o ‘5’ jednotek nad podlahu. Grafické znázornění 3D prostoru v souřadnicové soustavě ‘x, y, z’ najdete na obr. 39.
Kamera běží
Teď, když jsou 3D prvky na svém místě, potřebujeme vytvořit průhled (viewport), kterým se budeme na 3D scénu dívat. OGRE tyto průhledy nazývá kamerami, my je však musíme od kamer odlišovat, abychom se vyhnuli zmatkům. Průhled je 2D výřez, který existuje na právě otevřené obrazovce a zobrazuje to, na co se dívá 3D kamera. Vytvořením průhledu kamery se automaticky vytvoří 3D kamera umístěná na souřadnicích ‘0, 0, 0’ a nově vytvořený průhled zobrazuje to, na co se tato 3D kamera dívá. 3D kameru lze libovolně umisťovat a otáčet, průhled je však na obrazovce vždy pevně na stejném místě.
K vytvoření průhledu kamery a automatickému vytvoření 3D kamery v aktuálním 3D světě slouží příkaz ‘CreateCamera()’. (Helpfile:Reference Manual->3D Games Libraries->Camera- >CreateCamera) Příkaz má pět parametrů a prvním je jako obvykle PB číslo, které bude k tomuto objektu kamery přiřazeno. Druhý a třetí parametr jsou polohy ‘x’ a ‘y’ levého horního rohu průhledu na 2D obrazovce. Čtvrtý a pátý parametr jsou šířka a výška průhledu, kterým se na 3D scénu díváme. Při používání tohoto příkazu je velmi důležité rozumět hodnotám, s nimiž pracuje, protože se zásadně liší od většiny příkazů PureBasicu. Hodnoty parametrů příkazu ‘CreateCamera()’ nejsou v pixelech, ale v procentech právě otevřené obrazovky. V příkladu Invader vytvářím kameru takto:
...
CreateCamera(#CAMERA_ONE, 0, 0, 100, 100)
...
Abychom tomu plně porozuměli, rozeberme si toto volání parametr po parametru. Prvním parametrem je PB číslo, které je snadno pochopitelné, takže ho rychle přeskočíme. Druhý parametr je zadán jako ‘0’. To znamená, že se vypočítá jako nula procent šířky obrazovky (‘1024’), tedy ‘0’. Třetí parametr je rovněž zadán jako ‘0’. I to je procento, tentokrát výšky obrazovky (‘768’), takže i tady vychází ‘0’. Čtvrtý parametr je zadán jako ‘100’. To odpovídá sto procentům šířky obrazovky, v tomto případě ‘1024’. Pátý parametr je také zadán jako ‘100’, což odpovídá sto procentům výšky obrazovky, tedy ‘768’. Celkově tak dostáváme pro tento průhled kamery obrazovkové souřadnice ‘x=0, y=0, width=1024, height=768’, které zcela pokrývají obrazovku, takže máme do 3D světa celoobrazovkový průhled kamery.
U tohoto příkazu se místo pixelů používají procenta proto, aby polohy průhledů kamer byly zcela nezávislé na velikosti obrazovky. Je to snadný způsob, jak zajistit správné umístění kamer při různých rozlišeních obrazovky. Pokud například vytvořím průhled kamery o poloviční šířce a výšce obrazovky, bude mít tento průhled vždy poloviční šířku a výšku obrazovky bez ohledu na použité rozlišení.
Více průhledů kamer
Procenta jsou také dobrým způsobem, jak podporovat více průhledů kamer současně. Představte si, že potřebujete naprogramovat hru s obrazovkou rozdělenou na dvě nebo čtyři části; pak budete potřebovat dobrý způsob, jak vypočítat velikost průhledu pro každé rozlišení obrazovky (pokud si ho uživatel může zvolit). V PureBasicu se o to díky procentům vše postará za vás, protože každý průhled kamery vždy zabírá stejnou část obrazovky bez ohledu na použité rozlišení. Při vytváření více kamer je také velmi důležité pořadí jejich vytvoření. Všechny průhledy vytvořené v kódu později se vždy zobrazí nad průhledy vytvořenými dříve. Podívejte se například na tento kód:
...
CreateCamera(#CAMERA_ONE, 0, 0, 100, 100)
CreateCamera(#CAMERA_ONE, 75, 0, 25, 25)
...
Zde vytvářím jeden průhled kamery přes celou obrazovku a další průhled kamery nad ním, v pravém horním rohu. Tento menší průhled bude umístěn ve třech čtvrtinách šířky obrazovky a jeho šířka i výška budou čtvrtinou aktuální obrazovky. Kdyby byl menší průhled vytvořen jako první, zakryl by ho větší průhled kamery.
Každou z více vytvořených kamer lze také ve 3D světě nezávisle posouvat a otáčet, takže uživatelé mohou na obrazovce vidět váš svět z více pohledů. Druhou kameru můžete například použít jako zpětné zrcátko ve 3D závodní hře z pohledu první osoby. Průhled této kamery by mohl být umístěn v horní části 2D obrazovky a jeho 3D kamera by mířila dozadu za auto.
Posouvání a otáčení kamer
Vytvořením průhledu se zároveň automaticky vytvoří 3D kamera, kterou lze ve 3D scéně libovolně otáčet a posouvat. Tuto 3D kameru můžete pomocí polohových příkazů v hlavním cyklu přesunout a umístit kamkoli a kdykoli budete chtít. V příkladu Invader jsem k doladění polohy kamery použil dva příkazy, a to takto:
...
CameraLocate(#CAMERA_ONE, 0, 1, 2.5)
RotateCamera(#CAMERA_ONE, -15, 0, 0)
...
První příkaz, ‘CameraLocate()’, přesune kameru na absolutní polohu ve 3D scéně a má čtyři parametry. Prvním parametrem je PB číslo kamery, kterou chcete přesunout, druhý, třetí a čtvrtý parametr jsou souřadnice ‘x, y, z’ místa, kam ji chcete přesunout. Druhým použitým příkazem je ‘RotateCamera()’, který kameru otáčí kolem zadané osy. I tento příkaz má čtyři parametry, přičemž prvním je PB číslo kamery, kterou chcete otočit. Druhý, třetí a čtvrtý parametr jsou relativní úhly otočení kolem jednotlivých os ‘x, y, z’.

Obr. 42: Otáčení ve 3D prostoru — Šipky ukazují otáčení při kladných hodnotách
Na obr. 42 vidíte, která osa odpovídá kterému druhu otáčení. Pokud bych například chtěl, aby se kamera natáčela ze strany na stranu, použil bych otáčení kolem osy ‘y’. Při zadávání hodnot ‘x, y, z’ v jakémkoli příkazu pro 3D otáčení mohou být čísla záporná i kladná, což umožňuje otáčení obrátit. Šipky otáčení na obr. 42 ukazují směr, kterým se bude otáčet při použití kladných čísel. Při použití záporných čísel se otáčení obrátí. Malý příklad: pokud bych chtěl kameru natočit o čtyřicet pět stupňů doleva, zadal bych do parametru otočení ‘y’ hodnotu ‘45’. Pokud bych ji chtěl natočit o čtyřicet pět stupňů doprava, použil bych pro otočení ‘y’ hodnotu ‘-45’.
Všechny příkazy pro posun a otáčení lze k otáčení a posouvání kamer či jiných entit používat uvnitř hlavního cyklu i mimo něj. Použití mimo hlavní cyklus se hodí, když potřebujete nastavit polohu statických objektů. Použití uvnitř hlavního cyklu umožňuje posouvat a otáčet entity v reálném čase, často v reakci na vstup od uživatele.
Všechny příkazy PureBasicu, které pracují s 3D otáčením, používají stejnou soustavu ‘x, y, z’. Když se podíváte do hlavního cyklu příkladu Invader, uvidíte, že jsem k otáčení entity vetřelce za běhu programu použil příkaz ‘RotateEntity()’ (Helpfile:Reference Manual->3D Games Libraries->Entity->RotateEntity). I tento příkaz používá stejné osy otáčení, jaké jsou popsány na obr. 42. Při používání jakéhokoli příkazu s 3D otáčením vám obr. 42 může posloužit jako vodítko, jaké otočení je potřeba.
Více o příkazech pro práci s kamerami OGRE se dozvíte v nápovědě PureBasicu. (Helpfile:Reference Manual->3D Games Libraries->Camera)
Vykreslení 3D světa na obrazovku
Při vytváření 3D světa pomocí 3D příkazů se – na rozdíl od 2D příkazů – vaše sítě, světla, částice atd. nevykreslují na obrazovku okamžitě. Místo toho existují v paměti a čekají, až budou zachyceny a vykresleny. Jakmile je ve 3D scéně vše na svém místě, musíte příkazem ‘RenderWorld()’ (Helpfile:Reference Manual->3D Games Libraries->Engine3D->RenderWorld) dát všem existujícím 3D kamerám pokyn, aby každá pořídila snímek toho, na co míří. Tyto snímky se pak vykreslí do zadního bufferu, přičemž se přizpůsobí velikosti a poloze průhledu příslušné kamery. Po zavolání příkazu ‘FlipBuffers()’ se zadní buffer přepne dopředu a 3D scéna se zobrazí na obrazovce počítače. V praxi to můžete vidět v příkladu Invader. Pokud příkaz ‘RenderWorld()’ nepoužijete, do zadního bufferu se nevykreslí žádná 3D grafika. Doufám, že je teď příklad Invader plně vysvětlen a že s ním jako vodítkem dokážete načítat a zobrazovat vlastní modely.
Jednoduchá kamera z pohledu první osoby
Po spuštění příkladu Invader asi toužíte napsat vlastní 3D program, nebo se dokonce pustit do psaní hry. Když jsem poprvé viděl 3D schopnosti PureBasicu, napadlo mě jako první: zajímalo by mě, jestli bych dokázal udělat střílečku z pohledu první osoby. Výsledkem je následující kód, který ukazuje, jak naprogramovat kameru z pohledu první osoby ve 3D světě. Je pravda, že nejde o plnohodnotnou hru, to zdaleka ne, ale začátečníkům může posloužit jako výukový příklad. Kód ukazuje, jak vytvořit terén a pohybovat kamerou pomocí kurzorových kláves a myši:
Enumeration
#TEXTURE_GLOBAL
#TEXTURE_DETAIL
#MATERIAL_TERRAIN
#CAMERA_ONE
EndEnumeration
#MOVEMENT_SPEED = 1
;Set the width, height and bit depth of the screen
;Abbreviated variables are used here due to page width constraints :(
Global ScrW.l = 1024
Global ScrH.l = 768
Global ScrD.l = 32
;Other global variables
Global Quit.b = #False
Global MouseXRotation.f,MouseYRotation.f,KeyX.f,KeyZ.f,DesiredCameraHeight.f
Global CurrentCamXPos.f = 545
Global CurrentCamZPos.f = 280
;Simple error checking procedure
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
;Initialize environment
HandleError(InitEngine3D(), "InitEngine3D() command failed.")
HandleError(InitSprite(), "InitSprite() command failed.")
HandleError(OpenScreen(ScrW, ScrH, ScrD, ""), "Could not open screen.")
HandleError(InitMouse(), "InitMouse() command failed.")
HandleError(InitKeyboard(), "InitKeyboard() command failed.")
SetFrameRate(60)
;Set 3D Archive
Add3DArchive("Data\", #PB_3DArchive_FileSystem)
;Create Terrain
HandleError(LoadTexture(#TEXTURE_GLOBAL, "Global.png"), "Can't load texture")
HandleError(LoadTexture(#TEXTURE_DETAIL, "Detail.png"), "Can't load texture")
CreateMaterial(#MATERIAL_TERRAIN, TextureID(#TEXTURE_GLOBAL))
AddMaterialLayer(#MATERIAL_TERRAIN,TextureID(#TEXTURE_DETAIL),#PB_Material_Add)
CreateTerrain("Terrain.png", MaterialID(#MATERIAL_TERRAIN), 1, 2, 1)
;Create Viewport and 3D Camera
CreateCamera(#CAMERA_ONE, 0, 0, 100, 100)
DesiredCameraHeight.f = TerrainHeight(CurrentCamXPos, CurrentCamZPos) + 10
CameraLocate(#CAMERA_ONE,CurrentCamXPos,DesiredCameraHeight,CurrentCamZPos)
;Main loop
Repeat
;Update Mouse
If ExamineMouse()
MouseYRotation = -MouseDeltaX() / 10
MouseXRotation = MouseDeltaY() / 10
EndIf
RotateCamera(#CAMERA_ONE, MouseXRotation, MouseYRotation, 0)
;Update Key Presses and position the Camera accordingly
If ExamineKeyboard()
If KeyboardPushed(#PB_Key_Left) : KeyX = -#MOVEMENT_SPEED : EndIf
If KeyboardPushed(#PB_Key_Right) : KeyX = #MOVEMENT_SPEED : EndIf
If KeyboardPushed(#PB_Key_Up) : KeyZ = -#MOVEMENT_SPEED : EndIf
If KeyboardPushed(#PB_Key_Down) : KeyZ = #MOVEMENT_SPEED : EndIf
MoveCamera(#CAMERA_ONE, KeyX, 0, KeyZ)
KeyX = 0
KeyZ = 0
CurrentCamXPos.f = CameraX(#CAMERA_ONE)
CurrentCamZPos.f = CameraZ(#CAMERA_ONE)
DesiredCameraHeight.f = TerrainHeight(CurrentCamXPos, CurrentCamZPos) + 10
CameraLocate(#CAMERA_ONE,CurrentCamXPos,DesiredCameraHeight,CurrentCamZPos)
EndIf
RenderWorld()
FlipBuffers()
If KeyboardReleased(#PB_Key_Escape)
Quit = #True
EndIf
Until Quit = #True
End
Tento příklad se podobá příkladu Invader v tom, že nastavuje 3D prostředí stejným způsobem, takže by vám to už mělo být povědomé. Hlavní rozdíl spočívá v tom, že jsem vytvořil terén, který slouží jako povrch, po němž se lze procházet.
Terény
Chcete-li vytvořit terén, musíte nejprve vytvořit vícevrstvý materiál, který poslouží jako povrch terénu. Vícevrstvý materiál vytvoříte tak, že vytvoříte běžný materiál a pak na něj aplikujete další vrstvu materiálu. V příkladu FPS najdete v kódu tyto řádky:
...
HandleError(LoadTexture(#TEXTURE_GLOBAL, "Global.png"), "Can't load texture")
HandleError(LoadTexture(#TEXTURE_DETAIL, "Detail.png"), "Can't load texture")
...
Tyto dva příkazy načtou pomocí příkazu ‘LoadTexture()’ dva obrázky ve formátu Png jako standardní textury. První obrázek, ‘Global.png’, bude hlavním materiálem, který se jako obrovská přikrývka rozprostře přes celý povrch nového terénu. Druhý obrázek, ‘Detail.png’, je doplňková textura, která se s první prolne a dlaždicovitě se opakuje po celém terénu, aby mu dodala více detailů. K samotnému vytvoření vícevrstvého materiálu jsem použil tyto dva příkazy:
...
CreateMaterial(#MATERIAL_TERRAIN, TextureID(#TEXTURE_GLOBAL))
AddMaterialLayer(#MATERIAL_TERRAIN,TextureID(#TEXTURE_DETAIL),#PB_Material_Add)
...
První řádek vytváří standardní jednovrstvý materiál, jak bylo vysvětleno u příkladu Invader. Druhý příkaz přidává další texturu jako druhou vrstvu dříve vytvořeného materiálu. Příkaz ‘AddMaterialLayer()’ (Helpfile:Reference Manual->3D Games Libraries->Material- >AddMaterialLayer) má tři parametry. Prvním je PB číslo materiálu, do něhož chcete vrstvu přidat. Druhým je identifikátor OGRE textury, kterou chcete přidat jako další vrstvu. Třetím parametrem je režim prolnutí nové textury se stávajícím materiálem. Režim prolnutí lze zadat jednou ze čtyř vestavěných konstant:
‘#PB_Material_Add’ Prolne novou vrstvu materiálu se stávající operací „Add“ (sečtení).
‘#PB_Material_Replace’ Prolne novou vrstvu materiálu se stávající operací „Replace“ (nahrazení).
‘#PB_Material_AlphaBlend’ Prolne novou vrstvu materiálu se stávající operací „Add“ (sečtení). Tento režim navíc využívá informace alfa kanálu obsažené v textuře. Podporovány jsou pouze textury ve formátech Png a Tga.
‘#PB_Material_Modulate’ Prolne novou vrstvu materiálu se stávající operací „Modulate“ (modulace).
Jakmile máte vytvořený vícevrstvý materiál, můžete vytvořit terén příkazem ‘CreateTerrain()’ (Helpfile:Reference Manual->3D Games Libraries->Terrain- >CreateTerrain). V příkladu FPS jsem ho vytvořil takto:
...
CreateTerrain("Terrain.png", MaterialID(#MATERIAL_TERRAIN), 1, 2, 1)
...
Příkaz ‘CreateTerrain()’ má šest parametrů. Prvním parametrem je název obrázku, který se použije jako výšková mapa terénu. Druhým je identifikátor OGRE vícevrstvého materiálu, který poslouží jako povrch terénu. Třetí, čtvrtý a pátý parametr jsou nepovinné a slouží ke změně měřítka terénu v ose ‘x’, ‘y’ nebo ‘z’. Jde o násobitele: použijete-li hodnotu ‘1’, zůstane terén v dané ose stejně velký, při hodnotě ‘2’ se daný rozměr zdvojnásobí atd. Šestý a poslední parametr je nepovinná hodnota kvality terénu v rozsahu od ‘1’ do ‘20’. Čím nižší předaná hodnota, tím vyšší kvalita vykreslení terénu a tím vyšší zatížení procesoru při jeho kreslení. Vyšší hodnoty mají opačný účinek.
Podrobnosti o výškových mapách terénu
Při vytváření terénu z obrázku výškové mapy musíte při tvorbě tohoto obrázku dodržet několik pravidel. Zaprvé musí být obrázek čtvercový, protože OGRE v PureBasicu umí vytvářet pouze čtvercové terény (při vytváření však můžete změnit jejich měřítko). Zadruhé musí být obrázek uložen v 8bitovém formátu ve stupních šedi, aby poskytoval ‘256’ úrovní šedé. Čistě černá bude chápána jako výška ‘0’, zatímco čistě bílá jako výška ‘255’. Zatřetí musí mít obrázek určitou velikost, protože ta zároveň určuje počet trojúhelníků (polygonů) použitých v síti terénu. Velikost obrázku výškové mapy by měla odpovídat běžné velikosti textury, ale v každém rozměru o jeden pixel větší. Tím se zajistí, že výška terénu se z obrázku vypočítá správně. Obr. 43 ukazuje doporučené velikosti obrázků výškových map a počet trojúhelníků (polygonů), z nichž se síť terénu vygeneruje.
| Šířka | Výška | Počet polygonů terénu |
|---|---|---|
65 |
65 |
8192 |
129 |
129 |
32768 |
257 |
257 |
131072 |
513 |
513 |
524288 |
1025 |
1025 |
2097152 |
Obr. 43: Velikosti obrázků výškových map terénu — Všechny velikosti textur výškových map jsou mocninami čísla ‘2’ + ‘1’.
Z obr. 43 je vidět, jak počet trojúhelníků roste, když použijete obrázek výškové mapy s vyšším rozlišením. Výšková mapa s vyšším rozlišením může zpřesnit vykreslení terénu podle výškové mapy, ovšem za cenu nižšího výkonu. Velká rozlišení výškových map, například ‘1025 x 1025’, se kvůli vysokému počtu polygonů výsledného terénu obvykle nepoužívají.
Terény a automatická „úroveň detailů“
Všechny terény vytvořené v PureBasicu pomocí OGRE mají automatickou a dynamickou úroveň detailů (Level Of Detail). To znamená, že když terén není vidět kamerou nebo když některé útvary terénu zakrývají jiné (například kopce), skryté části terénu se nevykreslují. Když se navíc kamera od nějakého útvaru terénu vzdálí na určitou vzdálenost, tento útvar automaticky sníží svou složitost, čímž klesne počet polygonů na obrazovce a usnadní se vykreslení rozsáhlejší scény. V příkladu FPS si to snadno vyzkoušíte: zaměřte se na libovolný kopec, couvejte od něj a sledujte jeho strukturu. Uvidíte, že kopec sníží svou složitost, jakmile je od kamery daleko.
Pohled z první osoby
Jakmile je terén vytvořen a příklad FPS běží, použil jsem různé příkazy, kterými získávám informace z myši a klávesnice, a podle nich pak kameru nastavuji. Příkazy pro myš jsou:
‘MouseDeltaX()’ (Helpfile:Reference Manual->2D Games Libraries->Mouse-> MouseDeltaX) Tento příkaz vrací počet pixelů, o který se myš od posledního průchodu hlavním cyklem posunula po obrazovkové ose ‘X’ (zleva doprava).
‘MouseDeltaY()’ (Helpfile:Reference Manual->2D Games Libraries->Mouse-> MouseDeltaY) Tento příkaz vrací počet pixelů, o který se myš od posledního průchodu hlavním cyklem posunula po obrazovkové ose ‘Y’ (nahoru a dolů).
Tyto dvě vrácené hodnoty se pak dosadí do parametrů ‘x’ a ‘y’ příkazu ‘RotateCamera()’, takže se 3D kamera otočí o tolik, o kolik se pohne myš. Takto vypadá skutečný kód:
...
If ExamineMouse()
MouseYRotation = -MouseDeltaX() / 10
MouseXRotation = MouseDeltaY() / 10
EndIf
RotateCamera(#CAMERA_ONE, MouseXRotation, MouseYRotation, 0)
...
Tím vznikne kamera ovládaná myší. Všimněte si znaménka minus před příkazem ‘MouseDeltaX()’. Je tam proto, aby obrátilo hodnotu vracenou tímto příkazem, protože, jak si jistě vzpomínáte, k otočení doleva potřebujete kladné hodnoty a k otočení doprava záporné. Příkaz ‘MouseDeltaX()’ je vrací obráceně, protože vrací 2D souřadnice obrazovky, a ne úhly otočení.
K pohybu kamery ve 3D světě, aby to vypadalo, že putujeme po terénu, jsem použil takovýto kód:
...
If ExamineKeyboard()
If KeyboardPushed(#PB_Key_Left) : KeyX = -#MOVEMENT_SPEED : EndIf
If KeyboardPushed(#PB_Key_Right) : KeyX = #MOVEMENT_SPEED : EndIf
If KeyboardPushed(#PB_Key_Up) : KeyZ = -#MOVEMENT_SPEED : EndIf
If KeyboardPushed(#PB_Key_Down) : KeyZ = #MOVEMENT_SPEED : EndIf
MoveCamera(#CAMERA_ONE, KeyX, 0, KeyZ)
KeyX = 0
KeyZ = 0
CurrentCamXPos.f = CameraX(#CAMERA_ONE)
CurrentCamZPos.f = CameraZ(#CAMERA_ONE)
DesiredCameraHeight.f = TerrainHeight(CurrentCamXPos, CurrentCamZPos) + 10
CameraLocate(#CAMERA_ONE,CurrentCamXPos,DesiredCameraHeight,CurrentCamZPos)
EndIf
...
Zde příkazem ‘KeyboardPushed()’ testuji, zda je nějaká klávesa držena stisknutá. Pokud ano, přiřadím příslušným proměnným hodnotu a ty pak použiji jako parametry příkazu ‘MoveCamera()’. Ten pohybuje kamerou po 3D světě, nebere však v úvahu výšku terénu.
Abych kameru posouval nahoru a dolů tak, aby byla od terénu vždy v pevně dané vzdálenosti, používám příkaz ‘CameraLocate()’. Protože tento příkaz pracuje s absolutními hodnotami, potřebuji zjistit aktuální souřadnice ‘x’ a ‘z’ kamery, abych je mohl při změně hodnoty ‘y’ znovu nastavit. Aktuální souřadnice kamery získám příkazy ‘CameraX()’ a ‘CameraZ()’ (Helpfile:Reference Manual->3D Games Libraries->Camera). Oba příkazy mají jediný parametr, a to PB číslo kamery, z níž se mají hodnoty zjistit. Jakmile tyto hodnoty mám, potřebuji zjistit, jaká je na těchto souřadnicích výška terénu. K tomu používám příkaz ‘TerrainHeight()’ (Helpfile:Reference Manual->3D Games Libraries->Terrain->TerrainHeight). Tento příkaz má dva parametry: souřadnice ‘x’ a ‘z’ bodu terénu, jehož výšku chceme znát. Jakmile tuto hodnotu mám, přičtu k ní ‘10’, abych kameru mírně zvedl nad zem, a mám tak všechny tři 3D souřadnice potřebné pro příkaz ‘CameraLocate()’. Při každém průchodu hlavním cyklem se vypočítá nová souřadnice ‘y’, která upravuje výšku kamery při pohybu po terénu.
Trochu pokročilejší
V této části se budu věnovat o něco pokročilejším možnostem OGRE a PureBasicu. Patří k nim částice a skripty materiálů. Částice se ve 3D enginech používají k nejrůznějším účelům, hlavně k vytváření náhodných efektů, jako je sníh, déšť, oheň a kouř. V následujícím příkladu jsem je použil k simulaci ohně. Skripty materiálů umožňují soustředit všechny vlastnosti materiálu do jediného souboru skriptu materiálu, takže je váš zdrojový kód v PureBasicu mnohem přehlednější a čitelnější. Díky skriptům materiálů můžete načíst síť, která obsahuje odkaz na materiál, a pokud je tento materiál uveden v souboru skriptu, síť ho použije, aniž byste museli ve zdrojovém kódu dělat cokoli dalšího. To usnadňuje práci a umožňuje další přizpůsobení, protože některé pokročilé vlastnosti materiálů jsou dostupné jen prostřednictvím skriptů. V následujícím příkladu jsem pomocí skriptu materiálu určil, že načtená síť používá sférické mapování textury, což jinak k dispozici není. Zde je kód:
Enumeration
#MESH
#TEXTURE
#MATERIAL
#ENTITY
#CAMERA_ONE
#LIGHT_ONE
#LIGHT_TWO
#PARTICLE_ONE
EndEnumeration
;Set the width, height and bit depth of the screen
;Abbreviated variables are used here due to page width constraints :(
Global ScrW.l = 1024
Global ScrH.l = 768
Global ScrD.l = 32
;Other global variables
Global Quit.b = #False
;Simple error checking procedure
Procedure HandleError(Result.l, Text.s)
If Result = 0
MessageRequester("Error", Text, #PB_MessageRequester_Ok)
End
EndIf
EndProcedure
;Convert Degrees to Radians
Procedure.f DegToRad(Angle.f)
ProcedureReturn Angle.f * #PI / 180
EndProcedure
;Initialize environment
HandleError(InitEngine3D(), "InitEngine3D() command failed.")
HandleError(InitSprite(), "InitSprite() command failed.")
HandleError(OpenScreen(ScrW, ScrH, ScrD, ""), "Could not open screen.")
HandleError(InitKeyboard(), "InitKeyboard() command failed.")
SetFrameRate(60)
Add3DArchive("Data\", #PB_3DArchive_FileSystem)
Parse3DScripts()
CreateEntity(#ENTITY, LoadMesh(#MESH, "Statue.mesh"), #PB_Material_None)
LoadTexture(#TEXTURE, "Flame.png")
CreateMaterial(#MATERIAL, TextureID(#TEXTURE))
DisableMaterialLighting(#MATERIAL, 1)
MaterialBlendingMode(#MATERIAL, #PB_Material_Add)
CreateParticleEmitter(#PARTICLE_ONE, 2, 2, 0,#PB_Particle_Point,12.9, 69, 15.7)
ParticleSize(#PARTICLE_ONE, 5, 5)
ParticleMaterial(#PARTICLE_ONE, MaterialID(#MATERIAL))
ParticleEmissionRate(#PARTICLE_ONE, 50)
ParticleTimeToLive(#PARTICLE_ONE, 0.25, 0.25)
ParticleColorRange(#PARTICLE_ONE, RGB(255, 0, 0), RGB(255, 200, 0))
ParticleVelocity(#PARTICLE_ONE, 1, 10)
CreateLight(#LIGHT_ONE, RGB(255,255,255))
CreateLight(#LIGHT_TWO, RGB(255, 200, 0), 12.9, 72, 15.7)
CreateCamera(#CAMERA_ONE, 0, 0, 100, 100)
;Main loop
Repeat
Angle.f + 0.5
PosX.f = 75 * Sin(DegToRad(Angle))
PosY.f = (50 * Sin(DegToRad(Angle / 2))) + 65
PosZ.f = 75 * Cos(DegToRad(Angle))
LightLocate(#LIGHT_ONE, PosX, PosY + 100, PosZ)
LightColor(#LIGHT_TWO, RGB(255, Random(200), 0))
CameraLocate(#CAMERA_ONE, PosX, PosY, PosZ)
CameraLookAt(#CAMERA_ONE, 0, 60, 0)
RenderWorld()
FlipBuffers()
ExamineKeyboard()
If KeyboardReleased(#PB_Key_Escape)
Quit = #True
EndIf
Until Quit = #True
End
Tento příklad by měl být srozumitelný, protože se drží stylu několika předchozích 3D příkladů. Nejprve inicializujeme prostředí, otevřeme obrazovku a určíme 3D archiv. Pak použiji nový příkaz, ‘Parse3DScripts()’. Po zavolání tento příkaz prohledá všechny určené 3D archivy a načte všechny soubory skriptů, které v nich najde. Existuje mnoho typů skriptů OGRE, ale v současné době PureBasic podporuje pouze skripty materiálů.
Skripty materiálů
Po zavolání příkazu ‘Parse3DScripts()’ se ze všech určených 3D archivů načtou a analyzují všechny skripty materiálů. To znamená, že se u každého skriptu zjistí, jaké definice materiálů obsahuje, a vlastnosti každého materiálu se pak načtou do paměti. Pokud se později načte síť, která používá materiál se stejným názvem, jaký je uveden ve skriptu materiálu, použije textury a vlastnosti definované ve skriptu. Názvy použitých materiálů lze uložit spolu se sítí při ukládání z programu pro 3D modelování. Materiál tak můžete určit už při tvorbě sítě a pak ji snadno načíst do 3D programu v PureBasicu se zachováním všech vlastností materiálu.
Skripty materiálů lze psát ručně v jednoduchém textovém editoru, nebo je lze z některých programů pro 3D modelování exportovat spolu se sítí. Syntaxe skriptů materiálů je popsána na webu OGRE, jehož adresu najdete v příloze A (Užitečné internetové odkazy). Zde je skript materiálu, který jsem použil pro model sochy v příkladu Statue; soubor skriptu se jmenuje ‘Statue.material’:
material Statue
{
technique
{
pass
{
texture_unit
{
texture SphereMap.png
env_map spherical
filtering trilinear
}
}
}
}
Tento jednoduchý soubor popisuje materiál ‘Statue’, přesněji řečeno říká enginu OGRE, aby jako texturu použil obrázek ‘SphereMap.png’, použil sférické mapování textury a trilineární filtrování. Aby síť sochy tento materiál používala, zadal jsem jeho název v programu pro 3D modelování.
Když se podíváte na příklad Statue, uvidíte, že plně otexturovanou entitu vytvářím jediným řádkem kódu, zatímco v příkladu Invader jsem musel použít několik řádků k načtení textur, vytvoření materiálů atd. Ten řádek zní:
...
CreateEntity(#ENTITY, LoadMesh(#MESH, "Statue.mesh"), #PB_Material_None)
...
Tím se načte soubor ‘Statue.mesh’ a použije se materiál definovaný ve skriptu materiálu. Protože materiál definujeme skriptem materiálu, musí být při použití příkazu ‘CreateEntity()’ parametr ID materiálu roven ‘#PB_Material_None’. Tato vestavěná konstanta zajistí, že entitě nebude přiřazen žádný jiný materiál než ten, který je definován ve skriptu.
Částicové efekty
Vytváření částic může být dost složitá záležitost, zvlášť když se s nimi dá vytvořit tolik různých efektů. PureBasic v současnosti nabízí osmnáct příkazů, kterými lze částice přizpůsobit téměř jakýmkoli představitelným způsobem.
Částice, stejně jako sítě, potřebují ke správnému zobrazení přiřazený materiál; v příkladu Statue jsem jeden vytvořil s obrázkem ‘Flame.png’ jako texturou. Tento obrázek se použije pro každou jednotlivou částici, která opustí emitor. Emitor částic je bod ve 3D prostoru, z něhož jsou vyzařovány všechny částice. V příkladu jsem ho definoval takto:
...
CreateParticleEmitter(#PARTICLE_ONE, 2, 2, 0,#PB_Particle_Point,12.9, 69, 15.7)
...
Příkaz ‘CreateParticleEmitter’ (Helpfile:Reference Manual->3D Games Libraries->Particle- >CreateParticleEmitter) má osm parametrů. Prvním je jako obvykle PB číslo, které bude k tomuto emitoru částic přiřazeno. Druhý, třetí a čtvrtý parametr udávají, jak daleko od středového bodu jsou částice vyzařovány v osách ‘x’, ‘y’ a ‘z’. Pátým je režim částic, který může být buď ‘#PB_Particle_Point’, nebo ‘#PB_Particle_Box’. Bodové emitory se obvykle používají pro oheň, kouř apod., kdy částice vycházejí z určitého bodu, zatímco kvádrové emitory se obvykle používají pro plošné efekty, jako je déšť nebo sníh. Poslední tři parametry jsou souřadnice ve 3D světě, které určují, kam bude emitor umístěn. I tyto tři parametry jsou nepovinné; pokud je nepoužijete, emitor se umístí na ‘0, 0, 0’. Emitor můžete později přesunout příkazem ‘ParticleEmitterLocate()’.
Ostatní částicové příkazy použité v příkladu Statue slouží ke konfiguraci emitoru částic tak, aby vytvářel požadovaný efekt. Jsou to tyto příkazy:
...
ParticleSize(#PARTICLE_ONE, 5, 5)
ParticleMaterial(#PARTICLE_ONE, MaterialID(#MATERIAL))
ParticleEmissionRate(#PARTICLE_ONE, 50)
ParticleTimeToLive(#PARTICLE_ONE, 0.25, 0.25)
ParticleColorRange(#PARTICLE_ONE, RGB(255, 0, 0), RGB(255, 200, 0))
ParticleVelocity(#PARTICLE_ONE, 1, 10)
...
Všechny tyto příkazy jsou samovysvětlující a umožňují vytvořit tisíce různých efektů. Podrobněji si o nich můžete přečíst v nápovědě PureBasicu (Helpfile:Reference Manual->3D Games Libraries->Particle).
Pohled na určitý bod
V příkladu Statue jsem použil další nový příkaz pro kameru, který může být velmi užitečný. Je to příkaz ‘CameraLookAt()’. (Helpfile:Reference Manual->3D Games Libraries->Camera) Pomocí něj lze jediným příkazem natočit kameru tak, aby se dívala na libovolný bod ve 3D prostoru. V příkladu jsem ho použil takto:
...
CameraLookAt(#CAMERA_ONE, 0, 60, 0)
...
Prvním parametrem je PB číslo kamery, kterou chcete natočit. Druhý, třetí a čtvrtý parametr jsou souřadnice ‘x, y, z’ místa, na které se má kamera dívat. V mém příkladu díky tomu kamera hledí přímo do středu sochy, zatímco kolem ní krouží.
Dynamické osvětlení
V příkladu Statue jsem také použil několik triků s osvětlením, které scénu zatraktivní. Prvním je bílé světlo, které neustále následuje kameru. Díky němu je síť sochy vždy plně osvětlená. Druhým trikem je mihotavé světlo umístěné těsně nad emitorem částic, které mění barvu při každém průchodu hlavním cyklem. Dosahuji toho tak, že do hlavního cyklu umístím tento příkaz:
...
LightColor(#LIGHT_TWO, RGB(255, Random(200), 0))
...
Tento příkaz při každém použití změní barvu zadaného světla. V hlavním cyklu příkladu Statue náhodně měním zelenou složku barvy tohoto světla v rozsahu hodnot ‘0’ až ‘200’. Protože světlo už má červenou složku nastavenou na ‘255’ a modrou na ‘0’, bude světlo mihotavě přecházet od červené po žlutou. Jakmile program spustíte, uvidíte, jak barva mihotavě přebíhá po tváři sochy.
Několik triků, jako jsou skripty materiálů pro tvorbu složitějších materiálů a částice pro efektní efekty, pomůže vaší hře nebo demu vyniknout nad ostatními kvalitou i stylem. Ukázal jsem vám jen stručně, co tyto příkazy dokážou; zbytek je na vás. Chcete-li se o těchto příkazech dozvědět více, zkuste psát vlastní 3D programy a experimentujte s různými nastaveními, zejména u částicových příkazů.
Co dál?
Doufám, že pro vás tato kapitola o programování 3D grafiky v PureBasicu byla užitečná, i když byla stručná. Doufám také, že vás inspirovala, abyste se dozvěděli více o tom, čeho PureBasic s enginem OGRE dokáže dosáhnout. Doporučuji pročíst celý oddíl ‘3D Games Libraries’ v nápovědě PureBasicu, abyste plně pochopili, co vše PureBasic nabízí. Z prostorových a časových důvodů tato kapitola nepokryla všechny příkazy, které tam najdete, ale věřím, že jsem vám poskytl dobrý úvod do začátků; zbytek je teď na vás.
Naučit se programovat 3D grafiku může být dost obtížné, protože se to někdy opírá o složité matematické rutiny a dovednosti v 3D modelování. Matematika použitá v příkladech této kapitoly je docela elementární a myslím, že ji zná asi každý student vysoké školy. Přesto bych všem začátečníkům v programování 3D grafiky dal jednu radu: naučte se matematiku. Při programování 3D grafiky přijdou chvíle, kdy se zaseknete na mrtvém bodě, protože vaše matematické znalosti zaostanou za vašimi programátorskými schopnostmi, a tak je nejlepší být připraveni.
Podívejte se na internet – najdete tam stovky výukových materiálů k 3D matematice, kterými se můžete propracovat, a nespočet knih, které se tomuto tématu podrobně věnují.
12Zvuk
Při programování se dříve či později může stát, že budete potřebovat, aby program přehrával zvuky. Může jít o zvukový signál, který uživateli oznámí, že byla úloha dokončena, nebo o zvukový efekt ve hře. Ať už zvuk použijete jakkoli, budete potřebovat vědět, jak načíst a přehrát konkrétní zvukové soubory. Tato kapitola vysvětluje, jak načítat různé druhy zvukových souborů, a na příkladech ukazuje, jak tyto soubory přehrávat přímo z programu.
Soubory WAV
Soubory WAV patří k nejrozšířenějším zvukovým formátům na osobních počítačích, protože vznikly ve společné spolupráci firem Microsoft a IBM. Soubory WAV, které mají obvykle příponu ‘*.wav’, jsou nativním zvukovým formátem všech PC. Přestože tento formát nemá pro zvuková data žádnou vestavěnou kompresi, stále se používá ke každodenním účelům.
Následující příklad načte soubor WAV s názvem ‘Intro.wav’ a přehraje ho:
#SOUND_FILE = 1
If InitSound()
LoadSound(#SOUND_FILE, "Intro.wav")
PlaySound(#SOUND_FILE)
StartTime.l = ElapsedMilliseconds()
Repeat
Delay(1)
Until ElapsedMilliseconds() > StartTime + 8000
End
EndIf
Tento příklad byste ve skutečném programu nejspíš nepoužili, ale ukazuje správný postup, jak soubor WAV přehrát. Nejprve musíme pomocí příkazu ‘InitSound()’ inicializovat zvukové prostředí.
Ten správně inicializuje veškerý hardware a software potřebný k přehrání souboru. Pokud vrátí pravdu (true), víme, že inicializace proběhla v pořádku, a můžeme pokračovat. Pokud inicializace zvuku selže, nemá smysl se zvukem dál pokračovat – počítač pravděpodobně nemá nainstalovanou zvukovou kartu.
Jakmile je inicializace hotová a ověřená, načteme zvukový soubor příkazem ‘LoadSound()’ (Helpfile:Reference Manual->2D Games Libraries->Sound->LoadSound). Ten načte zvuk do paměti, kde je připraven k přehrání. Příkaz ‘LoadSound()’ má dva parametry: první je PB číslo, které chcete s tímto zvukovým souborem spojit, a druhý je řetězec obsahující název souboru se zvukem, který chcete načíst.
Jakmile je soubor WAV načten, můžete ho v programu kdykoli přehrát příkazem ‘PlaySound()’ (Helpfile:Reference Manual->2D Games Libraries->Sound->PlaySound). Tento příkaz má jeden parametr, a to PB číslo zvukového souboru, který chcete přehrát.
Když se na příklad se souborem WAV podíváte blíže, uvidíte, že jsem na konci programu použil poměrně propracovaný cyklus. Ten má zabránit tomu, aby se ukázkový program ukončil příliš brzy. Když se program ukončí, veškerý zvuk, který právě přehrává, se zastaví a uvolní z paměti. Nechci, aby se to stalo okamžitě, a proto jsem napsal tento cyklus, který programu dá osm sekund na přehrání souboru, a teprve pak se program ukončí. Ve skutečném programu něco takového nejspíš nikdy neuvidíte, protože ten bude mít pravděpodobně hlavní cyklus, který program udržuje „naživu“, zatímco se zvuk přehrává.
Vkládání souborů WAV do programu
Někdy možná nebudete chtít ve svých programech načítat externí soubory WAV, ale budete je chtít mít přímo uvnitř programu, aby se celý program dal distribuovat jako jediný soubor. Toho lze dosáhnout vložením souboru WAV do sekce ‘DataSection’, podobně jako při vkládání obrázku, jak je vysvětleno v kapitole 9 (Začlenění grafiky do programu). Je tu však jeden rozdíl: místo příkazu ‘CatchImage()’ použijeme k načtení souboru ze sekce ‘DataSection’ příkaz ‘CatchSound()’. Zde je příklad:
#SOUND_FILE = 1
If InitSound()
CatchSound(#SOUND_FILE, ?SoundFile)
PlaySound(#SOUND_FILE)
StartTime.l = ElapsedMilliseconds()
Repeat
Delay(1)
Until ElapsedMilliseconds() > StartTime + 8000
End
EndIf
DataSection
SoundFile:
IncludeBinary "Intro.wav"
EndDataSection
Zvukový soubor se do sekce ‘DataSection’ vloží příkazem ‘IncludeBinary’ přesně stejným způsobem jako obrázek a návěští ‘SoundFile:’ označuje začátek souboru v paměti. K načtení tohoto zvuku ze sekce ‘DataSection’ za běhu programu použijeme příkaz ‘CatchSound()’ (Helpfile:Reference Manual->2D Games Libraries->Sound->CatchSound). Tento příkaz má dva parametry: první je PB číslo, které bude s tímto zvukem spojeno, a druhý je adresa v paměti, ze které se má zvukový soubor načíst. Touto adresou bude adresa návěští, protože to označuje, kde se zvukový soubor v paměti nachází. Adresu libovolného návěští získáme tak, že před jeho název napíšeme otazník, například takto: ‘?SoundFile’. Všimněte si však, že dvojtečku za názvem návěští zde nepotřebujeme. Jakmile je soubor WAV takto „zachycen“, můžete s ním pracovat stejně jako s jakýmkoli jiným souborem WAV; v tomto případě zvuk opět přehraji příkazem ‘PlaySound()’.
Tímto způsobem lze do jednoho programu vložit mnoho souborů WAV, jen je potřeba dát každému z nich jedinečné návěští, aby je bylo možné „zachytit“.
Úpravy zvuku v reálném čase
Pomocí příkazů ze zvukové knihovny PureBasicu můžete provádět zajímavé změny hlasitosti, posouvání zvuku mezi reproduktory (panning) a posuny frekvence. Hlasitost zvyšuje nebo snižuje sílu zvuku, panning znamená přesouvání zvuku z jednoho reproduktoru do druhého, obvykle doleva nebo doprava, a změna frekvence ve výsledku zrychlí nebo zpomalí přehrávání souboru WAV v průběhu přehrávání. Abych tyto efekty předvedl, vytvořil jsem malý přehrávač zvuku, který umožňuje ovládat hlasitost, panning a frekvenci v reálném čase. Vyzkoušejte si ho sami: spusťte ho, načtěte soubor WAV, stiskněte tlačítko přehrávání a posouvejte jezdci (trackbary).
Enumeration
#WINDOW_ROOT
#SOUND_FILE
#TEXT_FILE
#BUTTON_CHOOSE_FILE
#TEXT_VOLUME
#TRACKBAR_VOLUME
#TEXT_PAN
#TRACKBAR_PAN
#TEXT_FREQUENCY
#TRACKBAR_FREQUENCY
#BUTTON_PLAY_FILE
#BUTTON_STOP_FILE
EndEnumeration
Global FileName.s = ""
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_ROOT, 0, 0, 500, 250, "Sound Player", #FLAGS)
If CreateGadgetList(WindowID(#WINDOW_ROOT))
TextGadget(#TEXT_FILE, 10, 10, 480, 20, "", #PB_Text_Border)
ButtonGadget(#BUTTON_CHOOSE_FILE, 10, 40, 150, 20, "Choose Wave File...")
TextGadget(#TEXT_VOLUME, 10, 70, 480, 20, "Volume")
TrackBarGadget(#TRACKBAR_VOLUME, 10, 90, 480, 20, 0, 100)
SetGadgetState(#TRACKBAR_VOLUME, 100)
TextGadget(#TEXT_PAN, 10, 120, 480, 20, "Pan")
TrackBarGadget(#TRACKBAR_PAN, 10, 140, 480, 20, 0, 200)
SetGadgetState(#TRACKBAR_PAN, 100)
TextGadget(#TEXT_FREQUENCY, 10, 170, 480, 20, "Frequency")
TrackBarGadget(#TRACKBAR_FREQUENCY, 10, 190, 480, 20, 100, 10000)
SetGadgetState(#TRACKBAR_FREQUENCY, 4400)
ButtonGadget(#BUTTON_PLAY_FILE, 10, 220, 100, 20, "Play File")
ButtonGadget(#BUTTON_STOP_FILE, 130, 220, 100, 20, "Stop Sound")
If InitSound()
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_CHOOSE_FILE
FileName=OpenFileRequester("Choose","","Wave File (*.wav)|*.wav",0)
If filename <> ""
SetGadgetText(#TEXT_FILE, GetFilePart(FileName))
LoadSound(#SOUND_FILE, filename)
EndIf
Case #TRACKBAR_VOLUME
If filename <> ""
SoundVolume(#SOUND_FILE, GetGadgetState(#TRACKBAR_VOLUME))
EndIf
Case #TRACKBAR_PAN
If filename <> ""
SoundPan(#SOUND_FILE, GetGadgetState(#TRACKBAR_PAN) - 100)
EndIf
Case #TRACKBAR_FREQUENCY
If filename <> ""
SoundFrequency(#SOUND_FILE,GetGadgetState(#TRACKBAR_FREQUENCY) * 10)
EndIf
Case #BUTTON_PLAY_FILE
If filename <> ""
PlaySound(#SOUND_FILE)
EndIf
Case #BUTTON_STOP_FILE
If filename <> ""
StopSound(#SOUND_FILE)
EndIf
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow
EndIf
EndIf
EndIf
End
Tento příklad představuje tři nové zvukové příkazy:
‘SoundVolume()’ Tento příkaz slouží k ovládání „hlasitosti“ načteného zvuku. Původní zvukový soubor nijak nemění, pouze mění hlasitost zvuku při jeho přehrávání. Abyste tento příkaz mohli použít, musíte mu předat dva parametry: první je PB číslo zvuku, který chcete změnit, a druhý je úroveň hlasitosti, na kterou ho chcete nastavit. Úroveň hlasitosti je číslo mezi ‘0’ a ‘100’, přičemž ‘0’ znamená ticho a ‘100’ nejvyšší hlasitost.
‘SoundPan()’ Tento příkaz posouvá zvuk mezi levým a pravým kanálem. K jeho použití musíte předat dva parametry. Prvním je PB číslo zvuku, který chcete posouvat, a druhým parametrem je hodnota posunu (pan). Tato hodnota je číslo v rozsahu od ‘-100’ do ‘100’. Použijete-li hodnotu ‘-100’, zvuk se zcela přesune doleva. Použijete-li hodnotu ‘100’, zvuk se zcela přesune doprava.
‘SoundFrequency()’ Tento příkaz mění frekvenci přehrávaného zvuku. Frekvence zvukového souboru se měří v hertzích a vyjadřuje, kolikrát za sekundu se načte daný průběh vlny. Například veškerá hudba uložená na kompaktních discích je vzorkována frekvencí 44.1kHz (kilohertzů). To znamená, že vlnový průběh obsahující zvukovou informaci na CD se načítá čtyřicet čtyři tisíc sto krát za sekundu. Tím je zajištěno, že vlnový průběh má dostatečné rozlišení k zakódování i té nejjemnější změny zvuku. Je-li zvuk zakódován s frekvencí 44.1kHz a vy tímto příkazem změníte jeho frekvenci na 22 050Hz, bude se zvuk při přehrávání přehrávat poloviční rychlostí oproti originálu. Chcete-li tímto příkazem v PureBasicu změnit frekvenci načteného zvuku, předáte mu dva parametry. Prvním je PB číslo zvuku, který chcete upravit, a druhým je číslo vyjadřující novou frekvenci v hertzích. Tento druhý parametr musí ležet v rozsahu od ‘1000’ do ‘100000’.
Chcete-li se dozvědět více o příkazech pro práci se soubory WAV, podívejte se na zvukovou knihovnu v nápovědě PureBasicu (Helpfile:Reference Manual->2D Games Libraries->Sound).
Modulové soubory
Tyto typy souborů používají formáty, které reprezentují hudbu pomocí digitálních vzorů (patternů). Interně ukládají několik stránek hudebních dat uspořádaných do patternů ve formě podobné tabulce v tabulkovém procesoru. Tyto patterny obsahují čísla not, čísla nástrojů a řídicí zprávy, které programu čtoucímu soubor říkají, kdy má noty zahrát, s jakými samply a jak dlouho. Modulové soubory také obsahují seznam, který určuje pořadí, v jakém se mají patterny přehrávat. Počet not, které lze zahrát současně, závisí na tom, kolik stop každý pattern obsahuje. Rané programy, které byly k dispozici, umožňovaly uživatelům vytvářet vlastní moduly se čtyřmi stopami. Největší výhodou modulů oproti běžným zvukovým souborům je, že moduly obsahují vlastní zvukové samply, a měly by proto znít v každém přehrávači stejně.
Modulové soubory se často nazývají trackerové moduly a umění skládat moduly se označuje jako tracking, a to jednoduše proto, že úplně první program, který uživatelům umožnil moduly vytvářet, se jmenoval ‘Soundtracker’. Tento program byl zpočátku přijat nevlídně, nakonec však byl uvolněn jako volné dílo (public domain) a dočkal se mnoha klonů s lepšími funkcemi a jinými názvy, například ‘Noisetracker’ nebo ‘Protracker’. Ty se staly mimořádně populárními, zejména mezi tvůrci her a dem pro Commodore Amiga. Programy, které umějí vytvářet modulové soubory, se dnes souhrnně nazývají trackery.
Modulové soubory mohou mít mnoho různých přípon, protože existují v mnoha různých formátech; přípona obvykle prozrazuje program, kterým byl soubor vytvořen. PureBasic podporuje tyto typy modulových souborů:
FastTracker (‘.xm’) Scream Tracker (‘.s3m’) Protracker (‘.mod’) Impulse Tracker (‘.it’)
Při načítání a přehrávání v programu v PureBasicu se se všemi těmito typy modulů zachází stejně. Zde je příklad, který ukazuje, jak načíst a přehrát libovolný z uvedených typů modulů:
#MODULE_FILE = 1
If InitSound()
If InitModule()
LoadModule(#MODULE_FILE, "Eighth.mod")
PlayModule(#MODULE_FILE)
StartTime.l = ElapsedMilliseconds()
Repeat
Delay(1)
Until ElapsedMilliseconds() > StartTime + 15000
StopModule(#MODULE_FILE)
End
EndIf
EndIf
Nejprve musíme stejně jako v příkladu se souborem WAV inicializovat zvukové prostředí příkazem ‘InitSound()’. Dále musíme příkazem ‘InitModule()’ inicializovat schopnost PureBasicu přehrávat moduly. Oba tyto příkazy je třeba otestovat, abyste měli jistotu, že se obě části inicializovaly správně.
Jakmile je prostředí připraveno, můžeme načíst modul příkazem ‘LoadModule()’ (Helpfile:Reference Manual->2D Games Libraries->Module->LoadModule). Tento příkaz má dva parametry: první je PB číslo, které chcete s tímto modulem spojit, a druhý je název souboru modulu, který se má načíst.
Po načtení můžeme modul kdykoli přehrát příkazem ‘PlayModule()’ (Helpfile:Reference Manual->2D Games Libraries->Module->PlayModule). Stejně jako příkaz ‘PlaySound()’ má i tento příkaz jeden parametr, a to PB číslo modulu, který chcete přehrát. K zastavení přehrávání modulu můžete použít příkaz ‘StopModule()’.
Nevýhody používání modulů
Používání modulů v programech v PureBasicu má dvě velké nevýhody. První je, že neexistuje snadný způsob, jak moduly, které je třeba přehrát, vložit do programu a načítat z paměti. To znamená, že spolu se spustitelným souborem musíte distribuovat i všechny použité modulové soubory. Existují sice způsoby, jak modul uložit do spustitelného souboru a před načtením a přehráním ho zapsat na disk, ale je to trochu těžkopádné. Druhou nevýhodou je, že spolu s programem musíte distribuovat soubor ‘Midas11.dll’. Tuto dynamicky linkovanou knihovnu (DLL) načítá příkaz ‘InitModule()’, a pokud ji nenajde, skončí chybou. Možná si myslíte, že to není tak zlé, ale licence vztahující se k používání knihovny ‘Midas’ zakazuje její použití k jakýmkoli komerčním účelům. Tato licence také brání tomu, aby byl soubor ‘Midas11.dll’ součástí balíku PureBasicu, takže si ho musíte sami stáhnout z webu ‘Housemarque Audio System’, jehož adresu najdete v příloze A (Užitečné internetové odkazy).
Chcete-li se dozvědět o dalších příkazech, kterými lze s modulovými soubory pracovat, podívejte se na knihovnu Module v nápovědě PureBasicu (Helpfile:Reference Manual->2D Games Libraries->Module).
Soubory MP3
Soubory MP3 se rychle stávají nejoblíbenějším zvukovým formátem všech dob, a to především proto, že formát MP3 je de facto standardem pro téměř veškerou hudbu ke stažení na internetu. MP3 je zkratka, která znamená ‘MPEG-1 Audio Layer 3’, což je pěkně dlouhé, takže asi chápete, proč se to zkrátilo.
Se soubory MP3 se v PureBasicu zachází trochu jinak a k jejich přehrávání musíme použít příkazy z knihovny ‘Movie’ (Helpfile:Reference Manual->General Libraries->Movie). Může se zdát trochu zvláštní používat k přehrávání souborů mp3 příkazy pro videa, ale tyto příkazy dokážou mnohem víc než jen přehrávat videa. Knihovna ‘Movie’ nabízí pohodlný způsob, jak načíst a přehrát téměř jakékoli médium, pro které je na hostitelském počítači nainstalován kodek. Pomocí těchto příkazů můžete přehrávat nejen video formáty, ale i formáty zvukových souborů.
Zde je seznam nejrozšířenějších formátů souborů, které knihovna ‘Movie’ dokáže přehrát, pokud jsou předem nainstalovány potřebné pluginy nebo kodeky. Možná se vám podaří přehrát i více formátů, než uvádí tento seznam:
Video soubory: Audio Video Interleave (‘.avi’) MPEG Video (‘.mpg’)
Zvukové soubory: Soubory MIDI (‘.mid’) Soubory MP3 (‘.mp3’) Ogg Vorbis (‘.ogg’) Soubory WAV (‘.wav’)
Knihovna ‘Movie’ se může zdát jako „univerzální obchod“ pro všechny vaše potřeby přehrávání médií a někteří lidé dokonce žádali, aby byla přejmenována na knihovnu ‘Media’. Je však třeba pamatovat na jednu věc: to, co se na vašem počítači načte a přehraje, se nemusí načíst a přehrát na počítači někoho jiného. Na jiných počítačích totiž mohou být nainstalovány jiné pluginy nebo kodeky (případně žádné). Přesto se zdá, že výše uvedený seznam je na většině počítačů celkem standardní, ale nechytejte mě za slovo.
V následujícím příkladu jsem příkazy pro videa použil k vytvoření jednoduchého přehrávače MP3 s jednoduchým ovládáním hlasitosti a panningu. WinAmpu možná konkurovat nebude, ale dá vám představu o tom, jak snadno se v PureBasicu vytvářejí přehrávače médií.
Enumeration
#WINDOW_ROOT
#SOUND_FILE
#TEXT_FILE
#BUTTON_CHOOSE_FILE
#TEXT_VOLUME
#TRACKBAR_VOLUME
#TEXT_PAN
#TRACKBAR_PAN
#BUTTON_PLAY_FILE
#BUTTON_PAUSE_FILE
#BUTTON_STOP_FILE
EndEnumeration
Global FileName.s = ""
Global FilePaused.b = #False
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_ROOT, 0, 0, 500, 215, "MP3 Player", #FLAGS)
If CreateGadgetList(WindowID(#WINDOW_ROOT))
TextGadget(#TEXT_FILE, 10, 10, 480, 20, "", #PB_Text_Border)
ButtonGadget(#BUTTON_CHOOSE_FILE, 10, 40, 150, 20, "Choose MP3 File...")
TextGadget(#TEXT_VOLUME, 10, 70, 480, 20, "Volume")
TrackBarGadget(#TRACKBAR_VOLUME, 10, 90, 480, 20, 0, 100)
SetGadgetState(#TRACKBAR_VOLUME, 100)
TextGadget(#TEXT_PAN, 10, 120, 480, 20, "Pan")
TrackBarGadget(#TRACKBAR_PAN, 10, 140, 480, 20, 0, 200)
SetGadgetState(#TRACKBAR_PAN, 100)
ButtonGadget(#BUTTON_PLAY_FILE, 10, 180, 100, 20, "Play")
ButtonGadget(#BUTTON_PAUSE_FILE, 130, 180, 100, 20, "Pause")
ButtonGadget(#BUTTON_STOP_FILE, 250, 180, 100, 20, "Stop")
If InitMovie()
Repeat
Event.l = WaitWindowEvent()
Select Event
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_CHOOSE_FILE
FileName=OpenFileRequester("Choose","","MP3 File (*.mp3)|*.mp3",0)
If filename <> ""
SetGadgetText(#TEXT_FILE, GetFilePart(FileName))
LoadMovie(#SOUND_FILE, filename)
EndIf
Case #TRACKBAR_VOLUME, #TRACKBAR_PAN
If filename <> ""
Volume.l = GetGadgetState(#TRACKBAR_VOLUME)
Balance.l = GetGadgetState(#TRACKBAR_PAN) - 100
MovieAudio(#SOUND_FILE, Volume, Balance)
EndIf
Case #BUTTON_PLAY_FILE
If filename <> ""
PlayMovie(#SOUND_FILE, #Null)
FilePaused = #False
SetGadgetText(#BUTTON_PAUSE_FILE, "Pause")
EndIf
Case #BUTTON_PAUSE_FILE
If filename <> ""
If FilePaused = #False
PauseMovie(#SOUND_FILE)
FilePaused = #True
SetGadgetText(#BUTTON_PAUSE_FILE, "Resume")
Else
ResumeMovie(#SOUND_FILE)
FilePaused = #False
SetGadgetText(#BUTTON_PAUSE_FILE, "Pause")
EndIf
EndIf
Case #BUTTON_STOP_FILE
If filename <> ""
StopMovie(#SOUND_FILE)
FilePaused = #False
SetGadgetText(#BUTTON_PAUSE_FILE, "Pause")
EndIf
EndSelect
EndSelect
Until Event = #PB_Event_CloseWindow
EndIf
EndIf
EndIf
End
Z tohoto malého příkladu je vidět, že chcete-li používat příkazy pro videa, musíte stejně jako u souborů WAV a modulů nejprve správně inicializovat prostředí. K inicializaci příkazů pro videa slouží příkaz ‘InitMovie()’. Po jeho zavolání můžete volně používat ostatní příkazy knihovny ‘Movie’. Stejně jako ostatní inicializační příkazy je třeba ho otestovat; pokud selže, příkazy pro videa nebudete moci dál používat.
K načtení videa (v tomto případě souboru MP3) použijeme příkaz ‘LoadMovie()’ (Helpfile:Reference Manual->General Libraries->Movie->LoadMovie). Tento příkaz má dva parametry. Prvním je PB číslo, které chcete spojit s médiem, jež se chystáte načíst, a druhým parametrem je řetězec obsahující název souboru s médiem, které se má načíst.
Jakmile je médium načteno, můžeme ho přehrát příkazem ‘PlayMovie()’ (Helpfile:Reference Manual->General Libraries->Movie->PlayMovie). Tento příkaz má dva parametry, aby mohl podporovat videa i zvuková média. Prvním parametrem je PB číslo média, které chcete přehrát, a druhým parametrem je identifikátor OS nějakého okna. Tento identifikátor OS je nutný při přehrávání videa, protože do tohoto okna se bude video vykreslovat. Pokud přehráváte soubor, který obsahuje pouze zvuková data (například MP3), můžete jako identifikátor OS použít vestavěnou konstantu ‘#Null’; k přehrávání souboru se pak nepřiřadí žádné okno:
...
PlayMovie(#SOUND_FILE, #Null)
...
V příkladu jsem také použil příkazy ‘PauseMovie()’ a ‘ResumeMovie()’. Jejich použití je jednoduché: oba mají jeden parametr, a to PB číslo média, jehož přehrávání chcete pozastavit nebo obnovit.
Abyste mohli přehrávání souborů zastavit, použil jsem v tomto příkladu také příkaz ‘StopMovie()’. I jeho použití je jednoduché, protože mu stačí předat jediný parametr. Je jím PB číslo média, jehož přehrávání chcete zastavit.
Přestože jde jen o kostru přehrávače médií, která podporuje pouze soubory MP3, bylo by hračkou tento kód upravit tak, abyste získali vlastní přehrávač médií, který zvládne všechny výše uvedené formáty. Proč to nezkusit?
Zvukové CD
Přehrávání zvukového CD je dobrý způsob, jak zajistit vysoce kvalitní hudbu pro jakoukoli hru nebo aplikaci, která hudbu potřebuje. Na internetu je k dispozici mnoho bezplatných nástrojů pro skládání hudby a její vypalování na CD. Používat CD jako zdroj hudby je skvělý nápad, protože jejich přehrávání vyžaduje jen velmi málo systémových prostředků a kvalita je fantastická. Zde je příklad, který pomocí knihovny PureBasicu ‘AudioCD’ vytváří velmi jednoduchý přehrávač CD:
Enumeration
#WINDOW_ROOT
#BUTTON_PREVIOUS
#BUTTON_PLAY
#BUTTON_STOP
#BUTTON_NEXT
#BUTTON_EJECT
#TEXT_STATUS
#PROGRESS_SONG
#LIST_TRACKS
EndEnumeration
;Global variables, etc.
Global NumberOfTracks.l
Global CurrentTrack.l
;Convert seconds into a String containing minutes
Procedure.s ConvertToMin(Seconds.l)
ProcedureReturn Str(Seconds / 60) + ":" + Str(Seconds % 60)
EndProcedure
;Set the current track
Procedure UpdateStatusText(Track.l)
If NumberOfTracks > 0
TrackLength.l = AudioCDTrackLength(Track)
TrackLengthString.s = ConvertToMin(TrackLength)
TrackTimings.s = " (" + TrackLengthString + ")"
SetGadgetText(#TEXT_STATUS, "Track: " + Str(Track) + TrackTimings)
SetGadgetState(#PROGRESS_SONG, 0)
If AudioCDStatus() > 0
TimeElapsed.l = AudioCDTrackSeconds()
TrackTimings.s=" ("+ConvertToMin(TimeElapsed)+" / "+TrackLengthString+")"
SetGadgetText(#TEXT_STATUS, "Track: " + Str(Track) + TrackTimings)
Progress.f = (100 / TrackLength) * TimeElapsed
SetGadgetState(#PROGRESS_SONG, Progress)
EndIf
SetGadgetState(#LIST_TRACKS, Track - 1)
Else
SetGadgetText(#TEXT_STATUS, "Please insert an Audio CD")
EndIf
EndProcedure
;Move to next track
Procedure NextTrack()
If CurrentTrack < NumberOfTracks
CurrentTrack + 1
UpdateStatusText(CurrentTrack)
If AudioCDStatus() > 0
PlayAudioCD(CurrentTrack, NumberOfTracks)
EndIf
EndIf
EndProcedure
;Move to previous track
Procedure PreviousTrack()
If CurrentTrack > 1
CurrentTrack - 1
UpdateStatusText(CurrentTrack)
If AudioCDStatus() > 0
PlayAudioCD(CurrentTrack, NumberOfTracks)
EndIf
EndIf
EndProcedure
;Populate the list to show all tracks on a disc
Procedure PopulateTrackListing()
ClearGadgetItemList(#LIST_TRACKS)
NumberOfTracks = AudioCDTracks()
If NumberOfTracks > 0
For x.l = 1 To NumberOfTracks
TrackLength.s = ConvertToMin(AudioCDTrackLength(x))
AddGadgetItem(#LIST_TRACKS, -1, "Track "+Str(x)+" ("+TrackLength+")")
Next x
If CurrentTrack = 0
CurrentTrack = 1
EndIf
Else
CurrentTrack = 0
EndIf
EndProcedure
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_ROOT, 0, 0, 320, 250, "CD Player", #FLAGS)
If CreateGadgetList(WindowID(#WINDOW_ROOT))
ButtonGadget(#BUTTON_PREVIOUS, 10, 10, 60, 20, "Previous")
ButtonGadget(#BUTTON_PLAY, 70, 10, 60, 20, "Play")
ButtonGadget(#BUTTON_STOP, 130, 10, 60, 20, "Stop")
ButtonGadget(#BUTTON_NEXT, 190, 10, 60, 20, "Next")
ButtonGadget(#BUTTON_EJECT, 250, 10, 60, 20, "Eject")
TextGadget(#TEXT_STATUS, 10, 40, 300, 20, "", #PB_Text_Center)
ProgressBarGadget(#PROGRESS_SONG,10,65,300,10,0,100,#PB_ProgressBar_Smooth)
ListViewGadget(#LIST_TRACKS, 10, 90, 300, 150)
If InitAudioCD()
PopulateTrackListing()
StartTime.l = ElapsedMilliseconds()
Repeat
Event.l = WindowEvent()
Select Event
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_PREVIOUS
PreviousTrack()
Case #BUTTON_PLAY
If NumberOfTracks > 0
PlayAudioCD(CurrentTrack, NumberOfTracks)
EndIf
Case #BUTTON_STOP
StopAudioCD()
Case #BUTTON_NEXT
NextTrack()
Case #BUTTON_EJECT
EjectAudioCD(#True)
PopulateTrackListing()
Case #LIST_TRACKS
If EventType() = #PB_EventType_LeftDoubleClick
CurrentTrack = GetGadgetState(#LIST_TRACKS) + 1
UpdateStatusText(CurrentTrack)
PlayAudioCD(CurrentTrack, NumberOfTracks)
EndIf
EndSelect
EndSelect
CurrentTime.l = ElapsedMilliseconds()
If CurrentTime > StartTime + 1000
PopulateTrackListing()
UpdateStatusText(CurrentTrack)
StartTime.l = ElapsedMilliseconds()
EndIf
Delay(1)
Until Event = #PB_Event_CloseWindow
StopAudioCD()
EndIf
EndIf
EndIf
End
Tento příklad je mimořádně jednoduchý přehrávač CD, který poskytuje jen naprosté minimum funkcí pro ovládání a přehrávání CD. Podrobněji si o všech použitých příkazech knihovny ‘AudioCD’ můžete přečíst v nápovědě PureBasicu (Helpfile:Reference Manual->General Libraries->AudioCD).
Chcete-li používat příkazy ‘AudioCD’, musíte nejprve inicializovat prostředky potřebné k přehrávání CD. K tomu slouží příkaz ‘InitAudioCD()’. Tento příkaz je třeba otestovat, abyste zjistili, zda byl úspěšný. Jako vedlejší produkt vrací tento příkaz počet CD mechanik připojených k počítači, které lze použít k přehrávání hudby. Je-li návratová hodnota ‘0’, počítač buď nemá nainstalovanou CD mechaniku, nebo nastal jiný problém, který mechanice brání v přehrávání hudby. Pokud je návratová hodnota větší než ‘0’, mělo by být vše v pořádku.
Jakmile je zvukové CD inicializováno, můžete volně používat všechny ostatní příkazy, které knihovna ‘AudioCD’ nabízí.
Zde je seznam těch, které jsem použil ve svém příkladu přehrávače CD:
‘PlayAudioCD()’ Tento příkaz slouží k přehrání stopy z CD, které je právě vloženo v mechanice. Má dva parametry. Prvním je stopa, od které se má začít přehrávat, a druhým je stopa, po jejímž dohrání se má přehrávání zastavit. Pokud bych tedy například zavolal příkaz takto:
PlayAudioCD(1, 3)
začala by se přehrávat stopa ‘1’, poté by přehrávání pokračovalo další stopou. Přehrávání by se pak zastavilo po dohrání stopy ‘3’.
‘StopAudioCD()’ Tento příkaz lze kdykoli použít k zastavení přehrávání jakékoli stopy, která se z CD právě přehrává.
‘EjectAudioCD()’ Tento příkaz buď otevře, nebo zavře šuplík CD mechaniky podle toho, jaký parametr mu předáte. Má pouze jeden parametr: je-li jeho hodnota ‘1’, šuplík mechaniky se otevře, čímž se přehrávání zastaví a CD se vysune. Je-li parametr ‘0’, šuplík mechaniky se zavře, čímž se načte CD, které je v něm vloženo.
‘AudioCDStatus()’ Tento příkaz nemá žádné parametry, ale vrací výsledek, který udává aktuální stav CD v mechanice v reálném čase. Pokud tento příkaz zavoláte a vrátí ‘-1’, mechanika není připravena, což znamená, že v ní buď není žádné CD, nebo je její šuplík právě otevřený. Vrátí-li tento příkaz hodnotu ‘0’, bylo CD správně rozpoznáno a je v mechanice, ale nepřehrává se. Vrátí-li tento příkaz hodnotu větší než ‘0’, CD mechanika přehrává stopu z CD. Vrácené číslo je pak číslo právě přehrávané stopy.
‘AudioCDTracks()’ Tento příkaz nemá žádné parametry a po zavolání vrátí počet stop na vloženém CD, které lze přehrát.
‘AudioCDTrackLength()’ Tento příkaz vyžaduje jeden parametr, a to číslo stopy na vloženém CD. Na základě této informace vrátí délku dané stopy v sekundách.
‘AudioCDTrackSeconds()’ Tento příkaz nemá žádné parametry. Po zavolání vrátí v sekundách dobu, po kterou se aktuální stopa už přehrává.
Když se na můj příklad přehrávače CD podíváte blíže, uvidíte, že jsem také použil příkaz ‘WindowEvent()’ místo ‘WaitWindowEvent()’. To znamená, že hlavní cyklus poběží neustále bez ohledu na to, zda byla zachycena nějaká událost, či nikoli. U tohoto programu jsem to potřeboval, protože v hlavním cyklu volám v pravidelných intervalech proceduru, která aktualizuje stavový text v grafickém uživatelském rozhraní přehrávače CD. Kdybych tento příkaz nepoužil, stavový text by se aktualizoval jen tehdy, když by byla zachycena nějaká událost, což by mohlo trvat dost dlouho.
Příkazy ‘WindowEvent()’ a ‘WaitWindowEvent()’ jsou podrobněji popsány v kapitole 9 (Pochopení událostí).
IVPokročilá témata
V této části vysvětluji věci, které jsou o něco pokročilejší než to, čemu se věnuje zbytek knihy. Je určena těm, kdo mají další otázky ohledně některé konkrétní stránky PureBasicu nebo se chtějí dozvědět trochu víc o tom, co se odehrává „pod kapotou“.
K psaní dobrých, spolehlivých a funkčně bohatých programů nepotřebujete znát nic z toho, co tato část obsahuje, ale zařadil jsem ji sem pro ty, kdo chtějí proniknout trochu hlouběji.
13Za hranicemi základů
Tato kapitola je takovou směsicí témat, protože jsem cítil, že všechny tyto věci je potřeba vysvětlit, ale žádná z nich by si opravdu nezasloužila celou samostatnou kapitolu. Nejsou nezbytné k tomu, abyste mohli psát programy v PureBasicu, jsou však určeny programátorům, kteří si chtějí rozšířit znalosti o pokročilejších možnostech jazyka PureBasic.
V této kapitole se mimo jiné dozvíte o direktivách kompilátoru a o tom, jak kompilátor řídit přímo z kódu; o pokročilých nastaveních kompilátoru, díky nimž z kompilátoru PureBasicu vytěžíte víc; o tom, jak programu předávat argumenty příkazové řádky při psaní nástrojů pro příkazovou řádku; jak PureBasic ukládá číselné datové typy; co jsou ukazatele a jak je používat; co jsou vlákna a jak je používat; co jsou dynamicky linkované knihovny a jak je vytvářet; a konečně jak v PureBasicu přímo používat rozhraní Windows API (Windows Application Programming Interface).
Direktivy a funkce kompilátoru
Direktivy kompilátoru jsou příkazy, které řídí kompilátor PureBasicu během kompilace. Díky nim tedy máte naprostou kontrolu nad tím, které části zdrojového kódu se zkompilují, a můžete jimi také získávat informace od kompilátoru. Direktivy kompilátoru působí pouze v době kompilace, kdy jsou analyzovány a vykonány. Za běhu programu je využít nelze.
Funkce kompilátoru se od direktiv liší tím, že jde o příkazy, které umožňují získat informace o něčem, co již bylo zkompilováno (obvykle o datovém typu). Na rozdíl od direktiv lze funkce kompilátoru využít i za běhu programu.
Příklady direktiv a funkcí kompilátoru jste již v této knize viděli, i když jste si toho možná nevšimli. Například v kapitole 8 (Jak minimalizovat a ošetřovat chyby) jsem předváděl příkaz ‘EnableExplicit’. Tato direktiva kompilátoru přepne kompilátor do explicitního režimu a zajistí, že všechny proměnné budou explicitně deklarovány, takže u každé nové proměnné bude určen její obor platnosti i typ. V kapitole 5 jste také viděli příkazy ‘SizeOf()’ a ‘OffsetOf()’. Tyto funkce kompilátoru získávají informace o zkompilovaných strukturách a rozhraních, například velikost určité struktury v paměti v bajtech nebo posun (offset), na kterém se uvnitř struktury či rozhraní nachází určité pole.
Do tohoto výčtu patří ještě několik dalších direktiv a funkcí, ale než je budu moci podrobněji vysvětlit, musím nejprve popsat vestavěné vyhrazené konstanty kompilátoru, které téměř všechny z nich používají.
Vyhrazené konstanty kompilátoru
Tyto vestavěné vyhrazené konstanty jsou úplně stejné jako jakékoli jiné konstanty, liší se však tím, že jejich hodnoty do značné míry závisejí na aktuálním stavu kompilátoru. Všechny tyto konstanty lze testovat v době kompilace a podle nich rozhodovat, jak má kompilace pokračovat; některé konstanty dokonce poskytují informace o samotném procesu kompilace. Zde je úplný seznam vyhrazených konstant kompilátoru a informací, které z nich můžete získat.
‘#PB_Compiler_OS’ Jde o speciální konstantu, které je přiřazena hodnota podle toho, na jaké platformě kompilátor běží. Má také několik přidružených konstant, které vám pomohou určit, co její hodnota znamená. Pokud má například konstanta ‘#PB_Compiler_OS’ hodnotu rovnou některé z konstant ‘#PB_OS_Windows’, ‘#PB_OS_Linux’, ‘#PB_OS_AmigaOS’ nebo ‘#PB_OS_MacOS’, pak kompilátor běží právě na dané platformě.
‘#PB_Compiler_Date’ Hodnota této konstanty obsahuje datum v číselné podobě, a to datum, kdy byl váš program zkompilován. Hodnota je zakódována ve formátu data PureBasicu, aby se dobře hodila k příkazům knihovny ‘Date’ (Helpfile:Reference Manual->General Libraries->Date).
‘#PB_Compiler_File’ Hodnotou této konstanty je řetězec obsahující úplnou cestu a název právě kompilovaného souboru (*.pb).
‘#PB_Compiler_Line’ Hodnotou této konstanty je číslo řádku v aktuálním souboru, který se právě kompiluje.
‘#PB_Compiler_Version’ Hodnota této konstanty obsahuje číslo s plovoucí desetinnou čárkou, které udává verzi kompilátoru použitého ke kompilaci programu.
‘#PB_Compiler_Home’ Hodnotou této konstanty je řetězec obsahující úplnou cestu ke složce, do které je PureBasic na vašem počítači nainstalován.
‘#PB_Compiler_Debugger’ Tato konstanta může mít jednu ze dvou hodnot. Je-li její hodnota rovna ‘#True’, byl debugger před kompilací programu zapnutý. Je-li rovna ‘#False’, byl debugger před kompilací vypnutý.
‘#PB_Compiler_Thread’ Tato konstanta může mít jednu ze dvou hodnot. Je-li její hodnota rovna ‘#True’, byl kompilátor před kompilací přepnut do režimu bezpečného pro vlákna. Je-li rovna ‘#False’, režim kompilátoru bezpečný pro vlákna použit nebyl.
‘#PB_Compiler_Unicode’ Tato konstanta může mít jednu ze dvou hodnot. Je-li její hodnota rovna ‘#True’, byl kompilátor před kompilací přepnut do režimu Unicode. Je-li rovna ‘#False’, režim Unicode použit nebyl.
Všechny tyto vyhrazené konstanty kompilátoru lze běžně používat v příkazech a výrazech, ve skutečnosti je můžete použít všude, kde byste použili obyčejnou konstantu. Většina z nich je však skutečně užitečná teprve ve spojení s následujícími direktivami.
Direktiva ‘CompilerIf’
Pokud rozumíte používání příkazů ‘If’ v PureBasicu, porozumíte i používání ‘CompilerIf’. ‘CompilerIf’ je příkaz, který se chová úplně stejně jako jakýkoli jiný příkaz ‘If’, ale sám se ve skutečnosti nikdy nezkompiluje. Je to v podstatě kompilátorová verze příkazu ‘If’.
Na rozdíl od běžného ‘If’ rozhoduje ‘CompilerIf’ o tom, který úsek kódu se zkompiluje, na základě výsledku konstantního výrazu (proměnné nejsou povoleny). Naproti tomu běžné ‘If’ rozhoduje o tom, který úsek (již zkompilovaného) kódu se spustí, na základě výrazu s proměnnými.
Ukážu vám příklad jednoho z nejběžnějších použití ‘CompilerIf’:
CompilerIf #PB_Compiler_OS = #PB_OS_Windows
MessageRequester("Info", "This compiler is running on Microsoft Windows")
CompilerElse
MessageRequester("Info", "This compiler is NOT running on Microsoft Windows")
CompilerEndIf
Zde ‘CompilerIf’ testuje konstantní výraz ‘#PB_Compiler_OS = #PB_OS_Windows’. Je-li tento výraz pravdivý, víme, že se tento kód kompiluje na počítači s Microsoft Windows. Je-li nepravdivý, pak tomu tak není – je to opravdu tak jednoduché. Vypadá to dost přímočaře, ale chytré na používání ‘CompilerIf’ je to, že ať se příkaz ‘CompilerIf’ vydá kteroukoli větví, zkompiluje se pouze kód v této větvi. Když tedy tento příklad zkompilujeme na počítači s Microsoft Windows, řádek:
MessageRequester("Info", "This compiler is NOT running on Microsoft Windows")
se nikdy nezkompiluje, a proto nebude nikdy zahrnut do spustitelného souboru programu.
Příkaz ‘CompilerIf’ se skládá ze tří příkazů, které jsou všechny předvedeny ve výše uvedeném příkladu. Část ‘CompilerElse’, podobná běžnému ‘Else’, je zcela nepovinná, celý příkaz však musí končit ‘CompilerEndIf’.
Někteří programátoři používají ‘CompilerIf’ k omezení funkčnosti programu, zejména pokud je kompilován jako zkušební verze. Řekněme, že napíšu užitečný program a chci uživatelům nabídnout demoverzi, aby si ho před koupí mohli vyzkoušet, a zároveň se obávám, že by se ji někteří mohli pokusit „cracknout“ a odstranit z ní omezení. Svůj program bych mohl napsat takto:
#DEMO = #True
CompilerIf #DEMO
;Demo code
MessageRequester("Info", "This is a demo, You must buy the full version.")
CompilerElse
;Full version code
Procedure.d MyPI()
ProcedureReturn ACos(-1)
EndProcedure
Test.s = "This is the full version." + #LF$ + #LF$
Test.s + "The value of Pi is: " + StrD(MyPI(), 16)
MessageRequester("Info", Test)
CompilerEndIf
Pouhou změnou hodnoty konstanty ‘#DEMO’ nyní donutíte kompilátor zkompilovat různé verze zdrojového kódu. To je užitečné, protože tím můžete zabránit prolomení svých demoverzí – jednoduše v nich nebude obsažen kód, který obsahuje plná verze. Zkuste změnit hodnotu konstanty ‘#DEMO’ na ‘#False’ a zkompilovat tak plnou verzi tohoto programu.
Direktiva ‘CompilerSelect’
Příkaz ‘CompilerSelect’ je kompilátorová verze oblíbeného příkazu ‘Select’. To znamená, že lze zkompilovat různé úseky zdrojového kódu v závislosti na různých hodnotách zvolené konstanty. Podobně jako ‘CompilerIf’ může i ‘CompilerSelect’ testovat pouze konstantní hodnoty, opět proto, že test probíhá v době kompilace, nikoli za běhu. Zde je další test operačního systému, tentokrát pomocí ‘CompilerSelect’:
CompilerSelect #PB_Compiler_OS
CompilerCase #PB_OS_Windows
;Windows specific code
MessageRequester("Info", "This is being compiled on Microsoft Windows.")
CompilerCase #PB_OS_Linux
;Linux specific code
MessageRequester("Info", "This is being compiled on Linux.")
CompilerCase #PB_OS_MacOS
;MacOS specific code
MessageRequester("Info", "This is being compiled on MacOS X")
CompilerCase #PB_OS_AmigaOS
;AmigaOS specific code
MessageRequester("Info", "This is being compiled on Amiga OS.")
CompilerEndSelect
Pomocí něčeho takového můžete program přizpůsobit tak, aby se choval různě podle toho, pro jaký operační systém je kompilován. Váš program může také používat příkazy z API určitého operačního systému, a protože takové příkazy nejsou multiplatformní, můžete pomocí ‘CompilerSelect’ použít API jiných operačních systémů, abyste na všech platformách dosáhli stejného výsledku.
PureBasic podporuje několik klíčových slov, díky nimž má ‘CompilerSelect’ stejnou funkčnost jako běžný příkaz ‘Select’. Jsou to klíčová slova ‘CompilerSelect’, ‘CompilerCase’, ‘CompilerDefault’ a ‘CompilerEndSelect’. Tři z nich jste viděli ve výše uvedeném příkladu ‘CompilerSelect’. Čtvrté, ‘CompilerDefault’, slouží jako záložní klíčové slovo pro ošetření výchozího stavu pro případ, že žádný z příkazů ‘CompilerCase’ nevrátí pravdu, například takto:
CompilerSelect #PB_Compiler_OS
CompilerCase #PB_OS_AmigaOS
;AmigaOS specific code
MessageRequester("Error", "This source code does not support Amiga OS.")
CompilerDefault
;This code will compile on all other operating systems.
MessageRequester("Info", "This is code will compile fine on this OS.")
CompilerEndSelect
V tomto příkladu vyvolám chybu, pokud se někdo pokusí tento kód zkompilovat na AmigaOS, ale na všech ostatních operačních systémech (ošetřených klíčovým slovem ‘CompilerDefault’) poběží bez problémů.
Přestože mé příklady pro ‘CompilerIf’ a ‘CompilerSelect’ používají hlavně konstanty ‘#PB_Compiler_OS’, musíte mít na paměti, že pomocí nich lze testovat jakékoli konstanty, ať už vyhrazené kompilátorem, nebo ne. Díky tomu si můžete proces kompilace pomocí kódu PureBasicu přizpůsobit, jak uznáte za vhodné.
Direktiva ‘CompilerError’
Tuto direktivu lze použít samostatně nebo uvnitř jiných direktiv kompilátoru, jako je ‘CompilerIf’ nebo ‘CompilerSelect’, k vyvolání chyby kompilátoru doplněné užitečným textem. To se hodí, když chcete proces kompilace zastavit a předat uživateli srozumitelné chybové hlášení kompilátoru. Zde je výše uvedený příklad s ‘CompilerSelect’ upravený tak, aby používal skutečné chybové hlášení kompilátoru:
CompilerSelect #PB_Compiler_OS
CompilerCase #PB_OS_MacOS
CompilerError "This source code does not support MacOS."
CompilerDefault
MessageRequester("Info", "This is code will compile fine on this OS.")
CompilerEndSelect
Z tohoto příkladu je vidět, že direktiva ‘CompilerError’ nepoužívá na rozdíl od běžného příkazu závorky kolem parametrů. Místo toho jednoduše uvedeme direktivu ‘CompilerError’ a za ní řetězcový literál. Tento řetězec bude chybovým textem, který se zobrazí při vyvolání chyby kompilátoru. Jakmile kompilátor narazí na direktivu ‘CompilerError’, kompilace se zastaví a zobrazí se chybový text.
Funkce kompilátoru ‘Subsystem()’
Abych mohl vysvětlit tuto funkci kompilátoru, musím nejprve vysvětlit subsystémy obecně a jejich vztah k PureBasicu. Subsystémy jsou snadno pochopitelný koncept: pokud nejste spokojeni s funkčností některého z vestavěných příkazů PureBasicu, můžete jej nahradit vlastní verzí, a tyto nové verze jsou obsaženy v subsystému.
Když se podíváte do instalační složky PureBasicu, uvidíte složku s názvem ‘PureLibraries’, která obsahuje soubory knihoven s vestavěnými příkazy PureBasicu. Právě tyto soubory knihoven jsou při použití subsystému nahrazeny. Slovem „nahrazeny“ nemyslím, že jsou skutečně smazány nebo přepsány. Knihovna subsystému má pouze přednost před standardními knihovnami.
Chcete-li vytvořit subsystém, musíte nejprve přepsat a zkompilovat knihovnu PureBasicu (více informací o tom najdete ve složce ‘Library SDK’ PureBasicu). Tato nová knihovna musí obsahovat všechny příkazy původní knihovny a všechny tyto příkazy musí být pojmenovány přesně stejně jako originály. Pak musíte zajistit, aby název nově zkompilované knihovny odpovídal názvu knihovny, kterou má nahradit.
Jakmile to uděláte, měla by být nová knihovna téměř totožnou kopií původní knihovny, až na funkčnost příkazů, které obsahuje (ty můžete napsat tak, aby dělaly cokoli si přejete). Chcete-li tuto knihovnu nainstalovat jako subsystém, abyste ji mohli používat při kompilaci, musíte ve složce ‘SubSystems’ v instalačním adresáři PureBasicu vytvořit novou složku. Název, který této nové složce dáte, bude názvem vašeho nového subsystému. Uvnitř této nové složky subsystému pak musíte mít složku s názvem ‘PureLibraries’ a do ní umístíte své náhradní knihovny. Adresářová struktura těchto složek tedy bude vypadat přibližně takto:
‘..\PureBasic\SubSystems\YourSubSystem\PureLibraries\YourNewLibrary’
Aby PureBasic váš nový subsystém používal, musíte kompilátoru nastavit příznak subsystému, aby bral knihovny z vašeho subsystému, a ne ze standardní složky ‘PureLibraries’. Otevřete k tomu okno ‘Compiler Options’ (Možnosti kompilátoru, Menu:Compiler->Compiler Options...), do pole ‘Library Subsystem:’ zadejte název složky subsystému (té, kterou jste vytvořili ve složce ‘SubSystems’) a klepněte na ‘OK’. Při příští kompilaci programu kompilátor prohledá při hledání knihoven složky ‘SubSystems’ i ‘PureLibraries’, a pokud zjistí, že obě složky obsahují stejně pojmenované knihovny, vždy zvolí zadaný subsystém před standardní knihovnou, čímž původní knihovnu nahradí.
Ve složce ‘SubSystems’ již jeden příklad subsystému je. Když se do ní podíváte, najdete složku s názvem ‘OpenGL’, v ní složku ‘PureLibraries’ a v té náhradní knihovny pro ‘Screen’, ‘Sprite’ a ‘Sprite3D’. To jsou knihovny, které tento subsystém nahradí, pokud ho použijete. Po aktivaci pomocí příznaku kompilátoru bude tento subsystém používat pro 2D grafiku místo DirectX knihovnu OpenGL.
Nyní tedy, jak jsem slíbil, vysvětlím funkci kompilátoru ‘Subsystem()’.
Funkce kompilátoru ‘Subsystem()’ vám během kompilace sdělí, zda byl určitý subsystém aktivován příznakem kompilátoru. Syntaxe je dostatečně srozumitelná. Kdybych například zapnul subsystém ‘OpenGL’, zobrazila by se následující ladicí zpráva:
If Subsystem("OpenGL")
Debug "The OpenGL subsystem is being used."
EndIf
Funkce kompilátoru ‘Subsystem()’ přijímá jeden parametr, a to řetězcový literál s názvem subsystému, který chcete otestovat (proměnné zde použít nelze). Pokud byl tento subsystém aktivován a používá se ke kompilaci tohoto programu, vrátí funkce kompilátoru ‘Subsystem()’ pravdu.
Funkce kompilátoru ‘Defined()’
Při psaní softwaru někdy potřebujete otestovat, zda byl určitý datový objekt definován. K tomu slouží funkce kompilátoru ‘Defined()’. Tato funkce přijímá dva parametry: první je datový objekt, který se má otestovat, a druhý je datový typ tohoto objektu. Pokud byl daný objekt definován, vrátí funkce kompilátoru ‘Defined()’ pravdu. Na hodnotě testovaného objektu nezáleží, důležité je jen to, zda byl definován. Testovat lze tyto datové objekty: konstanty, proměnné, pole, spojové seznamy, struktury a rozhraní.
Při použití funkce kompilátoru ‘Defined()’ smí být prvním parametrem pouze název testovaného datového objektu a nesmí obsahovat žádné z obvyklých předpon či přípon, které se u daného objektu běžně používají. Například názvy konstant nesmějí obsahovat znak ‘#’ a názvy polí a spojových seznamů nesmějí obsahovat závorky. Jako druhý parametr, kterým předáváte typ testovaného objektu, můžete použít vestavěné konstanty; zde je úplný seznam dostupných konstant:
‘#PB_Constant’ ‘#PB_Variable’ ‘#PB_Array’ ‘#PB_LinkedList’ ‘#PB_Structure’ ‘#PB_Interface’
Možná jsem tento příkaz vylíčil tak, že to vypadá na složité použití, a tak bych měl tento dojem raději rozptýlit jednoduchým příkladem, který ukáže, jak snadné to ve skutečnosti je. Tento příklad testuje, zda byla definována proměnná ‘Name.s’, a pokud ne, definuje ji:
Global Name.s = "Name 1"
If Not Defined(Name, #PB_Variable)
;This will only define this variable if it hasn't been defined before
Global Name.s = "Name 2"
EndIf
Debug Name
Tento kód můžete vyzkoušet tak, že první řádek zakomentujete. Pokud to uděláte, proběhne definice proměnné uvnitř příkazu ‘If’ a hodnotou řetězcové proměnné bude nyní ‘Name 2’. Takový kód je neocenitelný u velkých projektů, kde do hlavního souboru možná vkládáte spoustu dalších souborů se zdrojovým kódem a potřebujete otestovat, zda už bylo dříve definováno něco důležitého. Pokud ne, pak to definujete.
Pokročilá nastavení kompilátoru
Při práci s PureBasicem může být potřeba pro určitý program přepnout kompilátor do jiného režimu nebo nechat kompilátor vypsat určité informace. K tomu nabízí PureBasic řadu nastavení kompilátoru. Většinu z nich můžete zapnout či vypnout vizuálně v IDE v okně ‘Compiler Options’ (Menu:Compiler->Compiler Options...). Chcete-li však mít přístup ke všem podporovaným nastavením kompilátoru, musíte kompilátor volat příkazem z příkazové řádky (shellu) a nastavení mu předat jako parametry.
Co je tedy vlastně rozhraní příkazové řádky? Je to malý program, který se obvykle dodává s operačním systémem (někdy se mu říká shell) a který umožňuje procházet pevný disk počítače, spouštět programy a ovládat funkce počítače psaním textových příkazů, jimž rozumí. Kromě textového vstupu nemá žádné jiné uživatelské rozhraní. Programů s rozhraním příkazové řádky existuje celá řada; k nejoblíbenějším zřejmě patří tyto:
‘CLI’ v AmigaOS ‘Command Prompt’ (Příkazový řádek) v Microsoft Windows XP ‘BASH’ v Linuxu ‘Terminal’ v MacOS X
Aby tato rozhraní příkazové řádky s PureBasicem správně spolupracovala, může být nutné přidat úplnou cestu k adresáři s kompilátorem do proměnné prostředí ‘PATH’. Rozhraní příkazové řádky pak vždy ví, kde se kompilátor nachází. Díky takové proměnné prostředí nemusíte při používání kompilátoru v příkazu shellu zadávat jeho úplnou cestu. Používání příkazové řádky podle mého názoru není příliš uživatelsky přívětivé, ale je to jediný způsob, jak využít některé pokročilejší funkce kompilátoru PureBasicu. Na druhou stranu je kompilátor použitelný z příkazové řádky někdy užitečný, zejména pokud chcete používat vlastní editor kódu – v něm si ho pak můžete nastavit jako externí nástroj.
Používání kompilátoru z příkazové řádky
Používání kompilátoru z příkazové řádky je docela jednoduché, jen musíte správně předávat nepovinné parametry. Samotný příkaz kompilátoru musí vždy začínat názvem kompilátoru PureBasicu, za nímž následují požadované parametry. Jediným povinným parametrem je soubor, který se kompilátoru předá ke zpracování.
V nejjednodušší podobě, kdy z jednoho souboru PureBasicu vytváříte spustitelný soubor, nepotřebuje kompilátor z příkazové řádky žádné nepovinné parametry, potřebuje však název souboru ‘*.pb’. Otevřete okno rozhraní příkazové řádky, zadejte do něj následující text a stiskněte Enter:
PBCompiler MyProgram.pb
Pokud je proměnná prostředí ‘PATH’ nastavena správně, tento příkaz spustí kompilátor PureBasicu a předá mu soubor ‘MyProgram.pb’. Kompilátor vytvoří ve stejném adresáři, v němž se nachází, dočasný spustitelný soubor a spustí jej, stejně jako kdybyste v IDE stiskli tlačítko ‘Compile/Run’. To je patrně nejjednodušší způsob, jak zkompilovat program z příkazové řádky.
Chcete-li program zkompilovat do spustitelného souboru s vlastním názvem a chcete, aby se tento soubor objevil ve stejném adresáři jako soubor se zdrojovým kódem, můžete použít tento příkaz shellu:
PBCompiler MyProgram.pb /exe "MyProgram.exe"
Tím se zkompiluje soubor ‘MyProgram.pb’ a vytvoří se z něj spustitelný soubor. Tento zkompilovaný spustitelný soubor se bude jmenovat ‘MyProgram.exe’ a bude umístěn ve stejném adresáři jako zadaný soubor ‘*.pb’. Všimněte si, že v tomto příkazu používáme nové nastavení kompilátoru, ‘/exe’. To kompilátoru říká, že chceme řádně pojmenovaný spustitelný soubor. Řetězec za tímto nastavením určuje, jak se má soubor jmenovat. Všechna nastavení kompilátoru pro příkazovou řádku začínají takto lomítkem ‘/’. Tyto dva příklady jsou poměrně snadno pochopitelné, v praxi se však přesně tyto příkazy používají jen zřídka. Lidé k jednoduchým kompilacím raději používají IDE PureBasicu. Je ale užitečné je znát, zejména pokud si chcete nastavit jiný editor kódu.
Při používání nastavení kompilátoru z příkazové řádky je také důležité vědět, že lze použít mnoho nastavení současně. Kdybych například chtěl zkompilovat soubor ‘*.pb’ do spustitelného souboru a přiřadit mu ikonu, použil bych příkaz shellu jako tento:
PBCompiler MyProgram.pb /exe "MyProgram.exe" /icon ".\icons\MyIcon.ico"
Kompilátor rozpozná, že řetězec za nastavením ‘/exe’ je název spustitelného souboru a řetězec za nastavením ‘/icon’ je soubor ikony, který se má tomuto spustitelnému souboru přiřadit. Všechna nastavení kompilátoru na příkazové řádce musí být vždy oddělena mezerami.
Nastavení kompilátoru PureBasicu pro příkazovou řádku
Následuje úplný seznam všech nastavení kompilátoru PureBasicu pro příkazovou řádku, včetně vysvětlení každého z nich a krátkého příkladu použití. Nezapomeňte, že většinu těchto nastavení lze zapnout vizuálně v IDE pomocí zaškrtávacího políčka nebo rozbalovací nabídky v okně ‘Compiler Options’.
Díky tomu můžete chování kompilátoru ovládat snadněji. U všech těchto nastavení příkazové řádky se navíc nerozlišují velká a malá písmena, takže je můžete zadávat velkými i malými písmeny, je to zcela na vás.
/?
Toto nastavení je dostupné pouze z příkazové řádky a zobrazí užitečnou stránku nápovědy s podrobným popisem všech dostupných nastavení kompilátoru PureBasicu pro příkazovou řádku. Stránka nápovědy se vypíše do okna shellu. Toto nastavení navíc potlačí všechna ostatní nastavení použitá ve stejném příkazu.
PBCompiler /?
/Commented
Další nastavení dostupné pouze z příkazové řádky, které spolu s výstupním spustitelným souborem vytvoří ve složce ‘PureBasic\Compilers’ okomentovaný soubor v assembleru s názvem ‘PureBasic.asm’. Tento soubor je surovým výstupem kompilátoru PureBasicu a obsahuje kompilátorem vygenerovaný zdrojový kód souboru ‘*.pb’ v assembleru. Tento soubor lze pomocí nastavení kompilátoru ‘/reasm’ znovu zkompilovat do spustitelného souboru, a to i když v něm provedete změny.
PBCompiler MyProgram.pb /commented
/Console
Toto nastavení kompilátoru umožňuje zkompilovat skutečnou konzolovou aplikaci. Zde je jednoduchý příklad:
PBCompiler MyProgram.pb /exe "MyProgram.exe" /console
Další informace o konzolových aplikacích najdete v kapitole 9 (Konzolové programy).
/Constant (Název=Hodnota)
Další nastavení dostupné pouze z příkazové řádky, které umožňuje dynamicky definovat konstantu přímo na příkazové řádce. To se může hodit například tehdy, když napíšete program, jehož funkčnost se mění podle hodnoty této konstanty. Například: ‘DEMO=1’ nebo ‘DEMO=0’.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /constant MY_STRING="Hello World"
Jak je z tohoto příkladu vidět, při definování konstanty na příkazové řádce nesmíte před název konstanty psát znak ‘#’ a kolem rovnítka (‘=’) nesmí být mezery. Pokud definujete řetězcovou konstantu, doporučuji ji uzavřít do dvojitých uvozovek jako v mém příkladu. Není to stoprocentně nutné, protože pokud uvozovky chybí, kompilátor se ji pokusí automaticky převést na řetězec, ale pokud řetězec obsahuje mezery, může se kompilátor zmást a ohlásit chybu. Pro jistotu tedy u řetězců dvojité uvozovky používejte.
/Debugger
Je-li toto nastavení kompilátoru použito samostatně, zapne se k ladění výsledného dočasného spustitelného souboru samostatný debugger (s grafickým rozhraním). Je-li použito spolu s nastavením ‘/exe’, vloží se do výsledného spustitelného souboru konzolový debugger. Konzolový debugger pak spolu se spuštěným programem zobrazí okno konzole, které umožní ladit program z příkazové řádky. Zde jsou oba příklady:
PBCompiler MyProgram.pb /debugger
PBCompiler MyProgram.pb /exe "MyProgram.exe" /debugger
/DLL
Toto nastavení kompilátoru umožňuje vytvořit ze zdrojového kódu PureBasicu soubor DLL (dynamicky linkovanou knihovnu). Je-li toto nastavení při kompilaci použito, vytvoří se výsledný soubor DLL ve složce ‘PureBasic\Compilers’ pod názvem ‘PureBasic.dll’. Tento soubor pak můžete přejmenovat, jak uznáte za vhodné. Jako vedlejší produkt vytvoření DLL tímto způsobem vznikne ve stejné složce také soubor statické knihovny ‘PureBasic.lib’ a exportní soubor ‘PureBasic.exp’.
PBCompiler MyProgram.pb /dll
Soubory se zdrojovým kódem PureBasicu, ze kterých se vytvářejí DLL, se obvykle skládají pouze z procedur. Některé z těchto procedur mají speciální názvy, které zkompilované knihovně dodávají další funkčnost. Více informací o DLL najdete dále v této kapitole.
/DynamicCpu
Toto nastavení příkazové řádky je téměř rovnocenné zadání všech nastavení ‘/mmx’, ‘/3dnow’, ‘/sse’ a ‘/sse2’ najednou. Pokud zdrojový kód vašeho programu obsahuje rutiny v assembleru (ASM), které podporují všechna tato rozšíření procesoru, a použijete nastavení kompilátoru ‘/dynamiccpu’, bude výsledný spustitelný soubor obsahovat veškerý kód specifický pro jednotlivé procesory. Při spuštění takového programu se zjistí typ procesoru v systému, na kterém program běží, a ze zkompilovaných rutin se vybere ta, která odpovídá architektuře daného procesoru. Program tedy pro různé procesory dynamicky používá různý kód, který obsahuje. Spustitelný soubor tak může být větší než obvykle, protože může obsahovat více verzí téže rutiny, ale program může běžet rychleji, protože jednotlivé rutiny mohou obsahovat kód optimalizovaný pro konkrétní procesor.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /dynamiccpu
/Exe "NázevSouboru"
Toto nastavení kompilátoru je velmi přímočaré: řetězec za částí ‘/exe’ je název, pod kterým se spustitelný soubor zkompiluje. Za částí ‘/exe’ musí vždy následovat řetězec s názvem spustitelného souboru a musí být vždy uzavřen do dvojitých uvozovek, jinak můžete dostat neočekávané výsledky. Při takové kompilaci se navíc vygenerovaný spustitelný soubor umístí do stejného adresáře jako zdrojový kód, z něhož byl zkompilován.
PBCompiler MyProgram.pb /exe "MyProgram.exe"
/Icon "NázevIkony"
Toto nastavení kompilátoru umožňuje určit ikonu na pevném disku, kterou má váš spustitelný soubor používat. Řetězec za částí ‘/icon’ musí být uveden a musí být uzavřen do dvojitých uvozovek, protože udává umístění požadovaného souboru ikony na pevném disku. Řetězec s umístěním souboru ikony může být v případě potřeby i relativní cestou, jako v tomto příkladu:
PBCompiler MyProgram.pb /exe "MyProgram.exe" /icon ".\icons\MyIcon.ico"
/IgnoreResident "NázevSouboru"
Nastavení dostupné pouze z příkazové řádky, které umožňuje zabránit načtení nainstalovaného rezidentního souboru během kompilace. To se hodí, pokud chcete znovu zkompilovat rezidentní soubor, který je již nainstalován ve složce ‘PureBasic\Residents’. Pokud nainstalovaný rezidentní soubor neignorujete a kompilujete jej znovu, můžete dostat chyby ‘Already defined’ (již definováno).
PBCompiler MyProg.pb /resident "MyResid.res" /ignoreresident "MyResid.res"
PBCompiler MyProgram.pb /exe "MyProgram.exe" /ignoreresident "MyResid.res"
První řádek ukazuje příklad kompilace rezidentního souboru s ignorováním dříve nainstalované verze. Druhý řádek je příkladem toho, co možná budete muset udělat, pokud ve svém programu znovu definujete konstanty nebo struktury, které se již nacházejí v nainstalovaném rezidentním souboru.
/InlineAsm
Toto nastavení kompilátoru zapíná vkládaný (inline) assembler v souboru ‘*.pb’. Jinými slovy, pokud jste ve zdrojovém kódu PureBasicu použili jakékoli příkazy jazyka symbolických adres (assembleru), měli byste tuto funkci zapnout, aby byly příkazy assembleru kompilátoru PureBasicu správně předány.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /inlineasm
/LineNumbering
Toto nastavení kompilátoru přidává do spustitelného souboru podporu interního číslování řádků příkazů. To je užitečné pro ladicí nástroje třetích stran nebo pokud používáte vestavěnou knihovnu ‘OnError’.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /linenumbering
Mějte na paměti, že pokud ve spustitelném souboru používáte číslování řádků, může se tím zpomalit jeho běh, protože do něj přidáváte o něco víc „režie“ než obvykle.
/Linker "NázevSouboru"
Nastavení dostupné pouze z příkazové řádky, které umožňuje předat linkeru přímo soubor, jenž může obsahovat příkazy pro linker.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /linker "MyLinkerCommands.txt"
/MMX, /3DNow, /SSE a /SSE2
Tato čtyři nastavení kompilátoru vytvářejí spustitelné soubory silně závislé na procesoru, podle toho, které nastavení je použito. Najednou lze použít pouze jedno z nich, protože spustitelný soubor přizpůsobují tak, aby obsahoval jen rutiny, které běží výhradně na procesorech podporujících daná rozšíření. Pokud jste v ASM vytvořili mnoho rutin podporujících všechna rozšíření procesoru, použijí se ve výsledném spustitelném souboru jen ty, které odpovídají zvolenému nastavení kompilátoru. Vytvoříte-li například spustitelný soubor s nastavením kompilátoru ‘/mmx’, použijí se ve výsledném spustitelném souboru jen rutiny MMX ze zdrojového kódu a tento soubor poběží pouze na procesorech, které podporují rozšíření MMX.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /mmx
PBCompiler MyProgram.pb /exe "MyProgram.exe" /3dnow
PBCompiler MyProgram.pb /exe "MyProgram.exe" /sse
PBCompiler MyProgram.pb /exe "MyProgram.exe" /sse2
/Quiet
Nastavení dostupné pouze z příkazové řádky, které potlačí veškerý zbytečný textový výstup kompilátoru příkazové řádky. To se hodí, když chcete kompilátor používat jako externí nástroj z jiného editoru kódu a podobně.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /quiet
/ReAsm
Nastavení dostupné pouze z příkazové řádky, které umožňuje znovu přeložit assemblerem a zkompilovat dříve exportovaný okomentovaný soubor ‘.asm’. Tyto okomentované soubory ‘.asm’ se vytvářejí pomocí nastavení kompilátoru ‘/commented’.
PBCompiler PureBasic.asm /reasm
Při použití tohoto příkazu musí být soubor ‘*.asm’, který se má znovu přeložit, ve složce ‘PureBasic\Compilers’, jinak dojde k chybě kompilátoru.
/Resident "NázevSouboru"
Nastavení dostupné pouze z příkazové řádky, které umožňuje vytvořit ze standardního souboru ‘*.pb’ rezidentní soubor. Rezidentní soubory se obvykle skládají pouze z definic konstant a struktur.
PBCompiler MyProgram.pb /resident "MyResident.res"
Za částí ‘/resident’ tohoto nastavení kompilátoru musí být uveden řetězec uzavřený do dvojitých uvozovek, protože určuje název nového rezidentního souboru. Pokud tento řetězec chybí nebo není uzavřen do dvojitých uvozovek, dojde k chybě kompilátoru. Při použití tohoto nastavení se rezidentní soubor vytvoří ve stejném adresáři, v němž je soubor se zdrojovým kódem.
/Resource "NázevSouboru"
Toto nastavení kompilátoru je určeno pouze pro Microsoft Windows, protože ke zkompilované knihovně DLL nebo spustitelnému souboru připojí soubor prostředků (resource) Windows. Za částí ‘/resource’ tohoto nastavení musí následovat řetězec uzavřený do dvojitých uvozovek, který určuje přidávaný soubor prostředků. Přidat lze pouze jeden soubor prostředků, ten však může v případě potřeby obsahovat odkazy na další soubory prostředků. Soubor prostředků také nesmí být zkompilovaný, musí jít o soubor ASCII obsahující direktivy.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /resource "MyResource.rc"
/Standby
Toto nastavení příkazové řádky používá IDE k zavedení kompilátoru do paměti, kde čeká na předávané příkazy. Běžní uživatelé ho obvykle nepoužívají, protože dokumentace o tom, jak s kompilátorem komunikovat, když je zaveden v paměti, je velmi skromná.
/Subsystem "NázevSubsystému"
Toto nastavení kompilátoru umožňuje určit subsystém, který se použije při kompilaci programu. Subsystémy jsem podrobně popsal o něco dříve v této kapitole, takže se zde nebudu opakovat. Ve výchozím stavu je k dispozici několik vestavěných subsystémů, ze kterých můžete při kompilaci programu vybírat:
Windows:
PBCompiler MyProgram.pb /exe "MyProgram.exe" /subsystem "NT4"
PBCompiler MyProgram.pb /exe "MyProgram.exe" /subsystem "OpenGL"
Linux:
PBCompiler MyProgram.pb /exe "MyProgram.exe" /subsystem "GTK2"
MacOS X:
PBCompiler MyProgram.pb /exe "MyProgram.exe" /subsystem "GTK"
PBCompiler MyProgram.pb /exe "MyProgram.exe" /subsystem "GTK2"
Jak je z těchto příkladů vidět, za částí ‘/subsystem’ tohoto nastavení kompilátoru musíte uvést název subsystému uzavřený do dvojitých uvozovek.
/Thread
Toto nastavení kompilátoru zapne pro zkompilovaný spustitelný soubor bezpečnost pro vlákna. Mělo by se použít, pokud kompilujete program, který využívá vlákna. Při použití tohoto příkazu je třeba pamatovat na to, že výsledný spustitelný soubor může běžet o něco pomaleji než soubor, který bezpečný pro vlákna není. Je to kvůli dodatečné „režii“ potřebné k tomu, aby byl spustitelný soubor bezpečný pro vlákna.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /thread
Více informací o vláknech najdete dále v této kapitole.
/Unicode
Toto nastavení kompilátoru zapne pro zkompilovaný spustitelný soubor podporu Unicode. Unicode je schéma kódování znaků, které používá 16 bitů (2 bajty) na znak, aby bylo možné v jediné znakové sadě zakódovat všechny znaky všech hlavních světových jazyků, živých i mrtvých. Použití tohoto nastavení znamená, že všechny použité příkazy PureBasicu i vnitřní správa řetězců budou plně kompatibilní s Unicode.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /unicode
/Version
Nastavení dostupné pouze z příkazové řádky, jehož jedinou funkcí je vypsat do okna rozhraní příkazové řádky verzi použitého kompilátoru PureBasicu. Toto nastavení potlačí všechna ostatní nastavení použitá ve stejném příkazu.
PBCompiler /version
/XP
Toto nastavení kompilátoru je určeno pouze pro Microsoft Windows XP. Přidává do spustitelných souborů podporu vzhledů (skinů) Windows XP, aby se gadgety a okna správně zobrazovaly s motivem, pokud je pro grafické rozhraní Windows nějaký motiv použit.
PBCompiler MyProgram.pb /exe "MyProgram.exe" /xp
Zpracování parametrů příkazové řádky
Při vývoji programů v PureBasicu můžete někdy chtít vytvořit nástroje pro příkazovou řádku, které při spuštění příkazem shellu přijímají určité parametry. Funguje to podobně jako u kompilátoru PureBasicu: program se spustí, předají se mu parametry a jejich hodnoty určují, jakou funkci program vykoná. V tomto oddílu vám ukážu, jak takové parametry předávané vašemu programu zpracovat.
Co jsou parametry?
Při předávání parametrů (někdy se jim říká argumenty) programům pro příkazovou řádku musíte mít na paměti, jak se předávají a co se vlastně za parametr považuje. Vezměme si například tento příklad s kompilátorem z dřívější části kapitoly:
PBCompiler MyProgram.pb /exe "MyProgram.exe"
Tento příkaz shellu dává operačnímu systému pokyn spustit program ‘PBCompiler’ a předat mu tři parametry (‘MyProgram.pb’, ‘/exe’ a ‘"MyProgram.exe"’). Přestože za názvem souboru ‘*.pb’ (což je první parametr) používáme jen jedno nastavení kompilátoru, toto nastavení se skládá ze dvou dalších parametrů.
Při takovém předávání parametrů programům program rozhoduje o tom, kolik parametrů dostal, podle počtu mezer, které za názvem programu vidí. Potřebujete-li mít mezery uvnitř jediného parametru, musíte tento parametr uzavřít do dvojitých uvozovek. Všechny následující příkazy shellu by například programu s názvem ‘MyProgram’ předaly dva parametry:
MyProgram /a 105
MyProgram /play /now
MyProgram /play "Me And My Shadow"
MyProgram "Put It In The" "Back"
Jak je z těchto příkladů vidět, parametry mohou být čísla i řetězce, ale při předání do programu se všechny automaticky převedou na řetězce. Pokud parametry při předávání uzavíráte do dvojitých uvozovek (zejména parametry s mezerami), mějte na paměti, že se tyto uvozovky před samotným předáním řetězce odstraní, takže předáváte pouze řetězec uvnitř nich, nikoli uvozovky.
Čtení předaných parametrů uvnitř programu
Když jsou programu předány parametry z příkazu shellu, uloží se interně, abyste je ve svém programu mohli přečíst, kdy uznáte za vhodné. Voláním příkazu ‘ProgramParameter()’ můžete z tohoto vnitřního seznamu získávat jeden parametr po druhém. Jakmile příkaz ‘ProgramParameter()’ vrátí všechny parametry, začne vracet prázdný řetězec. Zde je ukázkový program, který vypíše všechny parametry předané programu:
NumberOfParameters.l = CountProgramParameters()
Text.s = "List of parameters passed:" + #LF$ + #LF$
If NumberOfParameters > 0
For x.l = 1 To NumberOfParameters
Text.s + ProgramParameter() + #LF$
Next x
Else
Text.s + "None"
EndIf
MessageRequester("Info", Text)
První řádek tohoto příkladu používá příkaz ‘CountProgramParameters()’, který vrací přesný počet platných parametrů předaných programu. Po zavolání tohoto příkazu pak pomocí cyklu ‘For’ opakovaně volám příkaz ‘ProgramParameter()’, abych získal všechny parametry. Kdybych tento kód zkompiloval do spustitelného souboru a pojmenoval ho ‘ListParameters.exe’, mohl bych mu příkazem shellu předat nějaké parametry, například takto:
ListParameters /one /two /three
Tyto parametry jsou pro tento příklad jen vymyšlené, takže můžete použít jakékoli jiné; před parametry jsem dal lomítko, protože to se zdá být u konzolových programů, které používám, běžným zvykem. Jakmile tento příkaz zadáte a program se spustí, bude hodnota uložená v proměnné ‘NumberOfParameters’ rovna ‘3’ a při každém volání příkazu ‘ProgramParameter()’ program postupně dostane jeden z těchto parametrů. Při prvním použití vrátí příkaz ‘ProgramParameter()’ hodnotu ‘/one’, při druhém ‘/two’ a při třetím ‘/three’. Kdybych příkaz ‘ProgramParameter()’ zavolal počtvrté, vrátil by prázdný řetězec.
Rozhodování na základě parametrů
Pokud parametry příkazové řádky používáte k řízení funkčnosti nebo výstupu programu, budete potřebovat, aby program prováděl různé akce v závislosti na hodnotách předaných parametrů. Někdy bude potřeba, aby program při předání určitého parametru udělal něco úplně jiného. Rozhodování na základě předaných parametrů není tak těžké, jak si možná myslíte – hodnoty parametrů jednoduše testujete běžnými příkazy ‘If’ a ‘Select’.
Tento postup předvádí následující příklad, který testuje, zda je jeden nebo více předaných parametrů ‘Mouse’, ‘Cat’ nebo ‘Dog’. Zkuste tomuto programu předat jeden nebo dva z těchto parametrů a podívejte se na výstup:
;Count parameters
NumberOfParameters.l = CountProgramParameters()
;Add all command line parameters to a linked list
Global NewList Parameters.s()
If NumberOfParameters > 0
For x.l = 1 To NumberOfParameters
AddElement(Parameters())
Parameters() = UCase(ProgramParameter())
Next x
EndIf
;Check to see if a particular parameter was passed
Procedure ParameterPassed(Parameter.s)
ForEach Parameters()
If Parameter = Parameters()
ProcedureReturn #True
EndIf
Next
ProcedureReturn #False
EndProcedure
;Check to see if the parameter 'Mouse' was passed
If ParameterPassed("MOUSE")
MessageRequester("Info", "'Mouse' was specified as a parameter.")
EndIf
;Check to see if the parameter 'Cat' was passed
If ParameterPassed("CAT")
MessageRequester("Info", "'Cat' was specified as a parameter.")
EndIf
;Check to see if the parameter 'Dog' was passed
If ParameterPassed("DOG")
MessageRequester("Info", "'Dog' was specified as a parameter.")
EndIf
Pokud se na tento příklad podíváte pozorně, uvidíte, že používám příkaz ‘UCase()’ (Helpfile:Reference Manual- >General Libraries->String->UCase), který převede všechny předané parametry na velká písmena. Díky tomu mohu parametry porovnávat jako řetězce, aniž bych se musel starat o velikost písmen. Pokud to ve svých programech uděláte, stačí vám porovnávat s řetězci psanými velkými písmeny, jak je vidět v příkazech ‘If’. Je to dobrý zvyk, protože nezáleží na tom, jak uživatel parametry zadá (velkými, malými či smíšenými písmeny) – před porovnáním v ‘If’ se vždy převedou na velká písmena.
Přidat programům podporu příkazové řádky využitím parametrů tímto způsobem se může zdát staromódní a upřímně řečeno to staromódní je. Když však uživatelům umožníte používat vaši aplikaci či nástroj z příkazové řádky, bude ji používat více lidí a program získá na všestrannosti. Při tvorbě softwaru o tom rozhodně stojí za to uvažovat.
Podrobněji o číselných datových typech
Číselné datové typy umožňují ukládat čísla v několika různých formátech a každý typ k jejich uložení používá trochu jiné množství paměti. Nezní to jako nic zásadního, jenže množství paměti, které číselný typ zabírá, přesně určuje jeho číselný rozsah. Když se vrátíte ke kapitole 2 a podíváte se na obr. 2, uvidíte přehled rozsahů všech číselných typů PureBasicu. Tyto meze jsou dány konečným počtem bitů v paměti, kterou tyto datové typy alokují. Podíváte-li se například na datový typ Byte (.b), uvidíte, že zabírá jeden bajt paměti, který se skládá z osmi binárních číslic neboli „bitů“. S těmito bity lze k vyjádření čísel manipulovat jen konečným počtem způsobů. Osm bitů lze ve skutečnosti uspořádat pouze do dvou set padesáti šesti (256) jedinečných kombinací, přičemž každý bit je buď ‘1’, nebo ‘0’. To znamená, že osmibitovým binárním číslem (bajtem) lze vyjádřit jen dvě stě padesát šest různých čísel.
V tomto oddílu vám vysvětlím, jak se čísla ukládají v paměti a jak se binární čísla vlastně počítají. Doufám, že vám to umožní trochu lépe nahlédnout do vnitřního fungování nejen PureBasicu, ale počítačů obecně.
Při práci s čísly v programovacích jazycích je třeba jasně rozlišovat mezi celými čísly a čísly s plovoucí desetinnou čárkou. Celá čísla mohou být kladná i záporná, ale neobsahují desetinnou čárku. Čísla s plovoucí desetinnou čárkou naproti tomu mohou být rovněž kladná i záporná, ale desetinnou čárku vždy obsahují. Už jsem to v této knize vysvětloval, ale řekl jsem si, že vám to zde připomenu.
Co je dvojková soustava?
Dvojkový zápis (binární notace), někdy také nazývaný soustava o základu dvě, je číselná soustava, v níž mohou číslice binárního čísla nabývat pouze jedné ze dvou hodnot, ‘0’ nebo ‘1’. Podobně jako v desítkové soustavě (soustavě o základu deset) představuje každá pozice binární číslice jinou hodnotu (váhu).
Vysvětlím tento koncept trochu názorněji. Zde je příklad desítkového čísla:
542
V tomto příkladu stojí číslice ‘2’ na pozici s váhou jedna, číslice ‘4’ na pozici s váhou deset a číslice ‘5’ na pozici s váhou sto. Každá váha je desetkrát větší než váha pozice vpravo od ní. Chcete-li zjistit, jaké číslo tento zápis představuje, jednoduše vynásobíte hodnotu každé číslice váhou její pozice a výsledky sečtete, tj. (‘5’ x sto) + (‘4’ x deset) + (‘2’ x jedna) = ‘542’ (pět set čtyřicet dva).
Stejně fungují i binární čísla (o základu dvě), pokud jde o celá čísla. I zde je s pozicí každé číslice binárního čísla spojena určitá váha, jen je váha každé pozice dvakrát větší než váha pozice vpravo od ní – jde přece o soustavu o základu dvě. Možná to zní krkolomně, ale na obrázku je to překvapivě snadno pochopitelné. Podívejte se na obr. 44.

Obr. 44: Byte bez znaménka — číselný rozsah: ‘0’ až ‘255’
Hodnotu, kterou toto binární číslo představuje, zjistíme stejným postupem jako v desítkové soustavě (o základu deset). Hodnotu každé číslice vynásobíme váhou její pozice a výsledky sečteme. Například hodnota zápisu ‘01001101’, jak je vidět na obr. 44, je ‘77’. Protože dvojkový zápis používá pouze číslice 0 a 1, zjednoduší se postup „vynásob a sečti“, který jsem předvedl na číslech o základu deset, na pouhé sčítání vah těch pozic, na nichž stojí binární hodnota ‘1’. Když se tedy podíváte na obr. 44 a sečtete váhy pozic, kde se objevuje binární hodnota ‘1’, dostanete: ‘64 + 8 + 4 + 1 = 77’.
Z obr. 44 je teď asi zřejmé, že s tímto počtem bitů lze binárně vyjádřit jen konečné množství čísel. Proto mají jednotlivé typy určité meze – prostě jim dojdou bity. Větší typy fungují úplně stejně, jen mají k výpočtu více bitů.
Celá čísla se znaménkem a bez znaménka
Na dřívějším obr. 2 vidíte, že rozsah mnoha celočíselných typů PureBasicu sahá od záporných po kladná čísla. Těmto typům se říká číselné typy se znaménkem, protože jejich hodnoty mohou obsahovat záporné znaménko. Typy bez znaménka jsou naopak celočíselné typy, jejichž číselný rozsah sahá od nuly do nějakého většího kladného čísla. Příkladem celočíselného typu bez znaménka je typ Character v PureBasicu, který je rovněž uveden na obr. 2. Protože tyto datové typy alokují jen konečný počet bitů, jsou potřeba dvě metody interpretace těchto binárních čísel podle toho, zda se mají číst jako čísla se znaménkem, nebo bez znaménka.
Jak je vidět na obr. 45, každý celočíselný datový typ lze číst dvěma způsoby. Například Byte může být se znaménkem i bez znaménka a obě varianty mohou obsahovat hodnotu z rozsahu dvou set padesáti šesti (256) možných čísel včetně nuly... ano, i nula je číslo!

Obr. 45 — * V PureBasicu v4 není k dispozici (možná v budoucích verzích?)
Binární čtení celých čísel bez znaménka
Číslo bez znaménka se binárně vyjadřuje snadno, jak jsme viděli na obr. 44. Stačí nastavovat bity na 1 a sečíst váhy pozic, kde se objevuje ‘1’. Například maximální hodnota bajtu bez znaménka vyjádřená binárně je ‘11111111’ (‘255’), kde jsou všechny bity nastaveny na ‘1’. Pěkně jednoduché.
Binární čtení celých čísel se znaménkem
Celé číslo se znaménkem se binárně vyjadřuje podle trochu jiných pravidel. PureBasic k vyjádření celých čísel se znaménkem používá systém zvaný dvojkový doplněk (Two’s Complement). Ve tvaru dvojkového doplňku udává bit binárního čísla se znaménkem, který je nejvíce vlevo (někdy se mu říká nejvýznamnější bit), zda celé číslo obsahuje znaménko (-). Je-li bit nejvíce vlevo ‘0’, je číslo vyjádřené bity kladné a lze ho přečíst výše vysvětlenou metodou pro čísla bez znaménka. Je-li bit nejvíce vlevo ‘1’, je vyjádřené číslo záporné a je nutné ho číst ve tvaru dvojkového doplňku, jak je vysvětleno níže.
Protože znaménkový bit nejvíce vlevo je vyhrazen k označení, zda je znaménko přítomno, zbývají vám k vyjádření zbytku čísla jen ostatní bity. Vezměme opět jako příklad Byte: ponecháme-li znaménkový bit na ‘0’, abychom vyjádřili kladné číslo, zbývá nám k sestavení čísla pouze sedm bitů, a ty všechny nastavíme na ‘1’, takto: ‘01111111’. Tím je vyjádřeno největší kladné celé číslo, které může bajt se znaménkem obsahovat, v tomto případě ‘127’.
Chceme-li binárně vyjádřit záporné celé číslo, musíme postupovat trochu jinak. Podívejme se nejprve na binární vyjádření čísla ‘9’ bez znaménka, které je ‘00001001’. Bit nejvíce vlevo je nula, takže s jistotou víme, že jde o kladné celé číslo. Abychom ho převedli do tvaru dvojkového doplňku a vyjádřili jako záporné celé číslo, musíme nejprve invertovat bity a k invertovanému binárnímu číslu pak přičíst jedničku (‘1’). Číslo ‘-9’ tedy vypadá takto: ‘11110111’. Invertováním bitů myslím to, že bit s hodnotou ‘0’ změníte na ‘1’ a bit s hodnotou ‘1’ na ‘0’, a to u všech bitů daného typu. Jak vidíte, bit nejvíce vlevo je nyní ‘1’, což znamená, že toto binární číslo představuje záporné celé číslo (se znaménkem). Invertování bitů kladného celého čísla a přičtení ‘1’ je metoda dvojkového doplňku, kterou se vyjadřuje záporná podoba tohoto čísla.
Chcete-li toto záporné celé číslo převést zpět na kladné, postupujete úplně stejně. Po invertování ‘-9’ (‘11110111’) vypadá binární číslo takto: ‘00001000’, pak k němu přičteme jedničku (‘1’) a dostaneme ‘00001001’, což při čtení běžnou metodou pro čísla bez znaménka dává kladnou ‘9’. Obr. 46 názorně ukazuje bajt se znaménkem, který obsahuje hodnotu ‘-9’.

Obr. 46: Byte se znaménkem — číselný rozsah: ‘-128’ až ‘127’
Přestože jsem v posledních několika oddílech k popisu čtení binárních čísel používal typ Byte, tyto metody jsou univerzální pro jakýkoli celočíselný typ bez ohledu na jeho velikost. U všech celočíselných typů roste váha každé pozice bitu o mocninu ‘2’, jak se v binárním čísle posouváte doleva. U binárních čísel se znaménkem je bit nejvíce vlevo vždy znaménkovým bitem.
Čísla s plovoucí desetinnou čárkou a dvojková soustava
Číslo s plovoucí desetinnou čárkou je číslo, které obsahuje desetinnou čárku a může být záporné i kladné. Taková čísla se ukládají způsobem, při kterém čárka v čísle „plove“, takže je možné ukládat velmi velká i velmi malá čísla. Díky takovému způsobu uložení lze uchovávat obrovský rozsah čísel, ovšem za cenu číselné přesnosti. Přestože jsou čísla s plovoucí desetinnou čárkou mimořádně všestranná, musíte počítat s tím, že pokud ukládáte mnoho desetinných míst, může dojít ke ztrátě části přesnosti.
PureBasic v současnosti podporuje dva datové typy pro práci s čísly s plovoucí desetinnou čárkou: běžný typ Float a typ Double. Rozdíl mezi nimi spočívá v počtu bitů, které k uložení čísla používají. Float používá 32 bitů (4 bajty) a Double 64 bitů (8 bajtů), takže typ Double je pochopitelně při uchovávání velkých čísel mnohem přesnější. Proč tedy místo typu Float nepoužívat vždy Double? Jedním z důvodů je rychlost. Čtení hodnot typu Float z paměti může být mnohem rychlejší, zejména při práci s velkými poli typu Float. Je to proto, že z paměti načítáte jen poloviční počet bajtů oproti typu Double. Programy jako hry obvykle používají Float, zatímco programy, které potřebují větší přesnost, obvykle používají Double.
Binární ukládání čísel s plovoucí desetinnou čárkou
Kvůli zvláštní povaze čísel s plovoucí desetinnou čárkou, která musí uchovávat desetinnou čárku a k ní velké číslo napravo, nalevo nebo na obou stranách od ní, se k jejich binárnímu ukládání používá jiná metoda. Tato metoda je poměrně složitá a je popsána ve standardu ‘IEEE 754’ pro binární kódování čísel s plovoucí desetinnou čárkou. Pokusím se ji popsat co nejjednodušeji.
Za prvé, všechna čísla s plovoucí desetinnou čárkou se ukládají ve třech binárních částech. Těmito částmi jsou znaménko (Sign), exponent (Exponent) a mantisa (Significand). Všechny tři části se vejdou do bitového rozsahu daného použitím typu Float nebo Double. Viz obr. 47.

Obr. 47: 32bitový Float, 64bitový Double (float s dvojitou přesností)
Zde vidíte, jak je typ vnitřně rozdělen pro jednotlivé tři části. Nyní už jen potřebujeme pochopit, jak se číslo s plovoucí desetinnou čárkou zakóduje, aby se do těchto částí vešlo. Znaménkový bit je asi nejsnáze vysvětlitelnou částí. Je-li kódované číslo kladné, bude znaménkový bit ‘0’, a je-li záporné, bude znaménkový bit ‘1’. Začněme ukázkovým číslem a já vám předvedu, jak se zakóduje do 32bitového typu Float. Vezměme číslo ‘10.625’.
Krok první: zakódování čísla do dvojkové soustavy
Abychom toto číslo zakódovali tak, aby se vešlo do binárních částí typu Float, musíme projít několika kroky. Nejprve musíme do dvojkové soustavy převést obě strany od desetinné čárky, takto:
‘10.625’ = ‘1010.101’
Může to vypadat trochu podivně, protože jste desetinnou čárku (nebo zde přesněji řádovou čárku) v binárním čísle nejspíš ještě neviděli. Slouží to jen k názornému zobrazení čísla v této fázi, takže se nelekejte. Takové kódování čísla do dvojkové soustavy se od dříve vysvětleného trochu liší, protože na jedné straně řádové čárky máte celé číslo a na druhé zlomek. Celočíselnou část zakódujete snadno, protože se řídí standardním kódováním bez znaménka, jak je vysvětleno u obr. 44, tj. desítkové ‘10’ = binární ‘1010’. Zlomková část naproti tomu používá podobnou metodu, ale v binárním vyjádření zlomku jsou váhy pozic samy zlomky, nikoli celá čísla. U těchto binárních čísel je také nedoplňujeme zbytečnými nulami.
Ve standardním zápisu bez znaménka začínají váhy na ‘1’ a čím dále se v binárním čísle posouváte doleva, tím se násobí faktorem ‘2’, kdežto ve zlomkovém binárním zápisu začínají váhy na ‘0.5’ a čím dále se posouváte doprava, tím se dělí faktorem ‘2’. Podívejte se na obr. 48.

Obr. 48: Zakódování desetinného zlomku do dvojkové soustavy
Zde vidíte, že váhy zlomkového binárního čísla začínají na ‘0.5’ a s každou pozicí směrem doprava se dělí faktorem ‘2’, takže vycházejí ‘0.5’, ‘0.25’, ‘0.125’ atd. Čím více pozic doprava máte, tím větší přesnost může zlomkové číslo mít. Protože naše číslo má zlomkovou část ‘.625’, lze ji snadno vyjádřit jako ‘0.5’ + ‘0.125’, a proto se na těchto místech objevují binární ‘1’.
Znalost toho, jak se zlomek vyjadřuje binárně, vám ovšem při jeho kódování nemusí nutně pomoci, zejména u obrovských desetinných zlomků. Naštěstí existuje snadný způsob, jak taková čísla zakódovat – trik se zdvojováním.
Nejprve vezmeme výchozí zlomek ‘.625’, zdvojnásobíme ho a podíváme se, zda je větší nebo roven ‘1.0’. Pokud ano, zapíšeme binární ‘1’. Pak vezmeme zlomkovou část posledního výsledku, opět ji zdvojnásobíme a otestujeme. Pokud v kterémkoli kroku zdvojnásobení nedá číslo větší nebo rovné ‘1.0’, zapíšeme binární ‘0’. V praxi to vypadá takto:
.625 * 2 = 1.25 – to je větší nebo rovno ‘1.0’, takže zapíšeme binární ‘1’. .25 * 2 = 0.5 – to není větší ani rovno ‘1.0’, takže zapíšeme binární ‘0’. .5 * 2 = 1.0 – to je větší nebo rovno ‘1.0’, takže zapíšeme binární ‘1’.
Jakmile už nezbývají žádné zlomkové části k testování nebo vám dojdou bity k vyplnění, přestanete počítat. Když se nyní podíváte na binární číslice, které z těchto výpočtů vyšly, a přečtete je shora dolů, uvidíte ‘101’, přesně jak se pro ‘.625’ očekávalo.
Teď, když víme, jak zakódovat desetinný zlomek do dvojkové soustavy, mohu pokračovat ve vysvětlování, jak se tato čísla kódují do 32bitového typu Float. Prvním krokem tedy bylo zakódovat naše číslo do binární podoby, takto:
‘10.625’ = ‘1010.101’
Krok druhý: posunutí řádové čárky a výpočet exponentu
V tomto kroku musíme posunout řádovou čárku, protože ta se ve výsledném binárním čísle kódovat nebude. Protože řádová čárka určuje, kde je desetinná čárka v desítkové podobě čísla, musíme si ve skutečnosti pamatovat, kde byla, abychom ji při dekódování mohli vrátit na původní místo. Uděláme to tak, že řádovou čárku posouváme v binárním čísle, dokud nalevo od ní nezůstane jen jediná ‘1’. Přebytečné nuly vlevo lze ignorovat, ale jejich pozice se musí započítat, pokud jimi řádová čárka projde. Podívejte se na tento příklad:
‘1010.101’ (původní) ‘1.010101’ (řádová čárka posunuta o 3 místa doleva)
Při posouvání řádové čárky si musíme poznamenat, o kolik míst jsme ji posunuli. Zde jsem ji posunul o ‘3’ místa doleva, aby nalevo od ní zůstala úvodní ‘1’, takže počet míst, o které se řádová čárka posunula, bude kladné číslo. Kdyby původní binární číslo bylo něco jako ‘0.0001101’, musel bych řádovou čárku posunout doprava, aby nalevo od ní zůstala jediná úvodní ‘1’ (nuly nepočítaje), což by dalo záporný posun řádové čárky ‘-4’. (K tomu, proč je tato ‘1’ vždy vlevo, se za chvíli dostanu.)
Počet míst, o které musíte řádovou čárku posunout, aby nalevo od ní zůstala jen úvodní ‘1’, se zaznamená jako exponent. Tento exponent se pak přičte k přednastavenému číslu (podle velikosti použitého typu s plovoucí desetinnou čárkou), aby bylo zaručeno, že se zakóduje jako číslo bez znaménka. Například u 32bitového typu Float musíte přičíst ‘127’; tomuto číslu se říká posun exponentu (Exponent Bias).
V našem původním příkladu jsme řádovou čárku posunuli o ‘3’ místa doleva (tedy o kladné 3), takže k ‘3’ přičteme ‘127’ a dostaneme ‘130’. Toto číslo se pak zakóduje do dvojkové soustavy standardní metodou bez znaménka, jak je popsána u obr. 44, což dá ‘10000010’. To se pak uloží do části exponentu v 32bitovém typu Float, jak ukazuje obr. 47. Protože ukládáme počet míst, o které se řádová čárka posunula, znamená to, že počet bitů části exponentu ve skutečnosti omezuje, jak velký posun řádové čárky můžeme zaznamenat. Toto omezení je ‘127’ míst doleva a ‘(-)126’ míst doprava. Cokoli nad ‘127’ se považuje za „nekonečno“ a cokoli pod ‘-126’ se považuje za denormalizované číslo, což je zvláštní případ, kdy exponent zůstává na ‘-126’ a úvodní ‘1.’ se změní na úvodní ‘0.’.
Krok třetí: výpočet mantisy
Mantisa je ta část čísla s plovoucí desetinnou čárkou, která obsahuje významnou část čísla. Ve skutečnosti je v ní uloženo samotné číslo, exponent vám pouze říká, kde má vůči mantise ležet řádová čárka. Po posunutí řádové čárky ve druhém kroku by naše binární číslo nyní mělo vypadat takto: ‘1.010101’
Abychom z něj vypočítali mantisu, nejprve úplně vypustíme ‘1’ na začátku tohoto binárního čísla. Tuto ‘1’ nikdy není třeba kódovat, protože tam je vždy – každé číslo, které chceme zakódovat pomocí typu s plovoucí desetinnou čárkou, tam bude mít vždy ‘1’, takže ji lze naprosto bezpečně vypustit, pokud nezapomeneme ji při dekódování binárního čísla vrátit zpět. Vypuštěním této číslice získáme v mantise o jeden bit navíc, který nám pomůže původní desítkové číslo vyjádřit. Nezapomeňte, že čím více bitů máme, tím přesněji dokážeme původní číslo vyjádřit.
Po vypuštění ‘1’ na začátku binárního čísla ztrácí smysl i řádová čárka, takže se jí můžeme rovněž zbavit. Binární číslo teď vypadá takto: ‘010101’. To je naše mantisa. Je-li mantisa kratší než 23 bitů jako v tomto příkladu, musíme ji doplnit nulami na požadovanou délku 23 bitů. Tyto nuly musí být na pravé straně, takto: ‘01010100000000000000000’. To je nyní úplná mantisa, která se uloží do části mantisy v 32bitovém typu Float, jak ukazuje obr. 47.
Celkově by tedy binární vyjádření čísla ‘10.625’ bylo: ‘0 10000010 01010100000000000000000’
Omezení čísel s plovoucí desetinnou čárkou
Přestože jsou čísla s plovoucí desetinnou čárkou velmi všestranná, jsou kvůli způsobu binárního uložení ze své podstaty také nepřesná. Nebuďte šokováni, když z proměnné typu Float přečtete jiné číslo, než jaké jste do ní původně přiřadili. U typu Float s jednoduchou přesností je správně vyjádřeno jen asi 7 desítkových číslic a u typu Double asi 16. K další ztrátě přesnosti desetinných čísel může dojít i při aritmetických operacích s čísly s plovoucí desetinnou čárkou, které celkovou přesnost znovu nahlodávají. Na to je třeba při používání typů Float a Double vždy pamatovat.
Přímé používání binárních čísel v PureBasicu
Binární čísla lze proměnným přiřazovat přímo pomocí předpony ‘%’. Takto použitý znak procenta si nepleťte s operátorem modulo z kapitoly 3 (Úvod do operátorů), přestože používají stejný symbol. PureBasic to rozpozná jako binární přiřazení, protože nalevo od znaku není žádný výraz a napravo od něj není mezera. Zde je příklad:
BinaryVariable.b = %01101101
Debug BinaryVariable
Takto binárně lze přiřazovat hodnoty všem číselným typům PureBasicu.
Ukazatele
Myslím, že lze bez nadsázky říci, že ukazatele v programování nahánějí spoustě lidí strach. Netuším proč, protože při řešení určitých programátorských problémů vám ukazatele dávají obrovskou moc. Možná je to strach z neznámého, co lidi vede k tomu, že se jim vyhýbají? Nevím, ale co vím jistě, je to, že když se lidem ukazatele pořádně vysvětlí, vždycky se pak diví, proč se jim tak dlouho vyhýbali. Tento oddíl je věnován ukazatelům: tomu, jak je PureBasic vytváří a používá, a výhodám, které vám jako programátorovi přinášejí.
Co je to tedy ukazatel? Zjednodušeně řečeno je ukazatel v PureBasicu proměnná, která obsahuje číselnou adresu určitého místa v paměti. Je to tak jednoduché! A co jsou adresy v paměti? Představte si, že každý bajt v paměti má přiřazené jedinečné číslo, jako by byly všechny bajty uloženy v jednom obrovském poli. Každý bajt v paměti lze vyhledat podle jeho čísla (adresy). Protože moderní počítače obsahují tisíce bajtů, bývají tyto číselné adresy obvykle dost velká čísla.
Získání adresy v paměti
Teď už víme, že ukazatel je jen proměnná obsahující adresu v paměti, a potřebujeme se ještě naučit, jak získat adresu v paměti něčeho užitečného. K tomu slouží speciální jednoznakové funkce, které vracejí adresu v paměti datového objektu, před který je zapíšeme.
| Datový objekt | Funkce | Příklad použití |
|---|---|---|
Proměnné |
@ |
@VariableName |
Pole |
@ |
@ArrayName() |
Procedury |
@ |
@ProcedureName() |
Návěští |
? |
?LabelName |
Obr. 49: Funkce pro získání adresy v paměti
Na obr. 49 vidíte obě speciální funkce pro získání adresy v paměti a datové objekty, se kterými pracují. Funkce ‘@’ je univerzálnější, protože funguje s proměnnými, poli i procedurami. Funkce ‘?’ je vyhrazena pro návěští. Zde je jednoduchý příklad, který ukazuje, jak zjistit adresu proměnné typu Byte v paměti:
MyByteVar.b = 100
Debug MyByteVar
Debug @MyByteVar
V tomto příkladu jsem definoval proměnnou typu Byte nazvanou ‘MyByteVar’ a přiřadil jí hodnotu ‘100’, což je zcela přímočaré. Na posledním řádku kódu zjišťuji adresu této proměnné v paměti tak, že před její název zapíšu ‘@’. Takto použitý znak ‘@’ vrátí adresu proměnné ‘MyByteVar’ v paměti, kterou jsem pak vypsal do okna Debug Output. Spustíte-li výše uvedený příklad a podíváte se do okna Debug Output, uvidíte, že se zobrazí původní hodnota ‘100’ a pod ní adresa proměnné typu Byte. Adresa je obvykle obrovské číslo, většinou dlouhé asi sedm nebo osm číslic, a může se lišit podle toho, na jakém počítači příklad spustíte. Je to proto, že různé počítače mohou paměť pro uložení onoho bajtu přidělovat trochu odlišně.
Když tento příklad spustím na svém PC, zobrazí se mi v okně Debug Output toto:
100
4298004
Z toho vyčtu, že proměnná typu Byte, ve které je uložena hodnota ‘100’, se nachází na adrese v paměti ‘4298004’.
Pomocí těchto speciálních funkcí lze získat adresu v paměti u všech typů proměnných, polí, procedur i návěští, což může být velmi užitečné. Zde je příklad, který by byl v praxi celkem k ničemu, ale ukazuje, jak získat adresy všech těchto různých datových objektů a vypsat je do okna Debug Output:
MyByteVar.b = 1
MyWordVar.w = 2
MyLongVar.l = 3
MyQuadVar.q = 4
MyFloatVar.f = 5
MyDoubleVar.d = 6
MyStringVar.s = "Seven"
Dim MyLongArray.l(8)
Procedure MyProcedure(Test.l)
Debug "Testing my procedure."
EndProcedure
Debug "Byte variable address: " + Str(@MyByteVar)
Debug "Word variable address: " + Str(@MyWordVar)
Debug "Long variable address: " + Str(@MyLongVar)
Debug "Quad variable address: " + Str(@MyQuadVar)
Debug "Float variable address: " + Str(@MyFloatVar)
Debug "Double variable address: " + Str(@MyDoubleVar)
Debug "String variable address: " + Str(@MyStringVar)
Debug "Array address: " + Str(@MyLongArray())
Debug "Procedure address: " + Str(@MyProcedure())
Debug "Label address: " + Str(?Label)
DataSection
Label:
Data.s "Testing"
EndDataSection
Všimněte si, že při získávání adresy polí, procedur nebo návěští nemusíte uvádět žádné doplňky, jako jsou identifikátory typů, rozměry polí, parametry apod. A i když bylo pole ve výše uvedeném příkladu definováno takto:
...
Dim MyLongArray.l(8)
...
k získání jeho adresy v paměti stačí použít jeho název se závorkami na konci, například takto:
@MyLongArray()
Podobně při získávání adresy procedury potřebujete jen její název se závorkami:
@MyProcedure()
Nejsou potřeba žádné typy ani parametry. Totéž platí i pro návěští. Přestože se definují s dvojtečkou na konci názvu, při použití s funkcí pro získání adresy se dvojtečka úplně vynechá, takto:
?Label
Získat adresu v paměti všech těchto různých datových objektů je snadné díky jednoduchému způsobu, jakým funkce pro získání adresy fungují. Pro začátek a pro přehlednost bych doporučoval všechny získané adresy v paměti ukládat do proměnných, aby byl kód úhledný a čitelný, a vždy jim dávat dobré, výstižné názvy.
Vytváření a pojmenovávání ukazatelů
Jak jsem řekl na začátku, ukazatel je proměnná, která obsahuje číselnou adresu místa v paměti. Neřekl jsem však, že ukazatel je zvláštní druh proměnné, který se řídí několika pravidly. Zaprvé se ukazatele v PureBasicu vytvářejí tak, že jako první znak jejich názvu použijete hvězdičku ‘*’. Například takto:
*Pointer
Zadruhé jsou ukazatele číselným typem, jehož velikost se může měnit podle architektury počítače, pro kterou se program kompiluje. Například na 32bitovém systému zabere ukazatel k uložení čísla 4 bajty paměti, zatímco na 64bitovém systému 8 bajtů.
Ukazatel v PureBasicu navíc není svázán s žádným konkrétním typem. To znamená, že pokud ukazatel definujete s hvězdičkou spolu s některým z vestavěných číselných typů, vestavěný typ se zahodí, aby měl ukazatel správnou velikost pro architekturu vašeho počítače. Pokud byste tedy ukazatel definovali takto, s typem Byte:
*Pointer.b = @Variable
typ Byte se zahodí a ukazatel bude i nadále zabírat 4 bajty na 32bitovém systému a 8 bajtů na 64bitovém systému.
Hvězdička, která je součástí názvu ukazatele, je navíc trvalým znakem. Jakmile tedy ukazatel definujete, musíte ji při jeho používání vždy ponechat jako součást názvu. Například tyto dvě proměnné jsou zcela odlišné a nemají spolu nic společného:
MyVariable.l
*MyVariable.l
Přestože se tyto proměnné liší jen hvězdičkou, první je proměnná typu Long, kdežto druhá je ukazatel (definovaný hvězdičkou). V jiných jazycích se hvězdička zapisuje před proměnné, aby se podle potřeby vrátila jejich hodnota nebo adresa v paměti, a proto je důležité pochopit, že PureBasic touto rozšířenou funkcí nedisponuje. Obě proměnné se považují za dvě naprosto odlišné proměnné.
Vytváření proměnných-ukazatelů pomocí hvězdičky je účinný způsob, jak je v PureBasicu odlišit od ostatních typů, a dává vám dobré vizuální vodítko, jaká data mohou obsahovat. V nápovědě tuto konvenci používají také všechny příklady syntaxe týkající se paměti, aby programátoři věděli, kde jsou potřeba ukazatele. Stačí se podívat na některé příklady syntaxe příkazů pro práci s pamětí (Helpfile:Reference Manual->General Libraries->Memory) – hvězdičky jsou tam všude.
S využitím této konvence lze první příklad přepsat takto:
MyByteVar.b = 100
*MemoryAddress = @MyByteVar
Debug MyByteVar
Debug *MemoryAddress
Všimli jste si hvězdičky před názvem ukazatele? Díky tomuto způsobu snadno poznáte, které proměnné jsou ukazatele a které ne.
Strukturovaný přístup k paměti pomocí ukazatele
V dalším příkladu vám ukážu, jak lze ukazatel použít jako strukturovanou proměnnou. Tento ukazatel má stejnou velikost jako kterýkoli jiný, ale k paměti, na kterou ukazuje, můžeme přistupovat strukturovanějším způsobem.
Structure DETAILS
Age.l
Height.l
EndStructure
My.DETAILS
My\Age = 32
My\Height = 168
*Pointer.DETAILS = @My
Debug *Pointer\Age
Debug *Pointer\Height
Zde vidíte, že jsem definoval strukturu nazvanou ‘DETAILS’, která obsahuje dvě pole typu Long. Hned poté definuji proměnnou nazvanou ‘My’ s touto strukturou a přiřadím do jejích řetězcových polí nějaká data. A právě zde se při vytváření ukazatele může hodit zvláštní funkce hvězdičky. Pokud vytvoříme ukazatel na strukturovanou proměnnou pomocí hvězdičky, můžeme nastavit jeho hodnotu tak, že mu přiřadíme adresu v paměti, takto:
*Pointer.DETAILS = @My
Tím se vytvoří ukazatel nazvaný ‘Pointer’ a jeho hodnota se nastaví na adresu strukturované proměnné ‘My’ v paměti. Protože jsme při definici proměnné ‘Pointer’ použili jako typ strukturu, můžeme k paměti, na kterou ukazuje, přistupovat strukturovaně.
Tyto dva řádky, které vypisují data do okna Debug Output:
Debug *Pointer\Age
Debug *Pointer\Height
tedy ve skutečnosti vypisují data obsažená ve strukturované proměnné ‘My’; tato data jen získáváme pomocí nově vytvořeného ukazatele. Opět platí, že zde vytvořený ukazatel je jen proměnná obsahující číselnou adresu v paměti – nevytváří žádnou kopii dat. Obr. 50 názorně ukazuje, jak to v paměti funguje.

Obr. 50: Strukturovaná proměnná ‘My.DETAILS’ v paměti
K čemu je to dobré? Například k vrácení více než jedné hodnoty z procedury. Můžete třeba uvnitř procedury vytvořit strukturovanou proměnnou s klíčovým slovem ‘Static’ a přiřadit jí hodnoty. Pak z procedury vrátíte její adresu v paměti. Tuto adresu pak můžete použít k vytvoření ukazatele na strukturovanou proměnnou, který vám zpřístupní data přiřazená v proceduře. Nějak takto:
Structure MEALS
Breakfast.s
Dinner.s
Tea.s
EndStructure
Procedure.l GetMeals()
Static Gary.MEALS
Gary\Breakfast = "Cornflakes"
Gary\Dinner = "Cheese sandwiches"
Gary\Tea = "Spaghetti bolognese"
ProcedureReturn @Gary
EndProcedure
*Gary.MEALS = GetMeals()
Debug *Gary\Breakfast
Debug *Gary\Dinner
Debug *Gary\Tea
Klíčové slovo ‘Static’ zde používáme proto, aby se data ve strukturované proměnné ‘Gary’ zachovala i po návratu z procedury, jinak by byla zničena. Adresa v paměti vrácená touto procedurou se pak přiřadí ukazateli na strukturovanou proměnnou nazvanému ‘*Gary’ (všimněte si hvězdičky). K této paměti pak můžeme přistupovat pomocí struktury ‘MEALS’. Jak vidíte, je to opravdu velmi šikovné.
Pro ještě větší pružnost lze nově vytvořenému ukazateli na strukturovanou proměnnou přiřadit adresu v paměti proměnné libovolného typu, a to i vestavěných typů PureBasicu. Zde je ukázka:
Structure SCREENCOORDS
x.w
y.w
EndStructure
Coordinates.l = %00000011000000000000010000000000
*Screen.SCREENCOORDS = @Coordinates
Debug *Screen\x
Debug *Screen\y
Zde definuji 32bitovou proměnnou typu Long pomocí binárního zápisu a pojmenuji ji ‘Coordinates’. Pak její adresu v paměti přiřadím nově vytvořenému ukazateli na strukturovanou proměnnou nazvanému ‘*Screen’. Protože struktura, kterou jsem pro ukazatel použil, obsahuje dvě 16bitová pole typu Word, 32bitová hodnota, na kterou se ukazuje, se nevejde jen do jednoho z polí, ale překryje obě a rozdělí se uprostřed. Díky tomu mohu z této jediné proměnné získat dvě hodnoty, a to hodnoty ‘x’ a ‘y’.
Předání strukturované proměnné proceduře pomocí ukazatele
Libovolnou strukturovanou proměnnou lze proceduře předat jako ukazatel, aby s ní procedura mohla pracovat. Je to v PureBasicu jediný způsob, jak strukturovanou proměnnou proceduře skutečně předat. Když takto předáváte strukturované proměnné, předáváte je ve skutečnosti „odkazem“ (‘By Reference’), velmi podobně jako pole a spojové seznamy. To znamená, že se hodnoty do žádných parametrů ve skutečnosti „nekopírují“. Místo toho se proceduře předá ukazatel a pomocí něj se pracuje s původní strukturovanou proměnnou. Jednou z hlavních věcí, které musíte při použití této metody brát v úvahu, je to, že když proceduře předáváte strukturovanou proměnnou, název parametru procedury se nemusí shodovat s názvem předávané strukturované proměnné. Ať však parametr pojmenujete jakkoli, stále pracujete s původní předanou strukturovanou proměnnou. Zde je příklad:
Structure COORDINATES
x.l
y.l
EndStructure
Point.COORDINATES
Procedure IncreaseValues(*Var.COORDINATES)
*Var\x + 10
*Var\y + 10
EndProcedure
Point\x = 100
Point\y = 100
IncreaseValues(@Point)
Debug Point\x
Debug Point\y
Zde jsem definoval strukturu nazvanou ‘COORDINATES’ a vytvořil z ní strukturovanou proměnnou nazvanou ‘Point’. Když jsou do této proměnné přiřazeny hodnoty všech polí, předám její adresu v paměti proceduře ‘IncreaseValues()’.
V definici procedury ‘IncreaseValues()’ jsem definoval jeden parametr ve tvaru ‘Var.COORDINATES’. Takto definovaný parametr říká proceduře, aby očekávala ukazatel na strukturovanou proměnnou vytvořenou ze struktury ‘COORDINATES’. Název ‘Var’ může být jakýkoli (pokud začíná hvězdičkou), slouží jen jako pohodlný způsob, jak s předaným ukazatelem pracovat. Když tedy ve výše uvedené proceduře napíšu toto:
...
*Var\x + 10
*Var\y + 10
...
ve skutečnosti dělám toto:
Point\x + 10
Point\y + 10
protože procedura pracuje s daty uloženými na předané adrese v paměti.
Tento způsob předávání strukturovaných proměnných procedurám se může velmi hodit v situacích, kdy chcete předat velké množství informací pěkně seskupených dohromady, například adresní údaje, konfigurační údaje nebo jakákoli konkrétně seskupená nastavení či hodnoty. Díky této metodě také můžete procedurám předávat méně parametrů, protože je všechny předáte v jedné strukturované proměnné. Jako příklad z praxe: před několika lety jsem napsal proceduru pro odesílání e-mailů, které jsem mohl předat strukturovanou proměnnou obsahující údaje o poštovním účtu spolu s příjemcem, předmětem, zprávou atd. Věci se tím prostě stávají o něco čitelnějšími a lépe zvládnutelnými.
Čtení a zápis hodnot pomocí ukazatelů
Když získáte adresu v paměti, můžete ji použít mnoha různými způsoby. Pravděpodobně nejběžnějším způsobem je čtení hodnot z tohoto místa v paměti nebo ukládání nových dat do něj. Tomu se říká „peekování“ a „pokování“ (peeking a poking). Příkazem ‘Peek’ data z místa v paměti čtete a příkazem ‘Poke’ do něj ukládáte nová data.
PureBasic obsahuje osm příkazů ‘Peek’ a osm příkazů ‘Poke’, které plně pokrývají všechny vestavěné datové typy. Všechny tyto příkazy jsou pojmenovány prakticky stejně, jen poslední písmeno názvu příkazu odpovídá typu, se kterým pracuje. Chcete-li například přečíst bajt z určité adresy v paměti, použijete příkaz ‘PeekB()’, který (jak naznačuje ‘B’ v jeho názvu) vrátí bajt z daného místa v paměti. Podobně pokud byste chtěli zapsat řetězec na určitou adresu v paměti, použili byste ‘PokeS()’. Podrobněji si o všech těchto šestnácti příkazech můžete přečíst v oddílu ‘Memory’ v nápovědě PureBasicu (Helpfile:Reference Manual->General Libraries->Memory).
Čtení hodnot uložených v paměti
Použití příkazu peek je docela přímočaré: předáte mu místo v paměti (třeba uložené v ukazateli) a příkaz peek vrátí data, která se tam nacházejí. Chcete-li získat určitý datový typ, musíte použít příslušný příkaz peek. Zde je příklad čtení bajtu z místa v paměti pomocí příkazu ‘PeekB()’:
Weight.b = 30
*Weight = @Weight
ReadValue.b = PeekB(*Weight)
Debug ReadValue
Zde přiřazuji hodnotu ‘30’ proměnné typu Byte nazvané ‘Weight’. Na dalším řádku přiřazuji její adresu v paměti ukazateli nazvanému ‘*Weight’ (všimněte si hvězdičky). Další řádek obsahuje příkaz ‘PeekB()’, který skutečně přečte hodnotu typu Byte z předaného ukazatele a vrátí ji. Pro parametr adresy nejste nuceni používat ukazatele (i když je to kvůli přehlednosti vhodné); tento příklad bychom mohli napsat i takto:
Weight.b = 30
ReadValue.b = PeekB(@Weight)
Debug ReadValue
Zde používám proměnnou typu Byte přímo s funkcí pro získání adresy a ukazatele se úplně zbavuji. Záleží asi na tom, co vám nejvíc vyhovuje. Nakonec všechny příkazy ‘Peek’ potřebují jako parametr místo v paměti, které jim lze předat buď definovaným ukazatelem, nebo (přímočařeji) návratovou hodnotou funkce pro získání adresy.
Zápis hodnot do paměti
Zapisování hodnot do paměti je stejně snadné jako použití příkazu ‘Peek’. Při zápisu však musíte zadat novou hodnotu spolu s adresou v paměti, kam se má uložit. Zde je příklad zápisu nové hodnoty typu Long do paměti existující proměnné typu Long:
Weight.l = 1024
*Weight = @Weight
PokeL(*Weight, 333)
Debug Weight
Začínáme tím, že proměnné ‘Weight’ přiřadíme původní hodnotu ‘1024’. Pak jsem vytvořil ukazatel nazvaný ‘*Weight’, který obsahuje adresu proměnné ‘Weight’ v paměti. Poté se příkazem ‘PokeL()’ zapíše hodnota ‘333’ na místo v paměti určené prvním parametrem. Nová hodnota proměnné ‘Weight’ se nakonec vypíše do okna Debug Output.
Varování při zápisu nových hodnot
Dávejte si velký pozor, kam nové hodnoty zapisujete. Používání příkazů PureBasicu pro práci s pamětí může být dost nebezpečné, pokud nevíte, co děláte. Například příkazy ‘Poke’ nemají žádnou vnitřní kontrolu, která by vám řekla, zda můžete na určitou adresu v paměti bezpečně zapsat hodnotu. Libovolnému příkazu ‘Poke’ byste mohli jako adresu v paměti předat náhodné číslo a on tam s klidem zapíše hodnotu. Je to dvousečná zbraň: tuto moc občas potřebujete k přeskupování hodnot v paměti, ale může vést k problémům. Uděláte-li chybu, můžete poškodit místo v paměti, které potřebuje číst nějaký důležitý program. To může vést k pádu programu nebo k něčemu ještě horšímu, například k pádu operačního systému.
Chcete-li do paměti zapisovat bezpečně, zapisujte na místo v paměti existující proměnné nebo pole, případně do paměti přidělené příkazem ‘AllocateMemory()’ (Helpfile:Reference Manual->General Libraries->Memory->AllocateMemory). Přitom dbejte na to, aby žádné hodnoty zapsané do těchto oblastí paměti nepřekročily přidělené místo. Bylo by například špatným zvykem zapsat hodnotu typu Long na místo v paměti proměnné typu Byte, protože byste zapsali o 3 bajty dat více, než byste měli. Fungovalo by to sice, protože se neprovádí žádná kontrola chyb, ale přepsali byste 3 bajty potenciálně důležitých dat a poškodili to, co tam bylo.
Adresa v paměti jako počáteční index
Pokud čtete hodnoty ze souvislých bloků paměti nebo do nich hodnoty zapisujete, můžete adresu prvního bajtu v paměti použít jako počáteční index pro zbytek bloku. To je užitečné zejména při používání ukazatelů na pole. Podívejte se na tento příklad:
Dim Numbers.l(2)
Numbers(0) = 100
Numbers(1) = 200
Numbers(2) = 300
*ArrayPointer = @Numbers()
Debug PeekL(*ArrayPointer)
Debug PeekL(*ArrayPointer + 4)
Debug PeekL(*ArrayPointer + 8)
Po vytvoření pole proměnných typu Long nazvaného ‘Numbers’ přiřadím každému z jeho indexů číselnou hodnotu v rozmezí od ‘100’ do ‘300’. Poté vytvořím ukazatel nazvaný ‘*ArrayPointer’, který obsahuje adresu pole v paměti.
Když takto vytvoříte jakékoli pole, všechny jeho indexy se vytvoří v jednom souvislém bloku paměti, takže všechna data, která pole obsahuje, jsou uložena těsně vedle sebe. Adresa v paměti, kterou vrátí funkce pro získání adresy zapsaná před pole, je adresa prvního indexu. Ukazatel nazvaný ‘*ArrayPointer’ tedy ve skutečnosti obsahuje adresu prvku pole ‘Numbers(0)’ v paměti.
Když použijeme řádek kódu, jako je tento:
...
Debug PeekL(*ArrayPointer)
...
čteme hodnotu z místa v paměti prvního indexu. Že je tomu tak, se můžete přesvědčit podle první hodnoty vypsané do okna Debug Output. Chceme-li z pole přečíst další hodnoty, musíme tento ukazatel použít jako počáteční místo a přičíst k němu počet bajtů, o který se chceme v paměti posunout. Víme, že typ Long zabírá čtyři bajty, takže ukazatel můžeme zvětšit o ‘4’, abychom získali další hodnotu typu Long uloženou v paměti přidělené tomuto poli. Přesně to dělají následující řádky kódu z výše uvedeného příkladu: čtou hodnoty z dalších míst v paměti pole a jako počáteční místo používají ukazatel na pole.
...
Debug PeekL(*ArrayPointer + 4) ;This echoes the second Long value: ‘200’
Debug PeekL(*ArrayPointer + 8) ;This echoes the third Long value: ‘300’
Názorně to ukazuje obr. 51. Kdybych používal pole bajtů, musel bych samozřejmě ukazatel na pole zvětšit o ‘1’, abych přečetl druhý bajt, o ‘2’, abych přečetl třetí, atd. Podobně kdybych používal typ Word, musel bych ukazatel pokaždé zvětšit o ‘2’ bajty.

Obr. 51: Pole ‘Numbers’ v paměti
Vlákna
Vlákno je samostatná posloupnost instrukcí, která se provádí jako oddělená úloha, ale přitom zůstává součástí programu, z něhož vzešla. Každý program může mít několik souběžně běžících vláken, z nichž každé plní jinou úlohu, například čeká na události nebo provádí časově náročnou práci. Vlákna jsou odnoží hlavního programu, která dokáže provádět instrukce nezávisle na něm. Pokud se původní program ukončí, vlákno se automaticky zastaví a zruší také. Jaké programy tedy vlákna používají? Použít je může v podstatě jakýkoli program, ale většinou se programují do aplikací, které potřebují dělat více věcí najednou. Pokud byste například psali nástroj pro vyhledávání souborů na pevném disku, kód pro vyhledávání byste nejspíš napsali tak, aby se prováděl ve vlákně. Pak by nenarušoval překreslování grafického rozhraní ani zpracování událostí v hlavní smyčce. Vyhledávání by mohlo probíhat nezávisle, aniž by zhoršovalo odezvu hlavního rozhraní. Jiným příkladem může být program, který zpracovává velké soubory. Protože jejich zpracování, ať už jakékoli, trvá dost dlouho, můžete je chtít zpracovávat ve vlákně, aby se hlavní program mezitím mohl věnovat jiným věcem. To jsou jen dva z mnoha způsobů, jak mohou vlákna vyřešit určitý programátorský problém.
Používání vláken
Než vám začnu ukazovat, jak vlákna používat, předvedu vám pro srovnání jednoduchý program, který vlákna nepoužívá. Tento příklad dvakrát volá proceduru, pokaždé proto, aby vložila hodnoty do jednoho ze dvou různých gadgetů typu ListView. Všimněte si, že když stisknete tlačítko ‘Start Test’, nemůžete hýbat oknem ani nevidíte, jak se do gadgetů skutečně vkládá text, dokud obě volání procedury neskončí.
Enumeration
#WINDOW_ROOT
#LIST_ONE
#LIST_TWO
#BUTTON_TEST
EndEnumeration
Procedure InsertText(Gadget.l)
For x.l = 1 To 25
AddGadgetItem(Gadget, -1, Str(x))
Delay(100)
Next x
EndProcedure
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_ROOT, 0, 0, 290, 200, "Thread Test", #FLAGS)
If CreateGadgetList(WindowID(#WINDOW_ROOT))
ListViewGadget(#LIST_ONE, 10, 10, 130, 150)
ListViewGadget(#LIST_TWO, 150, 10, 130, 150)
ButtonGadget(#BUTTON_TEST, 95, 170, 100, 20, "Start Test")
Repeat
EventID.l = WaitWindowEvent()
Select EventID
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_TEST
InsertText(#LIST_ONE)
InsertText(#LIST_TWO)
EndSelect
EndSelect
Until EventID = #PB_Event_CloseWindow
EndIf
EndIf
End
Při spuštění tohoto příkladu si také všimnete, že obě volání procedury ‘InsertText()’ v hlavní smyčce probíhají jedno po druhém. To znamená, že první procedura musí skončit, než může začít druhá – tak koneckonců procedurální programy fungují. V tomto případě nám na tom vlastně nezáleží, protože kvůli příkazu ‘Delay()’ použitému v proceduře ‘InsertText()’ stejně nevidíme žádné aktualizace v gadgetech ListView.
Tato prodleva dokonce brání programu ve zpracování interních zpráv pro překreslení uživatelského rozhraní nebo pro obsluhu přesunu okna v operačním systému. Prostě klepneme na tlačítko a musíme počkat, až procedury skončí, než můžeme s programem znovu pracovat. Představte si teď, že jde o program na zpracování obrázků a tyto dvě procedury potřebují na to, co dělají, třicet minut. To je hodně dlouhá doba čekání, než můžete pohnout oknem programu nebo uvidět jakoukoli změnu v uživatelském rozhraní. Nemohli bychom dokonce ani vykreslovat ukazatel průběhu!
Pokud chceme, aby obě volání procedury probíhala současně a zcela nezávisle na hlavním uživatelském rozhraní, můžeme vytvořit dvě vlákna, která poběží zároveň s hlavním programem. Lze to udělat takto:
Enumeration
#WINDOW_ROOT
#LIST_ONE
#LIST_TWO
#BUTTON_TEST
EndEnumeration
;Insert text into the specified list gadget
Procedure InsertText(Gadget.l)
For x.l = 1 To 25
AddGadgetItem(Gadget, -1, Str(x))
Delay(100)
Next x
EndProcedure
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_ROOT, 0, 0, 290, 200, "Thread Test", #FLAGS)
If CreateGadgetList(WindowID(#WINDOW_ROOT))
ListViewGadget(#LIST_ONE, 10, 10, 130, 150)
ListViewGadget(#LIST_TWO, 150, 10, 130, 150)
ButtonGadget(#BUTTON_TEST, 95, 170, 100, 20, "Start Test")
Repeat
EventID.l = WaitWindowEvent()
Select EventID
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_TEST
Thread1.l = CreateThread(@InsertText(), #LIST_ONE)
Thread2.l = CreateThread(@InsertText(), #LIST_TWO)
EndSelect
EndSelect
Until EventID = #PB_Event_CloseWindow
EndIf
EndIf
End
Když se pozorně podíváte, jediný rozdíl mezi těmito dvěma příklady je ve způsobu, jakým se procedury volají. Každé nově vytvořené vlákno v PureBasicu začíná svůj život jako běžná procedura, definovaná ve zdrojovém kódu obvyklým způsobem a vždy s jedním parametrem. Chcete-li z ní vytvořit vlákno, použijete příkaz ‘CreateThread()’ (Helpfile:Reference Manual->General Libraries->Thread->CreateThread), který sám přijímá dva parametry. Prvním je adresa v paměti procedury, kterou chcete spustit jako vlákno. Druhým je povinný parametr, který může být libovolného typu. Tento parametr musíte proceduře předat vždy, ať ho používáte, nebo ne; zde jsem ho použil k určení, do kterého gadgetu se má text vkládat.
Pokud při takovém vytváření vlákna vrátí příkaz ‘CreateThread()’ hodnotu větší než nula, vlákno bylo úspěšně vytvořeno a okamžitě spuštěno. Tato hodnota (v případě úspěchu) je navíc identifikátor vlákna typu Long, který lze používat s dalšími příkazy z knihovny ‘Thread’ (Helpfile:Reference Manual->General Libraries->Thread).
Shrňme si tedy, jaká pravidla musíme dodržet, abychom z procedury vytvořili vlákno.
1). Procedura vlákna musí mít jeden, a to právě jeden parametr. 2). Procedura vlákna nemůže vracet žádnou hodnotu. Pokud nějakou hodnotu vrátí, bude ztracena.
Když spustíte tento příklad s vlákny, uvidíte, jak se hodnoty vkládají do obou gadgetů ListView v reálném čase. Zatímco se hodnoty vkládají, můžete také posouvat okno programu po obrazovce a všimnete si, že se nyní normálně překresluje a aktualizuje. Dvě nově vytvořená vlákna se stala nezávislými částmi téhož programu, které běží současně s ním. Pokud by se hlavní program kdykoli ukončil, budou tato dvě vlákna rovněž přerušena a ukončena.
Pokud si všimnete, že se do některého z gadgetů vkládá zkomolený text, musíte zajistit, aby byla zapnutá volba kompilátoru ‘Create Threadsafe Executable’, jak je popsáno v rámečku „Kompilace programů bezpečných pro vlákna“.
Čekání na dokončení vláken
Používání vláken může být někdy trochu záludné a občas při řešení jedněch problémů přináší problémy nové. Pokud vlákna používáte v hlavním programu, jsou vždy vydána na milost délce jeho života. To znamená, že když hlavní program skončí nebo ho uživatel zavře, přidružená vlákna se ukončí také.
V PureBasicu můžete tento problém obejít pomocí příkazu ‘WaitThread()’ (Helpfile:Reference Manual->General Libraries->Thread->WaitThread). Tento příkaz zajistí, že vlákno dokončí svou úlohu, než bude hlavní program pokračovat. Zde je příklad:
Procedure DrawNumbers(Unused.l)
For x.l = 1 To 20
PrintN(Str(x))
Delay(75)
Next x
EndProcedure
If OpenConsole()
ThreadID.l = CreateThread(@DrawNumbers(), 0)
WaitThread(ThreadID)
Print("Press Return to quit") : Input()
CloseConsole()
EndIf
End
Za řádkem s vytvořením vlákna vidíte, že jsem použil příkaz ‘WaitThread()’. Ten přijímá jeden parametr, kterým je identifikátor dříve vytvořeného vlákna. Tento příkaz pozastaví normální provádění programu, dokud vlákno určené identifikátorem neskončí, jinými slovy, dokud procedura použitá k vytvoření vlákna nedokončí svou úlohu. Příkaz ‘WaitThread()’ může v případě potřeby přijmout volitelný druhý parametr, který určuje časový limit v milisekundách. Jakmile tento časový limit uplyne, provádění programu pokračuje bez ohledu na stav daného vlákna. Tento volitelný druhý parametr jsem ve svém příkladu nepoužil, protože chci zajistit, aby procedura vlákna skončila dříve, než budete moci program ukončit příkazem ‘End’. Pokud řádek s ‘WaitThread’ zakomentujete, všimnete si, že můžete kdykoli za běhu programu stisknout klávesu Enter a program zavřít, čímž úlohu vlákna fakticky předčasně přerušíte. S příkazem ‘WaitThread()’ na místě však musíte počkat, až vlákno skončí, než se na stisk klávesy zareaguje.
Bezpečné používání sdílených prostředků
Používáte-li v jednom programu mnoho vláken, musíte jejich činnost programovat velmi pečlivě, zejména pokud těmto vláknům dovolujete používat sdílené prostředky. Když se mnoho vláken pokouší číst a zapisovat do stejného souboru nebo místa v paměti přesně ve stejnou chvíli, skončí to vždycky poškozenými soubory a spoustou slz. Aby k tomu nedocházelo, nabízí PureBasic jednoduchý mechanismus, který ke sdílenému prostředku pustí v daném okamžiku jen jedno vlákno. Tímto mechanismem je mutex.
Mutex je datový objekt, který lze použít jako zámek, jenž zabrání vláknům používat prostředek, pokud ho právě používá jiné vlákno. Jakmile mutex ve svém kódu použijete k ochraně sdíleného prostředku, nedovolí vláknům pokračovat, dokud ho nezamknou. Jakmile vlákno objekt mutexu zamkne, může chráněný prostředek volně používat. Pokud se mezitím jiné vlákno pokusí zamknout tentýž mutex, bude toto druhé vlákno fakticky pozastaveno, dokud první vlákno mutex neodemkne, a nebude tak moci ze sdíleného prostředku číst ani do něj zapisovat. Zde je příklad, ve kterém pomocí mutexu řídím přístup k výpisu do konzole.
Global ConsoleAccess.l = CreateMutex()
Procedure DrawNumbers(ThreadNumber.l)
LockMutex(ConsoleAccess)
ConsoleLocate(ThreadNumber * 20, 0)
ConsoleColor((ThreadNumber + 1) * 3, 0)
Print("Thread " + Str(ThreadNumber) + " locked.")
For x.l = 1 To 20
ConsoleLocate(ThreadNumber * 20, x + 1)
Print(Str(x))
Delay(75)
Next x
UnlockMutex(ConsoleAccess)
EndProcedure
If OpenConsole()
EnableGraphicalConsole(#True)
Thread0.l = CreateThread(@DrawNumbers(), 0)
Thread1.l = CreateThread(@DrawNumbers(), 1)
Thread2.l = CreateThread(@DrawNumbers(), 2)
WaitThread(Thread0)
WaitThread(Thread1)
WaitThread(Thread2)
ConsoleLocate(0, 23)
Print("Press Return to quit") : Input()
CloseConsole()
EndIf
End
Po spuštění tohoto kódu bude každé vlákno vypisovat čísla do konzole, ale protože jsem v proceduře ‘DrawNumbers()’ použil mutex, může mutex zamknout a pokračovat ve výpisu do konzole vždy jen jedno vlákno.
První řádek kódu vytvoří nový objekt mutexu; to se provádí příkazem ‘CreateMutex()’ (Helpfile:Reference Manual->General Libraries->Thread->CreateMutex). Tento příkaz nevyžaduje žádné parametry, ale po zavolání vrátí handle nově vytvořeného objektu mutexu. Vrácený handle je 32bitová číselná hodnota, proto jsem ho uložil do proměnné typu Long nazvané ‘ConsoleAccess’.
Když je objekt mutexu vytvořen, musím zařídit, aby se procedury mých vláken řídily jeho stavem, tedy tím, zda je zamčený, nebo odemčený. K tomu musím do všech procedur vláken, které budou tento sdílený prostředek používat, přidat příkazy pro zamčení a odemčení. V mém příkladu mám jen jednu proceduru vlákna, takže tuto funkčnost stačí přidat tam. Kdybych přidal další procedury vláken, které by vypisovaly do konzole, musel bych je naprogramovat tak, aby se stavem tohoto mutexu řídily také.
Aby vlákno mohlo získat zámek objektu mutexu, použijeme příkaz ‘LockMutex()’ (Helpfile:Reference Manual->General Libraries->Thread->LockMutex). Tento příkaz přijímá jeden parametr, kterým je handle objektu mutexu, jejž chceme zamknout. Pokud je mutex momentálně odemčený, příkaz ‘LockMutex()’ ho zamkne a program normálně pokračuje. Pokud však mutex již zamklo jiné vlákno, příkaz ‘LockMutex()’ vlákno pozastaví, dokud ho nebude moci zamknout samo, což bude až poté, co ho druhé vlákno odemkne.
V praxi to můžete vidět v mém příkladu s mutexem: před výpisem do konzole mutex zamknu a po dokončení ho odemknu, čímž umožním ostatním vláknům, aby ho zamkla a pokračovala ve výpisu. Odemknutí objektu mutexu je stejně jednoduché jako zavolání příkazu ‘UnlockMutex()’ (Helpfile:Reference Manual- >General Libraries->Thread->UnlockMutex), kterému jako parametr předáte handle objektu mutexu, jejž chcete odemknout.
Pokračování vlákna, když je mutex zamčený
Když vaše vlákno používá sdílený prostředek chráněný mutexem, může být někdy užitečné, aby se úplně nezastavilo, když nemůže zamknout již zamčený objekt mutexu. Můžete potřebovat, aby vlákno mezitím dělalo něco jiného nebo aby informovalo o samotném stavu mutexu. V takovém případě můžete použít příkaz ‘TryLockMutex()’ (Helpfile:Reference Manual->General Libraries->Thread- >TryLockMutex). Příkaz ‘TryLockMutex()’ dělá přesně to, co říká jeho název: pokusí se zamknout mutex zadaný prvním parametrem. Pokud se to nepodaří, protože zadaný mutex již zamklo jiné vlákno, vrátí tento příkaz ‘0’ (nulu). Pokud ho však zamknout dokáže, vrátí nenulovou hodnotu (tedy jakoukoli číselnou hodnotu jinou než nula).
Zde je příklad se třemi vlákny, která se všechna pokoušejí zamknout objekt mutexu ‘Lock’ pomocí příkazu ‘TryLockMutex()’. Pokud se to některému z nich nepodaří, nebude jen nečinně čekat, dokud mutex nebude odemčen, ale zobrazí v příslušném gadgetu String dobu, po kterou již čeká.
Enumeration
#WINDOW_ROOT
#TEXT_ONE
#TEXT_TWO
#TEXT_THREE
#BUTTON_START
EndEnumeration
Global Lock.l = CreateMutex()
Procedure Update(Gadget.l)
StartTime.l = ElapsedMilliseconds()
Repeat
If TryLockMutex(Lock)
For x.l = 1 To 20
SetGadgetText(Gadget, Str(Gadget) + " has locked the mutex. " + Str(x))
Delay(250)
Next x
UnlockMutex(Lock)
Break
Else
Time.s = "(" + Str((ElapsedMilliseconds() - StartTime) / 1000) + " Secs)"
SetGadgetText(Gadget, Str(Gadget) + " is waiting for mutex. " + Time)
Delay(1)
EndIf
ForEver
SetGadgetText(Gadget, Str(Gadget) + " has finished.")
EndProcedure
#FLAGS = #PB_Window_SystemMenu | #PB_Window_ScreenCentered
If OpenWindow(#WINDOW_ROOT, 0, 0, 290, 130, "'TryLockMutex()' Test", #FLAGS)
If CreateGadgetList(WindowID(#WINDOW_ROOT))
StringGadget(#TEXT_ONE, 10, 10, 270, 20, "")
StringGadget(#TEXT_TWO, 10, 40, 270, 20, "")
StringGadget(#TEXT_THREE, 10, 70, 270, 20, "")
ButtonGadget(#BUTTON_START, 95, 100, 100, 20, "Start")
Repeat
EventID.l = WaitWindowEvent()
Select EventID
Case #PB_Event_Gadget
Select EventGadget()
Case #BUTTON_START
Thread1.l = CreateThread(@Update(), #TEXT_ONE)
Thread2.l = CreateThread(@Update(), #TEXT_TWO)
Thread2.l = CreateThread(@Update(), #TEXT_THREE)
EndSelect
EndSelect
Until EventID = #PB_Event_CloseWindow
EndIf
EndIf
End
Zde vidíte, že jsem uvnitř procedury vlákna použil cyklus ‘Repeat’, který udržuje vlákno aktivní, i když nemůže objekt mutexu zamknout. Jakmile je mutex zamčen, vlákno počítá do dvaceti a průběžně aktualizuje gadget String. Po dokončení počítání se mutex odemkne a klíčovým slovem ‘Break’ se opustí cyklus, čímž vlákno nakonec skončí. Pomocí příkazu ‘If’ se testuje výsledek příkazu ‘TryLockMutex()’, aby se podle stavu mutexu rozhodlo, jaký postup je třeba zvolit.
Shrnutí
Vlákna jsou dalším užitečným nástrojem v programátorově výbavě a jako každý nástroj je třeba je používat správně. Při kompilaci jakéhokoli programu, který používá vlákna, bych doporučoval vždy použít volbu kompilátoru pro bezpečnost vláken a snažit se používat co nejméně vláken.
Doporučil bych vám také důkladně si pročíst celý oddíl ‘Thread’ v nápovědě PureBasicu (Helpfile:Reference Manual->General Libraries->Thread), protože uvádí mnohem více užitečných příkazů pro práci s vlákny, než jsem na těchto stránkách předvedl. Než začnete vlákna používat, musíte si být plně vědomi jejich možností i omezení.
Dynamicky linkované knihovny
Dynamicky linkované knihovny, obvykle zkracované jen na „DLL“, jsou implementací sdílené knihovny kódu od firmy Microsoft pro operační systém Microsoft Windows, a proto je lze používat pouze v operačních systémech od Microsoftu. DLL umožňují programátorům zkompilovat kód do sdílené knihovny, takže kód v ní obsažený pak může využívat mnoho různých počítačových programů. Programy se mohou k DLL dynamicky připojit za běhu a používat příkazy knihovny. Po skončení práce může program knihovnu uvolnit, a tím uvolnit i veškerou paměť spojenou s jejím používáním.
Koncept DLL měl původně zmenšit velikost programů a jejich nároky na paměť tím, že knihovny budou uloženy na pevném disku a načtou se a použijí teprve tehdy, když jsou potřeba. Skutečnost je však taková (a v operačních systémech Microsoft Windows se to projevuje obzvlášť výrazně), že různé programy kvůli kompatibilitě potřebují mnoho různých verzí téže DLL, takže někdy je zapotřebí mnoho kopií stejné DLL (byť v různých verzích). Pro tento problém se vžilo označení „DLL Hell“ (peklo DLL), které vystihuje, jaké potíže může způsobit.
Ponecháme-li stranou problémy operačního systému, mohou být DLL velmi užitečné pro rozdělení programu na samostatné moduly. Pokud usoudíte, že nějaký kód, který napíšete, se bude hodit i v budoucích programech, můžete ho zkompilovat do DLL a ta pak bude k dispozici každému programu, který ji bude chtít použít.
PureBasic používání DLL usnadňuje: poskytuje vestavěnou knihovnu příkazů (Helpfile:Reference Manual->General Libraries->Library) pro načítání a používání DLL a kompilátor PureBasicu navíc nabízí možnost zkompilovat váš kód do DLL. PureBasic je tak ideální volbou pro používání i vytváření DLL.
Vytvoření DLL
Při vytváření vlastních DLL musíte samozřejmě dodržet několik věcí, ale nebojte se, nejsou nijak bolestivé. První věc, kterou je třeba mít na paměti při psaní kódu určeného pro DLL, je, že téměř veškerý kód musí být napsán uvnitř procedur. Je to proto, že když program vaši DLL načte, spouští kód v ní obsažený voláním zkompilovaných názvů procedur. Otevřením knihovny se DLL nespustí automaticky jako program; místo toho z ní musíte volat procedury. Co tedy myslím tím, že téměř veškerý kód musí být napsán tímto způsobem? Inu, definice proměnných a struktur nemusí být v DLL zapsány uvnitř definic procedur, ale jsou to jediné věci, které tam být nemusí.
Při psaní kódu pro DLL existují čtyři speciální rezervované názvy procedur, které Windows po načtení DLL volají automaticky. Tyto čtyři procedury se definují stejně jako kterákoli jiná procedura DLL, ale pokud jsou správně pojmenovány, Windows každou z nich zavolají, jakmile v souvislosti s DLL nastane určitá situace. Já osobně je definuji ve všech DLL, které píšu, i když je nepoužívám. Díky tomu, kdybych se někdy potřeboval k vývoji dané DLL vrátit, jsou vždy připravené k použití. Zde je seznam čtyř rezervovaných názvů procedur a situací, které automaticky spouštějí jejich provedení:
‘AttachProcess(Instance.l)’ Tato procedura se volá jednou, když program tuto DLL načte. Je to jediné místo ve vašem kódu, kde můžete definovat pole a spojové seznamy. Já ji používám i k definici proměnných a struktur, takže mám všechno na jednom místě a mimo procedury nemám nic. Jediným omezením této procedury je, že do ní nesmíte psát inicializační rutiny DirectX.
‘DetachProcess(Instance.l)’ Tato procedura se volá, když program tuto DLL zavírá. Sem by měl patřit veškerý úklidový kód, například uvolnění všech prostředků, které tato DLL používala.
‘AttachThread(Instance.l)’ Tato procedura se volá pokaždé, když se v programu, který tuto DLL načetl, vytvoří vlákno.
‘DetachThread(Instance.l)’ Tato procedura se volá pokaždé, když se v programu, který tuto DLL načetl, ukončí vlákno.
Jak je ze seznamu vidět, nejsou nijak složité na pochopení a mají jednoduché názvy. Chcete-li tyto automaticky volané procedury ve své DLL používat, stačí definovat procedury s uvedenými názvy. Parametr ‘Instance’, který všechny tyto procedury mají, je handle instance (někdy nazývaný handle modulu). Ten se může hodit při pokročilejším programování. Pokud tyto procedury používáte, musí být tento parametr vždy definován, i když ho ve svém kódu použít nehodláte.
Teď tedy víte, jak by měl být kód DLL napsán (všechno musí být uvnitř procedur), a znáte i názvy speciálních rezervovaných procedur, takže vám ukážu příklad jednoduché DLL.
ProcedureDLL AttachProcess(Instance.l)
Global Message.s = "This is my DLL."
EndProcedure
ProcedureDLL ShowAlert()
MessageRequester("Alert", Message)
EndProcedure
Kvůli stručnosti jsem zde nepoužil všechny speciální rezervované procedury; jediná, kterou v tomto příkladu uvádím, je procedura ‘AttachProcess()’, v níž definuji globální řetězcovou proměnnou ‘Message’. Druhá procedura v tomto příkladu se jmenuje ‘ShowAlert()’. Právě tuto proceduru budu volat, až tuto DLL otevřu v jiném programu. Jak vidíte, okno se zprávou definované v proceduře ‘ShowAlert()’ používá řetězec definovaný v proceduře ‘AttachProcess()’.
V tomto příkladu si také všimnete, že jsem k definici těchto procedur použil jiné klíčové slovo: místo ‘Procedure’ jsem použil ‘ProcedureDLL’. To je nezbytné pro definici speciálních rezervovaných procedur i pro každou proceduru, kterou chcete zpřístupnit ostatním programům. K definici procedur můžete i nadále používat standardní klíčové slovo ‘Procedure’, ale takové procedury nebudou zvenčí přístupné ostatním programům, které vaši DLL načtou. Používají se hlavně pro vnitřní výpočty apod.
Jakmile máme DLL napsanou ve výše uvedeném stylu, musíme ji otestovat. Nejprve tedy tento příklad zkompilujeme do DLL. Protože se dynamicky linkované knihovny od běžných programů trochu liší, musíme kompilátoru sdělit, aby místo běžného programu zkompiloval DLL. Pokud používáte příkazovou řádku, uděláte to pomocí volby kompilátoru ‘/DLL’; pokud používáte IDE, můžete ji nastavit vizuálně v dialogovém okně ‘Compiler Options’ (volby kompilátoru) (Menu:Compiler->Compiler Options...->Compiler Options- >Executable Format->Shared DLL). Obr. 52 ukazuje, kde v dialogovém okně ‘Compiler Options’ zvolit ‘Shared DLL’. Jakmile je to nastaveno, můžete v nabídce ‘Compiler’ zvolit ‘Create Executable...’ a DLL skutečně vytvořit. Přitom můžete zadat název a umístění své DLL.

Obr. 52 — Dialogové okno ‘Compiler Options’, jak vypadá v systému Microsoft Windows.
Po zkompilování DLL si všimnete, že kompilátor vytvořil tři soubory. Pokud jsme například naši DLL pojmenovali ‘Demo.dll’, získáte tyto tři soubory:
‘Demo.dll’ ‘Demo.exp’ ‘Demo.lib’
První je samozřejmě zkompilovaná DLL, druhý je exportní soubor a třetí je soubor statické knihovny. PureBasic k použití příkazů v DLL potřebuje pouze soubor DLL, ale ostatní soubory se mohou hodit lidem, kteří tuto DLL používají z jiných jazyků. Pokud budete svou DLL distribuovat, doporučuji šířit všechny tyto soubory společně; pokud ale svou DLL používáte jen s PureBasicem, potřebujete pouze soubor DLL a zbylé dva můžete zahodit.
Použití DLL ve vašem kódu
Použít DLL v programu je snadné: jednoduše otevřete knihovnu a zavoláte proceduru, kterou chcete spustit. V PureBasicu se to řeší příkazy z oddílu ‘Library’ (Helpfile:Reference Manual->General Libraries->Library). Zde je příklad, jak bychom zavolali proceduru ‘ShowAlert()’ z knihovny ‘Demo.dll’. Nezapomeňte umístit ‘Demo.dll’ do stejné složky jako soubor se zdrojovým kódem, který obsahuje tento kód:
#LIBRARY_DEMO = 0
If OpenLibrary(#LIBRARY_DEMO, "Demo.dll")
CallFunction(#LIBRARY_DEMO, "ShowAlert")
CloseLibrary(#LIBRARY_DEMO)
EndIf
Nejprve otevřete knihovnu příkazem ‘OpenLibrary()’. Ten má dva parametry: prvním je PB číslo, které chcete s nově otevřenou knihovnou spojit, a druhým je název DLL, kterou chcete otevřít. K zavolání funkce z otevřené DLL použijete příkaz ‘CallFunction()’, který má dva povinné parametry. Prvním z nich je PB číslo knihovny, z níž chcete proceduru volat, a druhým je název procedury, kterou chcete zavolat. Všimněte si, že při zadávání názvu volané procedury nemusíte uvádět závorky na konci. Za těmito dvěma povinnými parametry může příkaz ‘CallFunction()’ přijmout až dvacet (20) nepovinných parametrů, jimiž lze volané proceduře DLL předat hodnoty jako parametry. To se hodí, pokud volaná procedura DLL vyžaduje předání parametrů. Posledním příkazem, který jsem v tomto příkladu použil, je příkaz ‘CloseLibrary()’, který zavře DLL spojenou s PB číslem předaným v jeho jediném parametru.
Vytváření a používání DLL může být i o něco složitější, ale zde uvedené příklady ukazují celý postup v hrubých rysech. Všechny DLL se skládají z procedur, a abyste je mohli použít, stačí otevřít knihovnu a procedury zavolat (jakoukoli metodou); je to opravdu tak jednoduché.
Při takovém používání DLL můžete být v pokušení DLL otevřít, použít proceduru a knihovnu hned zase zavřít. Pro občasné zavolání jedné či dvou procedur je to v pořádku, ale pokud váš program DLL používá hodně, můžete narazit na problémy s výkonem. Lepší je otevřít DLL připravenou k použití hned při spuštění programu. Pak v programu používejte procedury DLL, kdykoli je potřebujete. A až se program ukončuje, zavřete spolu s ním i knihovnu DLL. Tím zajistíte, že se DLL otevře jen jednou a jen jednou se zavře, čímž odstraníte veškeré problémy s výkonem spojené s těmito souborovými operacemi.
Vracení hodnot z procedur DLL
Při používání procedur obsažených v DLL může být někdy nutné, aby některá z nich vrátila hodnotu. To lze udělat pomocí klíčového slova ‘ProcedureReturn’ stejně jako v jakékoli běžné proceduře. Zde je jednoduchý příklad procedury DLL napsané tak, aby vracela výsledek.
ProcedureDLL.l MultiplyValues(x.l, y.l)
ProcedureReturn x * y
EndProcedure
Jak vidíte, je to docela přímočaré a kromě klíčového slova ‘ProcedureDLL’ to vypadá jako jakákoli jiná běžná procedura. Zkompilujte tento kód do DLL a pak ji zavolejte tímto kódem:
#LIBRARY = 0
If OpenLibrary(#LIBRARY, "Demo.dll")
ReturnValue.l = CallFunction(#LIBRARY, "MultiplyValues", 22, 33)
Debug ReturnValue
CloseLibrary(#LIBRARY)
EndIf
Zde opět používám příkaz ‘CallFunction()’, ale tentokrát využívám dva z nepovinných parametrů k předání hodnot proceduře DLL ‘MultiplyValues’. Předávám hodnoty ‘22’ a ‘33’. Když se tyto dvě hodnoty předají proceduře DLL ‘MultiplyValues’, použije je jako parametry a příslušně je zpracuje. V tomto případě je vynásobí a vrátí výsledek. Vrácená hodnota se pak předá zpět příkazu ‘CallFunction()’, který ji vrátí do našeho programu. K uložení hodnoty vrácené z procedury DLL jsem použil proměnnou typu Long s názvem ‘ReturnValue’, kterou pak vypíšu do okna Debug Output.
Tento způsob vracení hodnot funguje dobře pro většinu vestavěných celočíselných typů (viz Omezení při práci s DLL na další stránce), u řetězců je to však trochu jinak. Především musí být všechny řetězce, které potřebujete z DLL vrátit, definovány jako globální. Je to proto, aby řetězec zůstal zachován i poté, co procedura DLL skončí. Navíc když má procedura DLL vrátit řetězec, vrátí se ve skutečnosti místo něj adresa řetězce v paměti, a to i tehdy, když byl návratový typ v definici procedury deklarován jako řetězec.
Zde je příklad, který to předvádí:
ProcedureDLL AttachProcess(Instance.l)
Global MyString.s = "Lorem ipsum dolor sit amet."
EndProcedure
ProcedureDLL.s GetString()
ProcedureReturn MyString
EndProcedure
V tomto příkladu jsem definoval proceduru ‘GetString()’ tak, aby vracela řetězec, a zajistil jsem, aby proměnná ‘MyString’ byla globální. Zkuste tento kód zkompilovat do DLL a zavolat ho tímto kódem:
#LIBRARY = 0
If OpenLibrary(#LIBRARY, "Demo.dll")
*ReturnValue = CallFunction(#LIBRARY, "GetString")
Debug PeekS(*ReturnValue)
CloseLibrary(#LIBRARY)
EndIf
Uvidíte, že příkaz ‘CallFunction()’ vrací číslo typu Long, takže k jeho uložení musíme použít číselnou proměnnou. Vytvořil jsem proto ukazatel ‘*ReturnValue’, do něhož se uloží vrácená adresa v paměti, a z ní pak příkazem ‘PeekS()’ přečtu řetězec, na který ukazuje.
Omezení při práci s DLL
Jediná skutečná omezení při používání DLL se týkají předávání hodnot do DLL a jejich vracení z DLL. Typy Byte, Word a Long se používají poměrně bezbolestně a podporují je všechny příkazy pro DLL, ale s ostatními typy mohou být trochu starosti. Se zvláštností řetězců, které se vracejí jako adresa v paměti místo samotného řetězce, jste se už setkali. Hodnoty typu Float se zase při vracení z DLL zdají být úplně zkomolené. Typy Quad a Double standardní příkazy ‘Library’ vůbec nepodporují, lze je však zpracovat pomocí prototypů PureBasicu, které jsou ale trochu nad rámec této knihy.
Chcete-li z procedury DLL vrátit hodnotu typu Float, je nejlepší vrátit místo ní její adresu v paměti a vrácenou hodnotu pak přečíst příkazem ‘PeekF()’. Zde je malý příklad, jak úspěšně vrátit hodnotu typu Float z procedury DLL. Nejprve ukázková DLL:
ProcedureDLL AttachProcess(Instance.l)
Global MyFloat.f = 3.1415927
EndProcedure
ProcedureDLL.l GetPi()
ProcedureReturn @MyFloat
EndProcedure
Místo samotné hodnoty typu Float je procedura DLL ‘GetPi()’ definována tak, aby vracela Long. To mi umožňuje vrátit adresu hodnoty Float v paměti. Jakmile je tento kód zkompilován do DLL, mohu ji zavolat tímto kódem:
#LIBRARY = 0
If OpenLibrary(#LIBRARY, "Demo.dll")
*ReturnValue = CallFunction(#LIBRARY, "GetPi")
Debug PeekF(*ReturnValue)
CloseLibrary(#LIBRARY)
EndIf
Vrácená adresa v paměti se přiřadí ukazateli ‘*ReturnValue’ a pak příkazem ‘PeekF()’ přečtu hodnotu Float, na kterou v paměti ukazuje. Tento trik s vracením adres v paměti lze ve skutečnosti obdobně použít i k vracení adres hodnot typu Quad a Double, takže v podstatě lze říci, že PureBasic jejich vracení podporuje.
Předávat hodnoty typu Quad nebo Double procedurám DLL jako parametry pomocí příkazů ‘Library’ však v současnosti prostě nijak nelze.
Jakmile pochopíte, jak předávat proměnné do DLL a jak vracet a používat vrácené hodnoty, je používání DLL docela jednoduché. DLL umožňují znovu použít kód tím, že ho zabalíte do úhledné knihovny. U některých vestavěných typů existuje několik problémů, ty však lze překonat pokročilejšími metodami, obvykle prostě vrácením ukazatele na data, která potřebujete vrátit. Složitější postupy, jako jsou prototypy, jsou bohužel příliš pokročilé na to, abychom se jim v této fázi věnovali, ale pro jistotu si je vždy můžete vyhledat v nápovědě PureBasicu (Helpfile:Reference Manual->Prototype) a seznámit se s nimi. Jen se nelekněte, pokud jim napoprvé neporozumíte. Vyplatí se také přečíst si v nápovědě PureBasicu celý oddíl ‘Library’ (Helpfile:Reference Manual->General Libraries->Library) a poznat všechny příkazy, které lze s DLL používat. Získáte tak dobrou představu o tom, co máte k dispozici, až se rozhodnete vyvinout svou první skutečnou DLL.
Rozhraní Windows API (The Windows Application Programming Interface)
Pravděpodobně se divíte, proč do knihy o multiplatformním programovacím jazyce zařazuji oddíl o programování pro Windows. Zařazuji ho sem proto, že verze PureBasicu pro Windows má docela šikovnou a užitečnou schopnost používat rozhraní Windows API (Windows Application Programming Interface) přímo. Dovolte mi to vysvětlit podrobněji.
Rozhraní Windows Application Programming Interface (obvykle zkracované jen na Win32 API) je součástí všech novějších verzí operačního systému Microsoft Windows a jde o společné rozhraní, které mohou používat všechny počítačové programy. Win32 API je v podstatě knihovna příkazů obsažená v mnoha různých DLL, které se standardně instalují při běžné instalaci Windows. Samotné API je součástí operačního systému a může ho použít jakýkoli počítačový program k provedení téměř čehokoli, co operační systém dokáže, např. k otevírání oken, práci s řetězci, kreslení tvarů atd.
Používání příkazů Win32 API
Chce-li uživatel použít příkaz Win32 API, může jednoduše načíst DLL, která potřebný příkaz obsahuje, a pak ho zavolat a předat mu všechny potřebné parametry. V PureBasicu to lze snadno udělat pomocí příkazů ‘Library’, ale protože PureBasic pro Windows podporuje Win32 API přímo, můžete API používat stejně snadno jako kterýkoli jiný příkaz PureBasicu. Například jiné, těžkopádnější programovací jazyky by k zobrazení jednoduchého okna se zprávou pomocí Win32 API musely postupovat takto:
#LIBRARY = 0
If OpenLibrary(#LIBRARY, "User32.dll")
MB_OK = 0
Caption.s = "Test"
TextString.s = "This is a Win32 API Test"
CallFunction(#LIBRARY, "MessageBoxA", #Null, @TextString, @Caption, MB_OK)
CloseLibrary(#LIBRARY)
EndIf
Jak vidíte, museli byste otevřít DLL, v níž se požadovaný příkaz nachází. Zde je to příkaz ‘MessageBoxA’ umístěný v ‘User32.dll’. Jakmile je DLL otevřená, můžete zavolat potřebný příkaz a předat mu všechny potřebné parametry. To je sice v pořádku, ale trochu složité a zdlouhavé. V PureBasicu můžete tentýž příkaz použít takto:
MessageBox_(#Null, "This is a Win32 API Test", "Test", #MB_OK)
Všimli jste si podtržítka (‘_’) za názvem příkazu? To označuje, že jde o příkaz API, a zajistí jeho automatické zavolání z příslušné DLL. Jistě budete souhlasit, že tento způsob je mnohem jednodušší a rychlejší. Příkaz Win32 API používáme, jako by to byl další nativní příkaz standardního balíku PureBasicu.
Podtržítko lze použít k automatickému zpřístupnění kteréhokoli příkazu z Win32 API. Například ve Win32 API existuje příkaz ‘CharUpper’ pro převod řetězců na velká písmena; tento příkaz můžeme použít, jako by to byl nativní příkaz PureBasicu, tak, že za jeho název (před závorky) přidáme podtržítko, takto:
TextString.s = "this is all lowercase text."
CharUpper_(@TextString)
Debug TextString
Podle dokumentace Win32 API vyžaduje tento příkaz jako parametr adresu řetězce v paměti, a tu jsem mu také předal. Když tento příklad spustíte a podíváte se do okna Debug Output, uvidíte, že textový řetězec byl převeden na velká písmena.
Používání Win32 API tímto způsobem vás zbaví veškeré námahy s vlastním otevíráním potřebných DLL a umožní vám použít příkaz API ve vašem kódu, kdykoli to potřebujete. Pokud používáte verzi PureBasicu pro Windows, můžete ve svém zdrojovém kódu ve skutečnosti libovolně kombinovat běžné příkazy s příkazy API.
Používání konstant a struktur Win32 API
Aby bylo používání příkazů Win32 API ve verzi PureBasicu pro Windows co nejpohodlnější, byly předem definovány i všechny související konstanty a struktury. To znamená, že kdykoli budete potřebovat konstantu nebo strukturu pro použití s příkazem Win32 API, jsou již interně definovány a připraveny k okamžitému použití.
Můžete to vidět ve verzi příkladu s příkazem ‘MessageBox’ pro PureBasic na předchozí stránce, kde jsem použil konstantu ‘#MB_OK’, aniž bych ji definoval. Je to proto, že konstanta Win32 API ‘MB_OK’ už byla interně definována. Chcete-li v PureBasicu použít jakoukoli konstantu Win32 API, stačí na začátek jejího názvu přidat znak mřížky (‘#’) a pak by ji mělo být možné použít, jako by byla definována přímo ve vašem zdrojovém kódu.
Konstanta Win32 API: ‘MB_OK’ Verze pro PureBasic: ‘#MB_OK’ (Tu není třeba definovat, protože už byla definována interně.)
Totéž platí pro struktury Win32 API: kdykoli nějakou potřebujete, prostě ji použijete. Není třeba ji definovat. Podívejte se na tento příklad:
DesktopInfo.RECT
DesktopHandle.l = GetDesktopWindow_()
GetClientRect_(DesktopHandle, @DesktopInfo)
DesktopSize.s = "Your current desktop size is: "
DesktopSize + Str(DesktopInfo\right) + " x "
DesktopSize + Str(DesktopInfo\bottom)
Debug DesktopSize
Zde používám strukturu Win32 API s názvem ‘RECT’, aniž bych ji definoval, a poté používám příkazy Win32 API ‘GetDesktopWindow’ a ‘GetClientRect’, jako by to byly nativní příkazy (všimli jste si podtržítek?). Jak je vidět na struktuře ‘RECT’, všechny struktury Win32 API jsou definovány s názvy psanými velkými písmeny. To je standardní forma při programování s Win32 API a zároveň můj preferovaný způsob pojmenování struktur, jak jsem popsal v kapitole 8 (Můj formát kódu).
Tato konvence pojmenování přesně odpovídá způsobu, jakým jsou struktury definovány v referenčních příručkách Win32 API, a zabraňuje zmatkům, když je přijde na jejich použití.
Pokud například dokumentace Win32 API uvádí, že určitý příkaz potřebuje proměnnou definovanou se strukturou ‘RECT’, můžete ve svém zdrojovém kódu PureBasicu prostě použít ‘RECT’ jako strukturu.
Vezměte si tento ukázkový text z dokumentace Win32 API popisující příkaz API ‘BeginPaint’:
The BeginPaint function prepares the specified window for painting and fills a
PAINTSTRUCT structure with information about the painting.
HDC BeginPaint(
HWND hwnd,// handle to window
PAINTSTRUCT lpPaint // pointer to structure for paint information);
Parameters
hwnd
Identifies the window to be repainted.
lpPaint
Pointer to the PAINTSTRUCT structure that will receive painting information.
Return Values
If the function succeeds, the return value is the handle to a display device
context (HDC) for the specified window. If the function fails, the return
value is NULL, indicating that no display device context is available.
Vidíte, že tento příkaz potřebuje jako druhý parametr ukazatel (neboli adresu v paměti) na strukturovanou proměnnou a tato strukturovaná proměnná musí být vytvořena ze struktury ‘PAINTSTRUCT’. Abychom takovou proměnnou vytvořili v PureBasicu, můžeme udělat toto:
PaintVariable.PAINTSTRUCT
A to je vše. Struktura ‘PAINTSTRUCT’ už byla interně definována, takže ji můžeme použít bez definice. Úplný příklad použití tohoto příkazu by ve vašem hlavním kódu mohl vypadat takto:
...
PaintVariable.PAINTSTRUCT
WindowHandle.l = WindowID(#MY_WINDOW)
HDC.l = BeginPaint_(WindowHandle, @PaintVariable)
...
Prohlížení interně definovaných konstant a struktur
Teď už víte, že spousta užitečných dat byla definována interně, ale nemusíte nutně vědět, co přesně bylo definováno. Aby se odstranily veškeré nejasnosti a vy jste mohli vidět, co přesně je definováno, nabízí IDE PureBasicu šikovný prohlížeč, v němž lze všechna tato data vyhledat. Tento nástroj se jmenuje ‘Structure Viewer’ (prohlížeč struktur) a najdete ho v nabídce ‘Tools’ v IDE (Menu:Tools->Structure Viewer). Obr. 53 ukazuje Structure Viewer, jak vypadá v operačním systému Windows, a popisuje mnoho funkcí, díky nimž je to tak užitečný nástroj.
Po otevření Structure Vieweru vás přivítá seznam všech interně definovaných struktur. V tomto seznamu lze vyhledávat a abecedně ho filtrovat pomocí příslušného ovládacího prvku popsaného v diagramu. Ačkoli seznam zpočátku zobrazuje definované struktury, výběrem jiné záložky ho lze přepnout na zobrazení definovaných rozhraní nebo konstant. Rozhraní (interfaces) sice v této knize probírána nebyla, ale seznam konstant vám bude užitečný, protože ukazuje všechny interně definované konstanty a jejich hodnoty. Zobrazují se zde také všechny vestavěné konstanty PureBasicu.
Chcete-li zobrazit samotné definice interně definovaných struktur, stačí poklepat na jejich názvy v seznamu dat. Jakmile to uděláte, zaktivní se tlačítka ‘Insert Copy’ a ‘Insert’. Tlačítko ‘Insert Copy’ vloží do vašeho zdrojového kódu PureBasicu kopii definice struktury, zatímco tlačítko ‘Insert’ vloží kód, který strukturu skutečně použije a definuje její pole. Otevřete si nový zdrojový soubor PureBasicu a trochu si pohrajte, abyste si zvykli, jak to funguje.

Obr. 53 — Dialogové okno ‘Structure Viewer’, jak vypadá v systému Microsoft Windows.
Dokumentace k Win32 API
Při používání Win32 API budete potřebovat dobrou referenční dokumentaci, abyste věděli, jaké příkazy máte k dispozici a jak je používat. Prvním místem, kam se obrátit, by byla pravděpodobně internetová síť Microsoft Developers Network (www.msdn.com), ta však může být pro nové uživatele matoucí, protože web je obrovský a obsahuje informace o všech myslitelných aspektech programování pro Windows, takže orientace v něm může být utrpením. Jako nejlepší řešení (pro mě osobně) se mi osvědčilo nahlížet do menší, cíleněji zaměřené reference a v MSDN hledat až tehdy, když potřebuji o určitém příkazu nebo syntaxi více informací.
Menší reference, kterou používám, je soubor ‘Win32.hlp’, soubor nápovědy Windows obsahující referenci příkazů Win32 API. Tento soubor nápovědy není součástí běžného balíku PureBasicu, takže si ho budete muset sami vypátrat a nainstalovat; abych vám pomohl, uvedl jsem internetový odkaz v příloze A (Užitečné internetové odkazy). Jakmile soubor ‘Win32.hlp’ máte, nainstalujte ho ručně do složky ‘Help’, která se nachází ve složce PureBasicu. Pokud ve složce PureBasicu složka ‘Help’ není, jednoduše ji vytvořte a soubor(y) ‘Win32.hlp’ do ní umístěte. Někdy soubor nápovědy doprovázejí další soubory, například ‘Win32.cnt’ a ‘Win32.kwf’; v takovém případě je nutné nainstalovat všechny společně. Poté můžete využívat integraci tohoto souboru s IDE.
Je-li tento soubor správně nainstalován, můžete v IDE vybrat kterýkoli příkaz Win32 API tak, že do něj umístíte kurzor a stisknete ‘F1’. Místo obvyklé nápovědy PureBasicu se nyní otevře soubor ‘Win32.hlp’ na stránce věnované zvýrazněnému příkazu Win32 API. Toto chování nijak neomezuje funkci standardní nápovědy PureBasicu; pouze se otevře jiný soubor nápovědy podle toho, jaký příkaz je v IDE zvýrazněn.
Vyzkoušejte si to sami: napište tento kód z jednoho z předchozích příkladů, umístěte blikající textový kurzor do příkazu ‘GetClientRect’ a stiskněte ‘F1’.
DesktopInfo.RECT
DesktopHandle.l = GetDesktopWindow_()
GetClientRect_(DesktopHandle, @DesktopInfo)
DesktopSize.s = "Your current desktop size is: "
DesktopSize + Str(DesktopInfo\right) + " x "
DesktopSize + Str(DesktopInfo\bottom)
Debug DesktopSize
Nyní byste měli vidět otevřený soubor ‘Win32.hlp’ se stránkou o příkazu ‘GetClientRect’. Nezapomeňte, že ‘Win32.hlp’ je standardní soubor nápovědy Windows, a proto se v něm snadno orientuje a lze v něm plně vyhledávat; pokud plánujete hodně programovat s Win32 API, možná se vyplatí si ho někdy přečíst.
Nevýhody používání Win32 API v PureBasicu
Jednou z největších nevýhod používání Win32 API v programu v PureBasicu je, že tyto příkazy lze používat pouze v operačním systému Microsoft Windows. To znamená, že jakýkoli program, který s těmito příkazy napíšete, půjde zkompilovat pouze v PureBasicu pro Windows.
Další velkou nevýhodou je, že Win32 API bylo původně navrženo pro programovací jazyky C a C++, a proto obsahuje odkazy na mnoho pokročilých datových typů, které v PureBasicu prostě neexistují. Ve většině případů však můžete místo typu z C/C++ použít náhradní typ PureBasicu. Obr. 54 ukazuje přehled toho, jaké typy PureBasicu lze použít místo uvedených typů C/C++. Pokud se například v popisu příkazu Win32 API dočtete, že určitý příkaz potřebuje proměnnou typu ‘DWORD32’, z obr. 54 vyčtete, že místo něj můžete použít typ Long z PureBasicu.

Obr. 54: Náhradní typy PureBasicu za typy Win32 API — Typy označené ‘†’ je nutné po volání příkazu správně přečíst. Je to proto, že tyto typy mohou být bez znaménka, respektive se znaménkem, tedy opačně než typ PureBasicu, který je nahrazuje.
Všimnete si, že některé typy uvedené na obr. 54 jsou označeny symbolem ‘†’. To značí, že tyto typy přesně neodpovídají svým protějškům v PureBasicu. Důvodem tohoto nesouladu je, že všechny označené typy Win32 API jsou bez znaménka (kromě ‘TBYTE’), zatímco náhradní typy PureBasicu jsou všechny se znaménkem. Proto mohou u některých typů nastat problémy s přetékáním číselných hodnot. Výjimkou je typ API ‘TBYTE’, který je se znaménkem, zatímco typ Character z PureBasicu, který ho nahrazuje, je bez znaménka. Ve vašem programu by to nakonec nemělo způsobovat velké problémy, protože s trochou kódu lze hodnoty se znaménkem snadno převést na hodnoty bez znaménka a naopak. Zde je několik procedur, které můžete použít k převodu všech těchto problematických typů:
;Returns the correct unsigned value from a UCHAR.
Procedure.w UCHAR(UCHAR.b)
ProcedureReturn UCHAR & $FF
EndProcedure
;Returns the correct signed value from a TBYTE.
CompilerIf #PB_Compiler_Unicode
Procedure.w TBYTE(TBYTE.c)
CompilerElse
Procedure.b TBYTE(TBYTE.c)
CompilerEndIf
ProcedureReturn TBYTE
EndProcedure
;Returns the correct unsigned value from a USHORT.
Procedure.l USHORT(USHORT.w)
ProcedureReturn USHORT & $FFFF
EndProcedure
;Returns the correct unsigned value from a UINT.
Procedure.q UINT(UINT.l)
ProcedureReturn UINT & $FFFFFFFF
EndProcedure
;Returns the correct unsigned value from a UINT32.
Procedure.q UINT32(UINT32.l)
ProcedureReturn UINT32 & $FFFFFFFF
EndProcedure
;Returns the correct unsigned value from a ULONG.
Procedure.q ULONG(ULONG.l)
ProcedureReturn ULONG & $FFFFFFFF
EndProcedure
;Returns the correct unsigned value from a ULONG32.
Procedure.q ULONG32(ULONG32.l)
ProcedureReturn ULONG32 & $FFFFFFFF
EndProcedure
Pokud jste například k uložení hodnoty bez znaménka typu ‘UCHAR’ použili Byte z PureBasicu (který je se znaménkem), můžete tuto hodnotu bez znaménka správně přečíst jen pomocí procedury ‘UCHAR()’, takto:
MyUCHAR.b = 255 ; This represents '-1' signed and '255' unsigned.
Debug MyUCHAR ; This echoes the signed value of '-1'.
UnsignedValue.w = UCHAR(MyUCHAR)
Debug UnsignedValue ; This echoes the unsigned value of '255'.
Jedinou nevýhodou těchto procedur je, že hodnota, kterou vracejí (i když je naprosto správná), zabírá dvojnásobek paměti oproti typu, který jste předali jako parametr. Stačí se podívat na proceduru ‘UCHAR()’ v posledním příkladu. Ta přijímá jako parametr Byte obsahující ‘UCHAR’, který chcete přečíst, a vrací Word se správnou hodnotou bez znaménka. To je dvojnásobek velikosti původního Byte. Je to tak proto, že téměř všechny typy PureBasicu jsou se znaménkem, takže musíme použít dostatečně velký typ, aby hodnotu bez znaménka správně vyjádřil a nedošlo k přetečení.
Přiřazování hodnot bez znaménka typům se znaménkem je naopak snadné. Jak ukazuje poslední příklad, hodnotu bez znaménka můžete přiřadit typu se znaménkem, ale ta se vždy uloží jako hodnota se znaménkem. Tento řádek kódu:
MyUCHAR.b = 255
Debug MyUCHAR
by tedy ve skutečnosti uložil hodnotu ‘-1’. V PureBasicu je to tak implementováno proto, aby se usnadnily podobné problémy s převody u Win32 API.
Krátká poznámka k typům ukazatelů na řetězce ve Win32 API
Při používání typů ukazatelů na řetězce ve Win32 API je užitečné vědět, jak správně číst z paměti a zapisovat do ní pro každý z různých typů řetězců, na které ukazují. Například ukazatel typu ‘LPCSTR’ by Win32 API použilo k odkazu na řetězec ASCII s jedním bajtem na znak, zatímco ukazatel typu ‘LPCWSTR’ by ukazoval na řetězec Unicode se dvěma bajty na znak. Přestože všechny ukazatele na řetězce používají k reprezentaci samotného ukazatele a uchování adresy v paměti typ Long z PureBasicu, musíte každý z nich číst z paměti a zapisovat do ní jiným režimem příkazů ‘PeekS()’ a ‘PokeS()’, aby se správně dodrželo kódování znaků každého typu řetězce.
Zde jsou typy ukazatelů na řetězce ve Win32 API a, což je důležitější, způsob, jak správně číst a zapisovat každý typ řetězce z místa v paměti, na které ukazují, a do něj:
‘LPCSTR’ Řetězec s jedním bajtem na znak (ASCII), i když je program zkompilován v režimu Unicode.
PeekS(StringPointer.l, StringLength, #PB_Ascii)
PokeS(StringPointer.l, Text.s, StringLength, #PB_Ascii)
‘LPCWSTR’ ‘PCWSTR’ ‘PWSTR’ ‘LPOLESTR’ Řetězec se dvěma bajty na znak (Unicode), i když program není zkompilován v režimu Unicode.
PeekS(StringPointer.l, StringLength, #PB_Unicode)
PokeS(StringPointer.l, Text.s, StringLength, #PB_Unicode)
‘LPCTSTR’ ‘LPTSTR’ ‘LPSTR’ ‘PCTSTR’ ‘PTSTR’ Přesně totéž jako standardní řetězec PureBasicu, tedy jeden bajt na znak, pokud program není zkompilován v režimu Unicode, a dva bajty na znak, pokud v režimu Unicode zkompilován je.
PeekS(StringPointer.l, StringLength)
PokeS(StringPointer.l, Text.s, StringLength)
Brána do širšího světa
Doufám, že vás tento krátký úvod do Win32 API povzbudí, abyste si o něm přečetli více a třeba ho i využili při programování pro Windows. Při používání PureBasicu a psaní softwaru pro Microsoft Windows můžete občas potřebovat nějaký příkaz API, který poskytne další funkce, jež v PureBasicu momentálně nejsou přímo k dispozici.
VPřílohy
Tato část obsahuje přílohy knihy. Doplňkový materiál nabízí řadu užitečných informací, mimo jiné užitečné internetové odkazy, několik stránek užitečných tabulek a úplný slovníček pojmů z informatiky.
Tyto závěrečné stránky vám poslouží jako rychlá příručka k některým z nejužitečnějších informací, ke kterým se budete chtít znovu a znovu vracet.
AUžitečné internetové odkazy
Na následujících stránkách najdete řadu užitečných internetových adres, na které se budete chtít podívat, až začnete s PureBasicem pracovat. Tyto weby obsahují spoustu užitečných informací, například ukázky kódu, nástroje a pomůcky, informace o tom, kde získat technickou podporu, a místa, kde můžete klást otázky.
PureBasic Beginners
http://www.pb-beginners.co.uk
Web, který patří k této knize. Většinu kódu, obrázků a zvuků použitých v příkladech v této knize si odtud můžete stáhnout spolu s dalšími užitečnými nástroji a pomůckami, včetně těžko k sehnání souboru nápovědy ‘Win32.hlp’.
Oficiální web PureBasicu
http://www.purebasic.com
Oficiální web PureBasicu. Zde si kompletní balík PureBasicu zakoupíte a stáhnete. Najdete tu také nejnovější zprávy o vývoji PureBasicu a přes nabídku webu se dostanete i k podpoře.
Oficiální fóra PureBasicu
http://forums.purebasic.com
Doufám, že se toto místo stane jednou z vašich prvních zastávek při práci s PureBasicem. Stačí se na fóru zaregistrovat a můžete se ptát, kolikrát chcete. Toto online fórum bedlivě sleduje tým PureBasicu, jehož členové se pravidelně zapojují do diskusí a odpovídají na otázky týkající se PureBasicu. Množství informací o PureBasicu, které jsou na tomto webu uloženy, rozhodně nepodceňujte. Máte přístup nejen ke sdíleným znalostem stovek programátorů v PureBasicu, kteří jsou ochotni vám pomoci, ale každý příspěvek je navíc archivován a lze v něm plně vyhledávat. Doslova tak máte na dosah ruky znalosti o PureBasicu nashromážděné za celé roky, které popisují téměř každou programátorskou úlohu, na kterou můžete narazit.
PureArea
http://www.purearea.net
Tento web obsahuje spoustu materiálů souvisejících s PureBasicem, mimo jiné tisíce příkladů kódu v PureBasicu ve stažitelném archivu kódu (Code Archive), stažitelné uživatelské knihovny třetích stran a odkazy na stovky freewarových a sharewarových programů napsaných v PureBasicu. Je zde také online referenční příručka PureBasicu.
The PureBasic Visual Designer
http://www.purebasic.be
Na tomto webu najdete novinky a aktualizované sestavení nového oficiálního Visual Designeru (vizuálního návrháře, VD) PureBasicu. Je tu vše, co souvisí s vývojem Visual Designeru.
PureProject
http://pureproject.reelmedia.org
Další ukázky kódu v PureBasicu včetně her a aplikací a další stažitelné uživatelské knihovny třetích stran. Nechybí ani oddíl věnovaný Windows API.
PureVision
http://purevision.reelmedia.org
Komerční náhrada standardního Visual Designeru PureBasicu od třetí strany. Tento profesionální vizuální návrhář navíc plně podporuje skinování grafického uživatelského rozhraní.
Dokumentace Microsoft Windows API
http://msdn.microsoft.com/library
Web společnosti Microsoft věnovaný Windows API, který podrobně popisuje celé rozhraní Windows Application Programming Interface. K rychlému vyhledání informací použijte vyhledávací pole na stránce.
API-Guide
http://www.allapi.net/agnet/apiguide.shtml
Program s názvem ‘API-Guide’, který vám umožní procházet příkazy dostupné ve Win32 API. Uvádí podrobnosti o všech příkazech a parametrech a téměř u všech příkazů i příklady. Poznámka: Příklady jsou napsány pro VisualBasic, ale do PureBasicu je lze snadno převést.
The OGRE Engine
http://www.ogre3d.org/
Web 3D enginu OGRE, který PureBasic používá k zobrazování 3D grafiky.
Housemarque Audio System
http://www.s2.org/hmqaudio/
Toto je zvukový systém, který PureBasic používá k přehrávání modulů. Abyste ve svých programech mohli přehrávat moduly, musíte si stáhnout soubor ‘midas11.dll’. Tento soubor je součástí balíku Housemarque „Standard distribution package“. Více informací najdete v kapitole 12 (Modulové soubory).
BUžitečné tabulky
Tato příloha obsahuje řadu užitečných tabulek, z nichž některé se již objevily dříve v této knize. Některé jsou zde otištěny znovu pro vaše pohodlí, abyste je v případě potřeby snáze našli.
| Priorita* | Operátory |
|---|---|
1 |
( ) |
2 |
~ |
3 |
<< >> % ! |
4 |
\| & |
5 |
* / |
6 |
+ - |
7 |
> >= < <= = <> |
8 |
And Or Not XOr |
Obr. 13: Priorita operátorů — * Operátory v horní části seznamu se vyhodnocují jako první.
| Operátor | Popis |
|---|---|
| = | Rovná se. Tento operátor lze použít dvěma způsoby. První slouží k přiřazení hodnoty výrazu na pravé straně (RHS) proměnné na levé straně (LHS). Druhý způsob nastává, když se výsledek operátoru použije ve výrazu k otestování, zda jsou hodnoty výrazů na levé a pravé straně stejné (pokud jsou stejné, vrátí operátor rovnosti pravdu (true), jinak vrátí nepravdu (false)). |
| + | Plus. Výsledkem je hodnota výrazu na pravé straně přičtená k hodnotě výrazu na levé straně. Pokud se výsledek tohoto operátoru nepoužije a na levé straně je proměnná, přičte se hodnota výrazu na pravé straně přímo k této proměnné. |
| - | Minus. Odečte hodnotu výrazu na pravé straně od hodnoty výrazu na levé straně. Pokud na levé straně žádný výraz není, dává tento operátor zápornou hodnotu výrazu na pravé straně. Pokud se výsledek tohoto operátoru nepoužije a na levé straně je proměnná, odečte se hodnota výrazu na pravé straně přímo od této proměnné. (Tento operátor nelze používat s řetězci.) |
| * | Násobení. Vynásobí hodnotu výrazu na levé straně hodnotou výrazu na pravé straně. Pokud se výsledek tohoto operátoru nepoužije a na levé straně je proměnná, vynásobí se hodnota proměnné přímo hodnotou výrazu na pravé straně. (Tento operátor nelze používat s řetězci.) |
| / | Dělení. Vydělí hodnotu výrazu na levé straně hodnotou výrazu na pravé straně. Pokud se výsledek tohoto operátoru nepoužije a na levé straně je proměnná, vydělí se hodnota proměnné přímo hodnotou výrazu na pravé straně. (Tento operátor nelze používat s řetězci.) |
| & | Bitové AND. Při používání tohoto operátoru byste měli znát dvojková čísla. Výsledkem tohoto operátoru je hodnota výrazu na levé straně spojená bit po bitu operací AND s hodnotou výrazu na pravé straně. Pokud se navíc výsledek operátoru nepoužije a na levé straně je proměnná, uloží se výsledek přímo do této proměnné. (Tento operátor nelze používat s řetězci.) |
| | | Bitové OR. Při používání tohoto operátoru byste měli znát dvojková čísla. Výsledkem tohoto operátoru je hodnota výrazu na levé straně spojená bit po bitu operací OR s hodnotou výrazu na pravé straně. Pokud se navíc výsledek operátoru nepoužije a na levé straně je proměnná, uloží se výsledek přímo do této proměnné. (Tento operátor nelze používat s řetězci.) |
| ! | Bitové XOR. Při používání tohoto operátoru byste měli znát dvojková čísla. Výsledkem tohoto operátoru je hodnota výrazu na levé straně spojená bit po bitu operací XOR s hodnotou výrazu na pravé straně. Pokud se navíc výsledek operátoru nepoužije a na levé straně je proměnná, uloží se výsledek přímo do této proměnné. (Tento operátor nelze používat s řetězci.) |
| ~ | Bitové NOT. Při používání tohoto operátoru byste měli znát dvojková čísla. Výsledkem tohoto operátoru je hodnota výrazu na pravé straně po provedení operace NOT, tj. výsledek bude mít oproti hodnotě výrazu všechny bity invertované. (Tento operátor nelze používat s řetězci.) |
| < | Menší než. Slouží k porovnání hodnot výrazů na levé a pravé straně. Je-li hodnota výrazu na levé straně menší než hodnota výrazu na pravé straně, dává tento operátor výsledek pravda (true), jinak je výsledkem nepravda (false). |
| > | Větší než. Slouží k porovnání hodnot výrazů na levé a pravé straně. Je-li hodnota výrazu na levé straně větší než hodnota výrazu na pravé straně, dává tento operátor výsledek pravda, jinak je výsledkem nepravda. |
| <= | Menší nebo rovno. Slouží k porovnání hodnot výrazů na levé a pravé straně. Je-li hodnota výrazu na levé straně menší nebo rovna hodnotě výrazu na pravé straně, dává tento operátor výsledek pravda, jinak je výsledkem nepravda. |
| >= | Větší nebo rovno. Slouží k porovnání hodnot výrazů na levé a pravé straně. Je-li hodnota výrazu na levé straně větší nebo rovna hodnotě výrazu na pravé straně, dává tento operátor výsledek pravda, jinak je výsledkem nepravda. |
| <> | Nerovná se. Slouží k porovnání hodnot výrazů na levé a pravé straně. Je-li hodnota výrazu na levé straně rovna hodnotě výrazu na pravé straně, dává tento operátor výsledek nepravda, jinak je výsledkem pravda. |
| And | Logické AND. Slouží k porovnání hodnot výrazů na levé a pravé straně. Jsou-li hodnoty výrazů na levé i pravé straně obě pravdivé, je výsledkem pravda, jinak je výsledkem nepravda. |
| Or | Logické OR. Slouží k porovnání hodnot výrazů na levé a pravé straně. Je-li hodnota výrazu na levé nebo na pravé straně pravdivá, je výsledkem pravda, jinak je výsledkem nepravda. |
| Not | Logické NOT. Slouží k logické negaci booleovské hodnoty. Jinými slovy: vrací-li výraz hodnotu pravda, lze ji pomocí operátoru Not obrátit na nepravdu. A naopak, vrací-li výraz na pravé straně tohoto operátoru nepravdu, vrátí Not pravdu. |
| XOr | Logické XOR. Slouží k porovnání hodnot výrazů na levé a pravé straně. Je-li jako pravdivý vyhodnocen pouze jeden z výrazů na levé či pravé straně, je výsledkem pravda. Jsou-li oba výrazy pravdivé, nebo oba nepravdivé, vrátí operátor XOr nepravdu. |
| << | Aritmetický posun doleva. Posune každý bit hodnoty výrazu na levé straně doleva o počet míst daný hodnotou výrazu na pravé straně. Pokud se navíc výsledek tohoto operátoru nepoužije a na levé straně je proměnná, posune se hodnota této proměnné o počet míst uvedený na pravé straně. Při používání tohoto operátoru se vám nejspíš bude hodit znalost dvojkových čísel, i když ho můžete používat i tak, jako by každé místo posunu znamenalo násobení dalším činitelem 2. |
| >> | Aritmetický posun doprava. Posune každý bit hodnoty výrazu na levé straně doprava o počet míst daný hodnotou výrazu na pravé straně. Pokud se navíc výsledek tohoto operátoru nepoužije a na levé straně je proměnná, posune se hodnota této proměnné o počet míst uvedený na pravé straně. Při používání tohoto operátoru se vám nejspíš bude hodit znalost dvojkových čísel, i když ho můžete používat i tak, jako by každé místo posunu znamenalo dělení dalším činitelem 2. |
| % | Modulo. Vrací zbytek po celočíselném dělení levé strany pravou stranou. |
| ( ) | Závorky. Pomocí párů závorek můžete vynutit, aby se část výrazu vyhodnotila jako první nebo v určitém pořadí. Výrazy v závorkách se vyhodnocují dříve než kterákoli jiná část aktuálního výrazu. U vnořených závorek se jako první vyhodnotí nejvnitřnější pár a poté postupně další směrem ven. |
Obr. 15: Stručný přehled operátorů — RHS = pravá strana, LHS = levá strana
| Typ | Přípona | Využití paměti (RAM) | Číselný rozsah |
|---|---|---|---|
Byte |
.b |
1 bajt (8 bitů) |
-128 až 127 |
Char (Ascii) |
.c |
1 bajt (8 bitů) |
0 až 255 |
Char (Unicode) |
.c |
2 bajty (16 bitů) |
0 až 65535 |
Word |
.w |
2 bajty (16 bitů) |
-32768 až 32767 |
Long |
.l |
4 bajty (32 bitů) |
-2147483648 až 2147483647 |
Quad |
.q |
8 bajtů (64 bitů) |
-9223372036854775808 až 9223372036854775807 |
Float |
.f |
4 bajty (32 bitů) |
Neomezený* |
Double |
.d |
8 bajtů (64 bitů) |
Neomezený* |
Obr. 2: Číselné typy PureBasicu — * Podrobně to bude vysvětleno v kapitole 13 (Podrobněji o číselných datových typech).
| Typ | Přípona | Využití paměti (RAM) | Maximální počet znaků |
|---|---|---|---|
String |
.s |
4 bajty (32 bitů) |
Neomezený |
String |
$ |
4 bajty (32 bitů) |
Neomezený |
Řetězec pevné délky |
.s{ length } |
4 bajty (32 bitů) |
Definovaný uživatelem* |
Řetězec pevné délky |
${ length } |
4 bajty (32 bitů) |
Definovaný uživatelem* |
Obr. 3: Řetězcové typy PureBasicu — * Parametr ‘length’ určuje maximální délku řetězce.

Obr. 54: Náhradní typy PureBasicu za typy Win32 API — Typy označené ‘†’ je nutné po volání příkazu správně přečíst. Důvodem je, že tyto typy mohou být bez znaménka či se znaménkem, tedy opačně než typ PureBasicu, který používají.

Obr. 55: Vestavěné gadgety PureBasicu — (ukázkové obrázky z Microsoft Windows)

Obr. 55

Obr. 55

Obr. 55

Obr. 56: Tabulka znaků a jejich odpovídajících hodnot v kódu Ascii, šestnáctkové a dvojkové soustavě

Obr. 56
CSlovníček pojmů
Tento slovníček je seznamem slov a pojmů, se kterými se můžete při programování setkat. V této příloze jsem se snažil popsat význam těchto slov a pojmů co nejúplněji a zároveň co nejstručněji, abych vám trochu usnadnil život, až narazíte na něco, co neznáte.
3D Engine (3D engine)
3D engine je prostředí výslovně naprogramované tak, aby poskytovalo konstrukci, pomocí níž lze realizovat 3D grafiku. Lze ho vysvětlit jako abstraktní vrstvu, která umožňuje grafikům či vývojářům rychle sestavit 3D grafiku zjednodušenými metodami, místo aby všechny nízkoúrovňové záležitosti programovali sami. 3D engine může například poskytovat příkaz 'LoadModel()', který načte 3D model a zobrazí ho, a uživateli tak usnadní práci. 3D enginy bývají někdy vybaveny i dalšími užitečnými funkcemi, jako je detekce kolizí a fyzikální modelování.
Absolute (absolutní)
Může se vztahovat k hodnotě nebo k cestě. Absolutní hodnota je hodnota, která stojí sama o sobě a není relativní vůči jiné. Absolutní cesta je taková, která určuje cestu v celém jejím rozsahu. Absolutními cestami jsou například všechny internetové adresy, jak je vidíte v adresním řádku internetového prohlížeče. Absolutní cesty se používají proto, aby nevznikla žádná nejasnost ohledně toho, kde se určitý soubor či složka nachází.
ActiveX
Specifikace společnosti Microsoft pro opakovaně použitelné softwarové komponenty. ActiveX vychází z COM, který určuje, jak spolu komponenty komunikují a spolupracují. Ovládací prvky ActiveX mohou aplikaci rozšířit o další funkce tím, že do jejího rozhraní začlení další hotové moduly. Moduly lze zaměňovat, a přesto se jeví jako součást původního softwaru. Na internetu lze ovládací prvky ActiveX vkládat do webových stránek a prohlížeč podporující ActiveX si je může stáhnout. Ovládací prvky ActiveX mohou webovým stránkám dodat funkce, díky nimž vykonávají úlohy jako jakýkoli jiný program spuštěný ze serveru. Ovládací prvky ActiveX mohou mít plný přístup k systému! Ve většině případů je tento přístup zcela legitimní, historie však ukázala, že ho zneužívaly škodlivé aplikace ActiveX.
Algorithm (algoritmus)
Přesně určený postup krok za krokem, který vede k řešení dané úlohy.
Alpha Channel (alfa kanál)
Část dat každého pixelu obrázku, která je vyhrazena pro informaci o průhlednosti. Některé 32bitové obrazové formáty obsahují čtyři kanály: tři osmibitové kanály pro červenou, zelenou a modrou a jeden osmibitový alfa kanál. Alfa kanál je maska. Určuje, jak velká část barvy pixelu se má smíchat s jiným pixelem, když se oba překrývají, jeden nad druhým.
Anti-virus Software (antivirový software)
Software, který prohledává paměť a disky počítače a hledá viry. Pokud nějaký virus najde, aplikace o tom informuje uživatele a může soubory, adresáře či disky zasažené škodlivým kódem vyčistit, odstranit nebo umístit do karantény.
API (Application Programming Interface, rozhraní pro programování aplikací)
Sada funkcí, kterou aplikace používá k vyžádání a provádění služeb nižší úrovně, jež zajišťuje operační systém počítače nebo knihovna příkazů programu třetí strany. Zjednodušeně řečeno je API jakékoli rozhraní, které umožňuje jednomu programu využívat prostředky poskytované jiným programem. Microsoft Win32 API je pravděpodobně nejznámější ze všech různých API.
Applet (applet)
Jakákoli miniaturní aplikace přenášená přes internet, zejména jako rozšíření webové stránky.
Array (pole)
Jednoduchá datová struktura pro uchovávání stejně velkých datových prvků, obvykle stejného datového typu. K jednotlivým prvkům se přistupuje pomocí indexu, který tvoří souvislá řada celých čísel. Některá pole jsou vícerozměrná, což znamená, že jsou indexována pevným počtem celých čísel. Obecně jsou nejběžnější jednorozměrná a dvourozměrná pole.
ASCII (American Standard Code For Information Interchange, americký standardní kód pro výměnu informací)
Schéma kódování znaků, které přiřazuje číselné hodnoty znakům, jako jsou písmena, číslice, interpunkce a další symboly. ASCII povoluje pouze 7 bitů na znak (celkem tedy 128 znaků). Prvních 32 znaků jsou netisknutelné řídicí znaky (posun o řádek, posun o stránku atd.), které slouží k ovládání hardwarových zařízení. Rozšířené ASCII přidává dalších 128 znaků, které se liší podle počítače, programu a písma. Počítače tyto rozšířené znaky používají pro písmena s diakritikou, grafické znaky nebo jiné speciální symboly.
ASCII Art (ASCII art)
Kresby vytvořené pomocí znaků standardní znakové sady ASCII. Obvykle se používají neproporcionální písma, aby každý znak v kresbě zabíral stejné místo jako kterýkoli jiný.
ASM (Assembly Language, jazyk symbolických adres)
Lidsky čitelný zápis strojového kódu, který používá určitá architektura počítače. Tento strojový kód se stává čitelným tím, že se surové číselné hodnoty nahradí symboly zvanými mnemotechnické zkratky (mnemoniky).
Assembler (assembler)
Počítačový program, který překládá jazyk symbolických adres do objektového kódu.
Attributes (atributy)
Vlastnosti přiřazené všem souborům a adresářům. Mezi atributy patří: Jen pro čtení (Read Only), Archivovat (Archive), Skrytý (Hidden) nebo Systémový (System).
Back Door (zadní vrátka)
Funkce, kterou programátoři často zabudovávají do programů, aby získali zvláštní oprávnění, jež běžní uživatelé programu obvykle nemají. Programátoři zadní vrátka často vytvářejí proto, aby mohli opravovat chyby. Pokud se o zadních vrátkách dozvědí hackeři nebo jiní lidé, může tato funkce představovat bezpečnostní riziko.
Background Task (úloha na pozadí)
Program spouštěný systémem, který obvykle zůstává pro uživatele neviditelný. Systém obvykle přiděluje úlohám na pozadí nižší prioritu využití procesoru než úlohám v popředí. Škodlivý software, např. viry, spyware atd., bývá systémem často spouštěn jako úloha na pozadí, aby si uživatel neuvědomil, že probíhají nežádoucí akce.
Backup (záloha)
Duplicitní kopie dat pořízená pro účely archivace nebo jako ochrana před poškozením či ztrátou originálu.
Batch files (dávkové soubory)
Textové soubory obsahující na každém řádku jeden příkaz MS-DOS. Při spuštění se jednotlivé řádky vykonávají postupně jeden po druhém. Jedním z příkladů je soubor 'AUTOEXEC.BAT' systému Microsoft Windows, který se vykoná při spouštění počítače. Tyto soubory mají příponu '*.bat'.
Binary (dvojková soustava)
Označuje číselnou soustavu o základu dvě. Tato soustava obsahuje pouze dvě číslice, 0 a 1.
BIOS (Basic Input/Output System, základní vstupně-výstupní systém)
Základní operační systém, který určuje sadu programů potřebných k inicializaci a spuštění počítače předtím, než se vyhledá zaváděcí disk operačního systému. BIOS se nachází v oblasti ROM základní desky a obvykle jej lze konfigurovat.
BIT (Binary Digit, dvojková číslice)
Nejmenší jednotka informace, kterou může počítač používat. Bit je reprezentován jako '0' nebo '1'.
Bit Depth (bitová hloubka)
Počet bitů použitých k popisu barvy jednoho pixelu v libovolném digitálním obrázku nebo na displeji počítače se nazývá bitová hloubka. Běžné bitové hloubky jsou 1 bit, 8 bitů, 16 bitů, 24 bitů a 32 bitů.
Boot (zavedení systému)
Spuštění (studený start) nebo restart (teplý start) počítače, aby byl připraven spouštět programy pro uživatele. Při zavádění systému se spouštějí různé programy, které počítač zkontrolují a připraví k použití.
Bug (chyba)
Neúmyslná chyba v programu, která způsobuje akce, jež nezamýšlel uživatel ani autor programu.
Byte (bajt)
Skupina osmi bitů (dvojkových číslic). Také název celého čísla, které lze vyjádřit pomocí těchto osmi bitů.
Cache (mezipaměť)
Oblast paměti, do níž lze dočasně ukládat často používaná data, aby k nim byl rychlý přístup.
CGI (Common Gateway Interface)
Standard pro výměnu informací mezi webovým serverem a počítačovými programy, které jsou vůči němu externí. Externí programy mohou být napsány v jakémkoli programovacím jazyce, který podporuje operační systém, na němž webový server běží. CGI samo o sobě není programovací jazyk.
Checksum (kontrolní součet)
Identifikační číslo vypočtené z vlastností souboru. I sebemenší změna v souboru změní jeho kontrolní součet.
Child (potomek)
Okno (nebo objekt), které vychází z jiného okna (nebo objektu) či je v něm uzavřeno.
Class (třída)
Šablona OOP, z níž lze vytvářet instance, tedy objekty se společnými definicemi, vlastnostmi, metodami, operacemi a chováním.
Client (klient)
Počítačový systém nebo software, který přistupuje ke vzdálené službě poskytované jiným počítačem prostřednictvím nějaké sítě. Webový prohlížeč je klientem webového serveru.
Code (kód)
Slangový výraz pro zdrojový kód.
Coding (kódování)
Slangový výraz pro programování počítačů.
Compile Time (doba kompilace)
Okamžik, kdy kompilátor kompiluje kód napsaný v programovacím jazyce do spustitelné podoby.
Compiler (kompilátor)
Nástroj pro vývoj softwaru, který překládá zdrojové kódy programů ve vyšším programovacím jazyce do instrukcí strojového kódu (objektového kódu), jimž určitá architektura počítače rozumí a dokáže je vykonat.
Constant (konstanta)
Pojmenovaná položka, která si po celou dobu běhu programu uchovává stálou hodnotu. Konstanty lze v kódu používat kdekoli místo skutečných hodnot. Konstanta může být řetězec nebo číselná hodnota.
Cookies (cookies)
Bloky textu uložené do souboru na pevném disku vašeho počítače. Webové stránky používají cookies k identifikaci uživatelů, kteří se na stránky vracejí. Cookies mohou obsahovat přihlašovací jména a hesla nebo uživatelské předvolby. Když si zobrazíte webovou stránku, která dříve cookie zapsala, může server využít informace v něm uložené k přizpůsobení webu danému uživateli.
CPU (Central Processing Unit, centrální procesorová jednotka)
Hlavní procesor, který zodpovídá za celkové zpracování dat v počítači.
Data Member (datový člen)
V OOP je datový člen proměnná definovaná a zapouzdřená uvnitř třídy nebo objektu. Každá instance objektu si pro každý datový člen třídy uchovává vlastní jedinečnou hodnotu, na rozdíl od situace, kdy by třída měla jednu proměnnou sdílenou všemi instancemi. Je to jen jiný název pro vlastnost (Property).
Data Type (datový typ)
Vlastnosti proměnné, které popisují, zda je číselná, abecední nebo alfanumerická. Určuje také rozsah hodnot, které může proměnná obsahovat, a způsob, jakým se tato informace ukládá do paměti počítače.
DirectX
Sada nízkoúrovňových rozhraní pro programování aplikací (API), kterou poskytuje Microsoft pro tvorbu vysoce výkonných multimediálních aplikací. DirectX umožňuje programům komunikovat s vestavěnými vysokorychlostními 3D grafickými rutinami grafických karet a používat je k rychlejšímu zpracování. DirectX API také umožňuje snadný přístup k hardwaru počítače, jako jsou zvukové karty, joysticky a dokonce i síťové adaptéry.
DLL (Dynamic Linked Library, dynamicky linkovaná knihovna)
Soubor obsahující zkompilovaný kód, který mohou programy dynamicky načítat a spouštět. Protože tutéž DLL může opakovaně používat několik různých programů, místo aby měl každý tento kód ve vlastním souboru, výrazně se tím snižuje místo potřebné pro uložení spustitelného souboru.
DOS (Disk Operating System, diskový operační systém)
Obecně jakýkoli počítačový operační systém, často se však používá jako zkratka pro 'MS-DOS', operační systém, který Microsoft používal předtím, než byl vyvinut systém Windows.
Double (Double Precision Floating Point Number, číslo s plovoucí desetinnou čárkou s dvojitou přesností)
Číslo s plovoucí desetinnou čárkou, které využívá dvakrát více paměti než běžné číslo s plovoucí desetinnou čárkou, aby mohlo přesněji počítat a ukládat informace o číslicích za desetinnou čárkou. Typ double obvykle zabírá v paměti osm bajtů.
Encapsulation (zapouzdření)
Princip OOP používaný při definování objektů. Zapouzdření skrývá podrobné vnitřní specifikace objektu a zveřejňuje pouze jeho vnější rozhraní. Uživatelé objektu tak potřebují používat jen tato rozhraní. Díky zapouzdření lze vnitřní data a metody objektu měnit nebo aktualizovat, aniž by se změnil způsob, jakým uživatelé objekt používají.
Encryption (šifrování)
Zakódování dat tak, aby bylo obtížné je dekódovat a interpretovat.
EXE (Executable) file (soubor EXE, spustitelný soubor)
Soubor, který lze spustit, například počítačový program, obvykle dvojitým kliknutím na jeho ikonu nebo zástupce na ploše, případně zadáním jeho názvu do příkazového řádku. Spustitelné soubory lze spouštět i z jiných programů, dávkových souborů nebo různých skriptů. Naprostá většina známých virů napadá právě spustitelné soubory.
Expression (výraz)
Kombinace hodnot, řetězců, operátorů, příkazů nebo procedur, vyhodnocovaná podle pravidel priority operátorů, která vypočítá a vrátí hodnotu.
File Extension (přípona souboru)
Značka ze tří nebo čtyř písmen, před níž stojí tečka a která určuje formát datového souboru nebo aplikaci, jíž byl soubor vytvořen.
Firewall (firewall)
Firewally obvykle brání počítačům v síti v přímé komunikaci s externími počítačovými systémy. Software firewallu analyzuje informace, které mezi nimi procházejí, a pokud neodpovídají jeho předem nastaveným pravidlům, zastaví je.
Floating Point Number (or a Real Number) (číslo s plovoucí desetinnou čárkou, neboli reálné číslo)
Číslo, které má desetinnou část, i když je tato desetinná část nulová. Číslu s plovoucí desetinnou čárkou se někdy také říká 'reálné číslo' (real number), což se často zkracuje na pouhé 'real'. Čísla s plovoucí desetinnou čárkou obvykle zabírají v paměti čtyři bajty.
Function (funkce)
Totéž co procedura.
Hexadecimal (šestnáctková soustava)
Číselná soustava se základem 16. Prvních deset číslic tvoří ‘0’ až ‘9’ a dalších šest ‘A’ až ‘F’. Díky tomu lze velmi velká čísla vyjádřit pomocí velmi malého počtu znaků. ‘FF’ v šestnáctkové soustavě se rovná ‘255’ v desítkové soustavě. Webové stránky používají šestnáctková čísla k vyjádření 24bitové hodnoty barvy.
High Level Programming Language (vyšší programovací jazyk)
Programovací jazyk, v němž každá instrukce odpovídá mnoha instrukcím strojového kódu. Příkazy tohoto jazyka musí kompilátor nebo interpret přeložit dříve, než je může určitá architektura počítače vykonat. Vyšší programovací jazyk je také uživatelsky přívětivější, pro člověka snadněji čitelný, často multiplatformní a odstíněný od nízkoúrovňových operací procesoru počítače. PureBasic je vyšší programovací jazyk.
HTML (Hypertext Markup Language, hypertextový značkovací jazyk)
Jazyk pro tvorbu obsahu používaný na internetové síti World Wide Web. HTML se používá k vytváření webových stránek.
HTTP (Hypertext Transfer Protocol, protokol pro přenos hypertextu)
Základní protokol, který používá World Wide Web. HTTP definuje, jak se zprávy formátují a přenášejí a jaké akce mají webové servery a prohlížeče provádět v reakci na různé příkazy. Když například zadáte do prohlížeče adresu URL, ve skutečnosti tím odešlete webovému serveru příkaz HTTP, který mu nařizuje, aby požadovanou webovou stránku vyhledal a odeslal.
Hyperlink (hypertextový odkaz)
Odkaz v dokumentu, který vede na informace v tomtéž nebo v jiném dokumentu. Tyto odkazy jsou obvykle znázorněny zvýrazněnými slovy nebo obrázky. Když čtenář hypertextový odkaz vybere, přepne se zobrazení počítače na odkazovaný dokument nebo na tu jeho část, na kterou odkaz ukazuje.
Inheritance (dědičnost)
Proces v OOP, při němž objekty dědí funkčnost a data od třídy, z níž jsou odvozeny.
Integer (celé číslo)
Číslo bez desetinné čárky. Celočíselné hodnoty mohou být menší než nula, rovny nule nebo větší než nula.
Internet (internet)
Elektronická síť počítačů, která dnes zahrnuje téměř všechny univerzity, vládní instituce a výzkumná pracoviště na světě. Internet, původně vytvořený v roce 1969 jako páteřní komunikační síť pro případ jaderné války, zaznamenal explozivní nárůst veřejného i komerčního využití poté, co byl vyvinut snadno ovladatelný software pro přístup k informacím, které obsahuje.
Interpreter (interpret)
Program, který vykonává programy napsané ve vyšších programovacích jazycích řádek po řádku přímo ze zdrojového kódu. Liší se tím od kompilátoru, který svůj vstup (zdrojový kód) nevykonává, ale překládá ho do spustitelného strojového kódu (objektového kódu), jenž je určen k pozdějšímu slinkování a spuštění.
IP (Internet Protocol) Address (IP adresa)
Číslo, které identifikuje každého odesílatele či příjemce informací posílaných přes síť TCP/IP. IP adresa má podobu čtyř čísel oddělených tečkami, například: 127.0.0.1
IRC (Internet Relay Chat)
Forma okamžité komunikace přes internet. Je určena hlavně pro skupinovou komunikaci v diskusních fórech zvaných kanály, umožňuje však i komunikaci mezi dvěma osobami.
JavaScript
Skriptovací jazyk, který lze spouštět všude tam, kde je k dispozici vhodný interpret skriptů, například ve webových prohlížečích.
LAN (Local Area Network, místní síť)
Místní síť je počítačová síť pokrývající místní oblast, jako je domácnost, kancelář nebo malá skupina budov, například škola.
Link Time (doba linkování)
Okamžik během kompilace spustitelného souboru, kdy se objektový kód linkuje do výsledného spustitelného souboru.
Linked List (spojový seznam)
Datová struktura, která napodobuje chování dynamického pole. Umožňuje vkládat a mazat prvky dynamicky za běhu programu. Spojové seznamy lze vytvářet pomocí kteréhokoli z datových typů, které jazyk nabízí. Na rozdíl od pole však každý prvek obsahuje také ukazatele na předchozí a následující prvek seznamu, takže seznam nemusí zabírat souvislou oblast v RAM, a proto je při načítání dat pomalejší než pole.
Linker (linker)
Program, který spojuje zkompilované soubory s objektovým kódem a další datové soubory do spustitelného programu. Linker může mít i další funkce, například vytváření knihoven.
Linking (linkování)
Proces spojování souborů s objektovým kódem do výsledného spustitelného souboru.
Linux
Svobodný operační systém s otevřeným zdrojovým kódem založený na Unixu. Linux původně vytvořil Linus Torvalds za pomoci vývojářů z celého světa.
Localhost (localhost)
Počítačový systém, na kterém uživatel pracuje; často je mu přiřazena IP adresa: 127.0.0.1
Long
Celé číslo, které zabírá v paměti čtyři bajty.
Low Level Programming Language (nižší programovací jazyk)
Programovací jazyk, který poskytuje malou nebo žádnou abstrakci od mikroprocesoru počítače. Slovo „nižší“ neznamená, že by byl jazyk horší než vyšší programovací jazyky, ale vyjadřuje menší míru abstrakce mezi jazykem a hardwarem, který ovládá. Příkladem nižšího jazyka je jazyk symbolických adres (assembler).
Mac OS X
Nejnovější verze systému Mac OS, operačního systému používaného na počítačích Apple Macintosh. Mac OS X je na rozdíl od svých předchůdců založen na unixovém jádře a má modernizované uživatelské rozhraní.
Malicious Code (škodlivý kód)
Kus kódu navržený tak, aby poškodil systém nebo data, která obsahuje, případně aby zabránil běžnému používání systému.
Malware (malware)
Obecný výraz pro škodlivý software, jako jsou viry, trojské koně, spyware, adware atd.
MBR (Master Boot Record, hlavní spouštěcí záznam)
Program umístěný v hlavním spouštěcím sektoru. Tento program načte tabulku oddílů, určí, z kterého oddílu se má systém zavést, a předá řízení programu uloženému v prvním sektoru daného oddílu. Na každém fyzickém pevném disku je pouze jeden hlavní spouštěcí záznam.
MBS (Master Boot Sector, hlavní spouštěcí sektor)
První sektor pevného disku. Tento sektor se nachází na sektoru '1', hlavě '0' a stopě '0'. Obsahuje hlavní spouštěcí záznam.
Member Function (členská funkce)
Funkce nebo procedura, která je součástí třídy OOP a provádí nějaký výpočet, obvykle související s datovými členy třídy. Je to jiný název pro metodu (Method).
Method (metoda)
Funkce nebo procedura, která je součástí třídy OOP a provádí nějaký výpočet, obvykle související s vlastnostmi třídy.
MS-DOS (Microsoft Disk Operating System)
Operační systém, který Microsoft vyvinul pro platformu IBM před systémem Windows. Windows 3.x, 95 a 98 jsou na MS-DOS silně závislé a dokážou vykonat většinu příkazů MS-DOS.
Newsgroup (diskusní skupina)
Elektronické fórum, do něhož čtenáři zasílají příspěvky a navazující zprávy na určité téma. Internetová diskusní skupina umožňuje lidem z celého světa diskutovat o společných zájmech. Název každé diskusní skupiny vyjadřuje její téma.
NTFS (New Technology File System)
Souborový systém sloužící k organizaci a evidenci souborů, který je standardním souborovým systémem Windows NT a jeho následovníků: Windows 2000, Windows XP a Windows Server 2003.
Object (objekt)
Instance třídy OOP. Tento objekt dědí veškerou funkčnost a data naprogramovaná ve výchozí třídě.
Object Code (objektový kód)
Výstupem kompilátorů a assemblerů a vstupem i výstupem linkeru jsou soubory obsahující objektový kód. Existuje řada standardizovaných i proprietárních formátů objektových souborů, což znamená, že vývojové nástroje jednoho výrobce jen zřídka dokážou přečíst objektový kód vytvořený nástroji jiného výrobce.
OCX (OLE Control Extension)
Samostatný programový modul, k němuž mohou v prostředí Windows přistupovat jiné programy. Ovládací prvky OCX byly mezitím nahrazeny ovládacími prvky ActiveX. Ovládací prvky OCX mají příponu '*.ocx' a přestože byly nahrazeny, jsou s ActiveX stále kompatibilní, což znamená, že některé programy kompatibilní s ActiveX mohou tyto moduly nadále používat.
OLE (Object Linking And Embedding, propojování a vkládání objektů)
Tato technologie byla přejmenována na ActiveX a jím také nahrazena.
OOP (Object Oriented Programming, objektově orientované programování)
Styl programování, který podporuje zapouzdření, dědičnost a polymorfismus. Některé programovací jazyky, například C++, Java a Python, jsou objektově orientované už ze své podstaty, a umožňují tak pomocí konstrukcí programovacího jazyka efektivně modelovat skutečné či pomyslné objekty.
Open Source Software (software s otevřeným zdrojovým kódem)
Označuje jakýkoli program, jehož zdrojový kód je zpřístupněn k používání nebo úpravám podle toho, jak uživatelé či jiní vývojáři uznají za vhodné. Software s otevřeným zdrojovým kódem se obvykle vyvíjí formou veřejné spolupráce a je volně dostupný.
OpenGL (Open Graphics Library)
Specifikace definující na jazyce nezávislé API pro psaní aplikací, které vykreslují 2D a 3D grafiku. OpenGL je open source a multiplatformní, na rozdíl od DirectX, který je jeho nejbližším konkurentem.
Operating System (operační systém)
Operační systém je základní software, který vám umožňuje s počítačem pracovat. Operační systém řídí například úložiště počítače, komunikaci a správu úloh. Mezi běžné operační systémy patří například Mac OS X, Linux a Windows XP.
Parent (rodič)
Primární nebo nadřazené okno (či objekt), které vytváří a někdy i obsluhuje svá podřízená okna (či objekty).
Polymorphism (polymorfismus)
Pojem z OOP, který znamená, že jednu definici lze použít s různými typy dat. Například jedna polymorfní definice procedury může nahradit několik definic určených pro konkrétní typy a jediný polymorfní operátor může působit ve výrazech různých typů.
POP (Post Office Protocol)
E-mailový protokol, který umožňuje e-mailovým klientům stahovat poštu ze vzdáleného serveru přes připojení TCP/IP. Téměř všichni uživatelé individuálních e-mailových účtů u poskytovatelů internetových služeb mohou ke své poště přistupovat pomocí klientského softwaru, který používá POP3 (Post Office Protocol verze 3).
Port (port)
(1) Rozhraní, přes které se odesílají a přijímají data. (2) „Portovat“ může znamenat přepsání zdrojového kódu programu (někdy do jiného jazyka) tak, aby jej bylo možné zkompilovat nebo spustit na jiné počítačové platformě.
Procedure (procedura)
Pojmenovaná posloupnost příkazů, která se vykonává jako celek zavoláním jejího názvu. Procedury mohou také přijímat parametry, pomocí nichž lze do posloupnosti předat uživatelská data. Na rozdíl od podprogramů mohou procedury vracet vypočtenou hodnotu. Procedury lze 'volat' opakovaně, takže programy mohou kód využívat znovu a znovu, aniž by bylo nutné kód procedury psát víc než jednou.
Process (proces)
Běžící instance programu. Víceúlohový operační systém přepíná mezi procesy, aby vznikl dojem současného běhu, ačkoli ve skutečnosti může procesor v daném okamžiku používat pouze jeden proces.
Property (vlastnost)
V OOP je vlastnost proměnná definovaná a zapouzdřená uvnitř třídy nebo objektu. Každá instance objektu si pro každou vlastnost třídy uchovává vlastní jedinečnou hodnotu, na rozdíl od situace, kdy by třída měla jednu proměnnou sdílenou všemi instancemi.
Protocol (protokol)
Formální popis formátů zpráv a pravidel, jimiž se musí dva počítače řídit, aby si tyto zprávy mohly vyměňovat.
Quad
Celé číslo, které zabírá v paměti osm bajtů.
Radix Point (řádová čárka)
V matematice označuje řádová čárka symbol, který se v zápisu čísel používá k oddělení celé části čísla (vlevo od řádové čárky) od jeho zlomkové části (vpravo od řádové čárky). Řádová čárka je obvykle malá tečka, umístěná buď na účaří, nebo v polovině mezi účařím a horním okrajem číslic. V desítkové soustavě se řádová čárka nazývá desetinná čárka.
Refresh Rate (obnovovací frekvence)
Počet překreslení obrazu monitoru na obrazovku za sekundu. Obnovovací frekvence se udává v hertzích (Hz), takže obnovovací frekvence 75 znamená, že se obraz obnovuje 75krát za sekundu. Obnovovací frekvence konkrétního monitoru závisí na parametrech daného monitoru a použité grafické karty.
Registry (registr)
Interní databáze, kterou Microsoft Windows používá k ukládání informací o konfiguraci hardwaru a softwaru, uživatelských předvoleb a informací o instalaci.
Relative (relativní)
Může se vztahovat k hodnotě nebo k cestě. Relativní hodnota je taková, která se vztahuje k jiné hodnotě nebo na ní staví. Relativní cesta je taková, která je vztažena k jiné cestě. Relativní cesty se obvykle používají při určování umístění prostředků programu ve zdrojovém kódu, které jsou vztaženy ke spustitelnému souboru. Má-li například program načíst obrázek ze složky 'Images', je relativní cesta definována jako '\Images', protože tato složka se nachází ve stejném adresáři jako spustitelný soubor, a je tedy vztažena k programu.
Reset (reset)
Restartování počítače bez jeho vypnutí.
RGB (Red, Green And Blue, červená, zelená a modrá)
Základní barvy světla, které počítače používají k zobrazování obrázků na obrazovce. Barvy RGB se obvykle skládají z hodnot červené, zelené a modré v rozsahu od '0' do '255'. Tyto barvy se pak mísí podle aditivního barevného modelu. Když mají například všechny barevné složky maximální hodnotu (255), vznikne bílá barva.
Runtime (doba běhu)
Doba, kdy program běží, neboli je vykonáván.
SDL (Simple DirectMedia Layer)
Rozhraní pro programování aplikací (API) s otevřeným zdrojovým kódem pro tvorbu vysoce výkonných multimediálních aplikací. SDL je velmi jednoduché; funguje jako tenká multiplatformní obálka a poskytuje podporu pro 2D operace s pixely, zvuk, přístup k souborům, zpracování událostí, časování, vlákna a další. Spolu s SDL se často používá OpenGL, které zajišťuje rychlé 3D vykreslování. SDL bývá často považováno za multiplatformní obdobu DirectX, i když mu chybějí některé jeho pokročilejší funkce.
Server (server)
Jakákoli aplikace nebo počítač, který slouží jinému; například počítače, na nichž jsou uloženy webové stránky, se nazývají servery, protože poskytují webové prostředky klientským aplikacím, jako jsou webové prohlížeče.
Service (služba)
Program, který se může automaticky spustit v rámci spouštění operačního systému a nepřetržitě běží jako úloha na pozadí.
Shareware (shareware)
Software šířený bezplatně k vyzkoušení, za plná užívací práva je však nutné autorovi zaplatit. Pokud po vyzkoušení softwaru nemáte v úmyslu ho používat, jednoduše ho smažete. Používání neregistrovaného sharewaru po uplynutí zkušební doby se považuje za softwarové pirátství.
SMTP (Simple Mail Transport Protocol)
Jednoduchý formát doručování e-mailu pro přenos e-mailových zpráv mezi servery, který je současným standardem pro přenos e-mailu po internetu.
Software Pirate (softwarový pirát)
Osoba, která porušuje zákony týkající se autorských práv k softwaru. Zákony se řídí zemí, v níž daná osoba žije.
Source Code (zdrojový kód)
Kód, z něhož se program skládá před zkompilováním, tj. původní stavební instrukce programu, které kompilátoru určují, jaké akce má program provádět poté, co bude zkompilován do binárního spustitelného souboru.
Statement (příkaz)
Programovací příkaz, který jen zřídka vrací nějakou hodnotu a může obsahovat další součásti, jako je konstanta nebo výraz. K vytvoření programu je zapotřebí jeden nebo více příkazů.
Static Library (statická knihovna)
Knihovna, jejíž kód se při linkování začlení do spustitelného souboru, a stane se tak statickou součástí programu. Jakmile je program zkompilován, knihovnu již nepotřebuje, protože veškerý kód je nyní uvnitř spustitelného souboru.
String (řetězec)
Souvislá řada písmen, číslic a dalších znaků uzavřená v (dvojitých nebo jednoduchých) uvozovkách.
Subroutine (podprogram)
Posloupnost příkazů označená návěštím, která se vykonává jako celek skokem na začátek posloupnosti, obvykle pomocí příkazu 'Goto' nebo 'GoSub'. Po vykonání posloupnosti se běh programu vrátí do místa, odkud skok proběhl, obvykle pomocí příkazu 'Return'. Na rozdíl od procedur nemohou podprogramy vracet vypočtenou hodnotu. Na podprogramy lze skákat opakovaně, takže programy mohou kód využívat znovu a znovu, aniž by bylo nutné kód podprogramu psát víc než jednou.
Syntax (syntaxe)
Pravidla, podle nichž se slova ve zdrojovém kódu programu spojují do příkazů, které jsou pro interpret nebo kompilátor platné.
TCP/IP
Tato sada internetových protokolů je souborem komunikačních protokolů, které tvoří zásobník protokolů, na němž běží internet a většina komerčních sítí. Nazývá se sada protokolů TCP/IP podle dvou nejdůležitějších protokolů, které obsahuje: Transmission Control Protocol (TCP) a Internet Protocol (IP), jež byly zároveň jako první definovány.
Thread (Thread Of Execution) (vlákno, vlákno vykonávání)
Vlákno je jediná posloupnost instrukcí vykonávaná jako samostatná úloha, která je však stále součástí výchozího procesu. Proces může mít několik souběžně běžících vláken, z nichž každé provádí jinou úlohu, například čeká na události nebo vykonává časově náročnou práci, kterou program nemusí dokončit, než přejde k něčemu jinému. Když vlákno svou práci dokončí, je pozastaveno nebo zrušeno. Vícevláknové programy mohou při správném naprogramování dokončit úlohy rychleji než programy bez vláken, protože některé procesory podporují současný běh dvou či více vláken, například řada procesorů Intel s technologií Hyperthreading.
Trojan Horse (trojský kůň)
Škodlivý program, který se tváří jako užitečný a neškodný, ale po spuštění záměrně dělá něco, co uživatel nečeká a čeho si někdy ani nevšimne. Trojské koně nejsou viry, protože se nerozmnožují, mohou však být stejně ničivé.
UNC (Universal Naming Convention)
Standard pro identifikaci serverů, tiskáren a dalších prostředků v síti, který vznikl v komunitě kolem Unixu. Cesta UNC používá před názvem počítače dvě lomítka nebo dvě zpětná lomítka. Cesta (disk a adresáře) uvnitř daného počítače se pak odděluje jednoduchými lomítky nebo jednoduchými zpětnými lomítky. Microsoft Windows obvykle používá zpětná lomítka a Unix (Linux) běžná lomítka.
Unicode
Schéma kódování znaků, které používá 16 bitů (2 bajty) na znak, aby bylo možné všechny znaky všech hlavních světových jazyků, živých i mrtvých, zakódovat v jediné znakové sadě a stejně jako v ASCII jim přiřadit jedinečné číslo. Znakové sady Unicode mohou obsahovat přes 65 000 znaků.
Unix
Operační systém, na jehož vzniku se podíleli výzkumníci společnosti AT&T. Unix je dobře známý svou nezávislostí na hardwaru a přenositelnými aplikačními rozhraními. UNIX je navržen tak, aby ho mohlo používat mnoho lidí současně, a má vestavěnou podporu sítí TCP/IP. Unix a jeho odvozeniny (Linux) jsou nejrozšířenějšími operačními systémy pro servery na internetu.
URL (Uniform Resource Locator)
Adresa HTTP, kterou World Wide Web používá k určení konkrétního místa a souboru. Je to jedinečný identifikátor, neboli adresa, webové stránky na internetu.
Usenet
Neformální systém elektronických nástěnek či diskusních skupin, který se obvykle šíří prostřednictvím internetu. Usenet je starší než internet, ačkoli dnes se většina materiálů Usenetu šíří přes internet.
VBS (Visual Basic Script)
Programovací jazyk, který dokáže vyvolat jakoukoli systémovou funkci, včetně spouštění, používání a ukončování jiných aplikací, a to i bez vědomí uživatele. Programy VBS lze vkládat do souborů HTML a poskytovat tak aktivní obsah prostřednictvím internetu. Soubory Visual Basic Script mají příponu '*.vbs'.
Virus (virus)
Soubor s počítačovým programem, který se dokáže připojit k diskům nebo jiným souborům a opakovaně se rozmnožovat, obvykle bez vědomí či svolení uživatele. Některé viry se připojují k souborům, takže když se napadený soubor spustí, spustí se i virus. Jiné viry sídlí v paměti počítače a napadají soubory ve chvíli, kdy je počítač otevírá, upravuje nebo vytváří. Některé viry vykazují příznaky a některé poškozují soubory a počítačové systémy, ale ani příznaky, ani škody nejsou pro definici viru podstatné; neškodný virus je stále virus.
VM (Virtual Machine, virtuální stroj)
Software, který napodobuje fungování hardwarového zařízení. Virtuální stroj je samostatné provozní prostředí, které se chová, jako by šlo o samostatný počítač. Například Java applety běží ve virtuálním stroji Javy, který nemá přístup k hostitelskému operačnímu systému.
VSync (Vertical Synchronization, vertikální synchronizace)
Vertikální synchronizace je volba, kterou najdete v mnoha hrách a která umožňuje sladit snímkovou frekvenci hry s obnovovací frekvencí monitoru. Zapnutí VSync obecně zajišťuje největší stabilitu, jeho vypnutí však může umožnit mnohem vyšší snímkovou frekvenci. Nevýhodou vyšší rychlosti je možný vznik vizuálních artefaktů, například trhání obrazu.
W3C (Wide Web Consortium)
Řídicí orgán pro standardy World Wide Webu.
WAN (Wide Area Network, rozlehlá síť)
Skupina počítačových sítí propojených na velké vzdálenosti. Internet je rozlehlá síť (WAN).
Word
Celé číslo, které zabírá v paměti dva bajty.
World Wide Web
Systém pro procházení internetových stránek. Nazývá se web (pavučina), protože se skládá z mnoha vzájemně propojených stránek. Uživatelé mohou přecházet z jedné stránky na druhou klikáním na hypertextové odkazy.
Worm (červ)
Parazitické počítačové programy, které se rozmnožují, ale na rozdíl od virů nenapadají jiné soubory s počítačovými programy. Červi mohou vytvářet své kopie na tomtéž počítači nebo je mohou rozesílat do jiných počítačů prostřednictvím sítě.
Wrapper (obálka)
Programové rozhraní mezi programem a samostatným, „obaleným“ kusem kódu. To se může dělat z důvodu kompatibility, například pokud je obalený kód zkompilován jako DLL nebo používá jiné konvence volání. Z toho vyplývá, že k obalenému kódu lze přistupovat pouze prostřednictvím obálky.
WSH (Windows Scripting Host)
Integrovaný modul společnosti Microsoft, který programátorům umožňuje automatizovat operace v celém prostředí pracovní plochy Windows.
XML (Extensible Markup Language, rozšiřitelný značkovací jazyk)
Standard pro vytváření značkovacích jazyků, které popisují strukturu dat. Nejde o pevnou sadu prvků jako u HTML, ale o jazyk pro popis jazyků. XML umožňuje autorům definovat vlastní značky.
ZIP File (soubor ZIP)
Archiv obsahující komprimované sady jiných souborů. Soubory ZIP jsou na internetu oblíbené, protože uživatelé mohou doručit více souborů v jediném kontejneru, což navíc šetří místo na disku i dobu stahování.

O autorovi
Gary Willoughby je profesionální grafik, webový vývojář a vývojář softwaru. Programovat se poprvé učil koncem devadesátých let v interpretovaných jazycích, jako jsou PHP, Python a Javascript, a poté se rozhodl věnovat svůj volný čas přechodu k vývoji aplikací v kompilovaných jazycích.
Po nějaké době používání C++, kdy si všiml, jak obrovský programátorský maraton vyžaduje i jednoduchý kus softwaru, začal hledat jednodušší, intuitivnější a elegantnější programovací jazyk, v němž by mohl za kratší dobu vytvářet dobře navržený software. Všechna tato přání splnila málo známá francouzská firma Fantaisie Software. Programovací jazyk, který vyvinula a uvedla na trh, se jmenoval PureBasic.
Od léta roku 2002 je Gary aktivním členem komunity na oficiálním online fóru PureBasicu (pod pseudonymem ‘Kale’) a v PureBasicu napsal několik úspěšných komerčních programů.