Ncurses – úvod ncurses je knihovna, která umožňuje barevný výstup na terminál, tvoří takovou nádstavbu klasického terminálu. Pomocí ncurses si můžeme nadefinovat.

Prezentace na téma: "Ncurses – úvod ncurses je knihovna, která umožňuje barevný výstup na terminál, tvoří takovou nádstavbu klasického terminálu. Pomocí ncurses si můžeme nadefinovat."— Transkript prezentace:

1 ncurses – úvod ncurses je knihovna, která umožňuje barevný výstup na terminál, tvoří takovou nádstavbu klasického terminálu. Pomocí ncurses si můžeme nadefinovat barvy, které budeme používat, styl písma (tučné, kurzíva, podtržené a jejich kombinace) a pozadí. Abychom uplatnily styl písma, musí terminál běžet v grafickém režimu (v okně nebo přes framebuffer). ncurses dále umožňuje vytvožit více podoken, zjistit velikost terminálu a hlavně echovat výstup z klávesnice (nečeká na ukončení řádku '\n' – enter). Abychom úspěšně zkompilovali aplikaci pod ncurses, potřebujeme její hlavičkové soubory a knihovny, nám bude stačit #include <curses.h> poznámka: ncurses je náhrada za curses, v dokumentaci je všude curses.h, takže ho budeme používat i my, v linuxu je ncurses.h jen symbolický odkaz na curses.h, takže je jedno co si zvolíme. Při linkování aplikace potřebujeme knihovnu ncurses. Příklad kompilace aplikace 'test' v linuxu (výsledný soubor je spustitelný): gcc -lncurses test.c -o test

2 ncurses – vzorová aplikace
V manuálových stránkách ncurses najdeme tuto vzorovou aplikaci a my si krok za krokem popíšeme co dělá. #include <curses.h> /* hlavičkový soubor pro ncurses */ #include <signal.h> /* ncurses aplikace potřebuje signály */ /* tato funkce bude zavolána při ukončení aplikace */ static void finish(int sig) { endwin(); /* tady vlož non-curses ukončovací kód */ exit(0); } /* konec funkce finish() */ int main(int argc, char *argv[]) { int num = 0; /* tady nainicializuj tvoje non-curses data a struktury */ signal(SIGINT, finish); /* signal handler pro ukončení apl. */ initscr(); /* inicializuj knihovnu (n)curses */ keypad(stdscr, TRUE); /* povol mapování kláves */ nonl(); /* nedělej z '\n' -> '\r\n' */ cbreak(); /* nečekej na konec řádku při vstupu z klávesnice */ echo(); /* barevný výstup (echo input in color) */

3 ncurses – vzorová aplikace
/* funkce has_colors() zjistí, zda je terminál barevný */ if (has_colors()) { /* terminál je barevný a funkce start_color() řekne curses * aby používal barvy. */ start_color(); /* Jednoduché přenastavení barev, barva číslo 0 nemůže být * přenastavena. Při volání funkce init_pair zadáváme první * index barvy, barvu textu a barvu pozadí jako poslední */ init_pair(1, COLOR_RED, COLOR_BLACK); init_pair(2, COLOR_GREEN, COLOR_BLACK); init_pair(3, COLOR_YELLOW, COLOR_BLACK); init_pair(4, COLOR_BLUE, COLOR_BLACK); init_pair(5, COLOR_CYAN, COLOR_BLACK); init_pair(6, COLOR_MAGENTA, COLOR_BLACK); init_pair(7, COLOR_WHITE, COLOR_BLACK); } /* hlavní cyklus programu */ for (;;) { int c = getch(); /* zachytává jednotlivé znaky při psaní */ attrset(COLOR_PAIR(num % 8)); /* přenastaví barvu */ num++; /* toto do své aplikace nedávejte, jen to přičítá */ } /* barvy */ finish(0); /* na tento řádek se aplikace nikdy nedostane */ } /* konec funkce main() */

4 ncurses – vzorová aplikace
Takto vypadá vzorová apolikace po nalinkování, můžeme si všimnout, že každé písmeno má jinou barvu, to způsopbuje právě to n++ a volání funkce attrset().

5 ncurses – vlastní typy Ještě než probereme funkce je třeba si ujasnit definice a typy použité v knihovně ncurses: typedef unsigned char bool; – ncurses definuje bool jako char! (hodnoty TRUE a FALSE). typedef unsigned long chtype; - jeden znak včetně attributy typedef struct screen SCREEN; typedef struct _win_st WINDOW; /* ...must be at least as wide as chtype */ typedef chtype attr_t; #define ERR (-1) - funkce proběhla s chybou (-1). #define OK (0) - funkce proběhla v pořádku. V dokumentaci a hlavičkovém souboru jsem se dočetl, že některé funkce nemusí vrátit OK jako indikaci, že proběhli úspěšně, měli bychom testovat pouze, jestli proběhli neúspěšně (ERR) => Pokud se návratová hodnota funkce nerovná ERR, funkce proběhla úspěšně.

6 ncurses – inicializace a deinicializace
WINDOW* initscr(void); První funkce, která musí být zavolána, nastaví vše potřebné, zjistí charakteristiku terminálu a alokuje prostor pro první okno (stdscr). Tato funkce smí být zavolána pouze jednou a jako první. int endwin(void); Funkce, která se postará o vyčištění ncurses z paměti a posune kurzor do spodního levého rohu. Tato funkce by měla být zavolána jako poslední funkce z knihovny ncurses. SCREEN* newterm(const char *type, FILE *ofp, FILE *ifp); Aplikace, která potřebuje více než jeden terminál by měla zavolat tuto funkci pro vytvoření dalšího, takto vytvořený terminál může být odstraňen funkcí delscreen(). Parametr ofp je výstup a parametr ifp je vstup. Type je typ, v případě že je NULL, bude použita systémová proměnná $TERM. SCREEN* set_term(SCREEN *to); Nastaví aktuální terminál na to a vrátí předchozí. void delscreen(SCREEN *sp); Zničí terminál sp vytvořený funkcí newterm().

7 ncurses – okna (WINDOW*)
Okno je pole, které má 2 dimenze znaků, reprezentující celou nebo část CRT obrazu. Výstup a vstup znaků by měl být směřován do specifického okna. Defaulní okno je stdwin, které reprezenjute plnou velikost terminálu x, y. Ale funkcí newwin() můžeme vytvořit například určitý výřez okna, viz obrázek. Vytvoření okna: WINDOW *newwin(int nlines, int ncols, int y0, int x0); WINDOW *subwin(WINDOW *parent, int nl, int nc, int y0, int x0); LINES a COLUMNS jsou globální proměnné!

8 ncurses – okna (WINDOW*)
Zníčení okna: int delwin(WINDOW *win); Výška a šířka okna: Velikost terminálu je dána proměnou COLUMNS a LINES. Jsou to globální proměnné nastavené při initsrc(). Co když se ale velikost změní...? Změnit velikost může například uživatel když roztáhne okno terminálu. #define getmaxx(win) ((win)?((win)->_maxx + 1):ERR) #define getmaxy(win) ((win)?((win)->_maxy + 1):ERR) #define getmaxyx(win,y,x) (y = getmaxy(win), x = getmaxx(win)) struktura WINDOW sama uchováná svoje rozměry a tyto makra slouží jenom pro jejich extrakci. Obnovení obsahu okna (aktualizace): int wrefresh(WINDOW *win); #define refresh() wrefresh(stdscr) Funkce wrefresh() obnoví obsah okna win, makro refresh() obnoví obsah okna stdscr. Můžeme si všimnout, že u všech funkcí, které mají prefix w je první parametr WINDOW*. Vyčištění obsahu okna: int wclear(WINDOW *win); #define clear() wclear(stdscr)

9 ncurses – okna (WINDOW*)
Změnění velikosti okna: int wresize(WINDOW *win, int y, int x); Změní velikost okna win na x, y. Funkce vrátí ERR při neúspěchu, jinak OK. Posun okna: int mvwin(WINDOW *win, int y, int x); Posune okno win na pozici x, y. Funkce vrátí ERR při neúspěchu, jinak OK.

10 ncurses – kurzor Kurzor nám ukazuje, kam je směřován vstup, a proto je jeho pozice velmi důležitá. Pro změnu kurzoru je funkce wmove() a makro move(), ale máme tu i kombinované funkce, které udělají víc věcí současně (jednoduchost a rychlost). Funkce, které změní pozici kurzoru mají prefix mv a funkce které změní pozici kurzoru do okna mají prefix mvw. Malý příklad pro funkci wgetch(): int mvgetch(int y, int x); int mvwgetch(WINDOW *win, int y, int x); Změna pozice kurzoru: int wmove(WINDOW *win, int y, int x); #define move(x, y) wmove(stdscr, y, x) Opět se jedná o dvojici funkcí, pozor u všech funkcí začíná první parametr y a pak x, je to tak trochu nezvyk, ale knihovna ncurses je taková.

11 ncurses – vstup Funkce pro nastavení vstupu:
int cbreak(void); Tato funkce ohlásí terminálu, že chceme zachytit každý znak (nečekat na '\n' – konec řádku). int keypad(WINDOW *window, bool value); Tuto funkci zavoláme, když chceme zachytit speciální klávesy, jako jsou např. Backspace, Delete, … (jestli jsme vytvořili pouze jedno okno funkcí initsrc(), voláme tuto funkci takto: keypad(stdscr, TRUE); ) int echo(void); Touto funkcí zapneme echování vstupu z klávesnice (každá klávesa, která bude poslána na vstup bude vypsána na obrazovku) int noecho(void); Touto funkcí vypneme echování vstupu z klávesnice, stisknuté klávesy se nebudou vypisovat. int nodelay(WINDOW *win, bool value); Tato funkce vypne (nebo zapne) zpoždění kláves po první stisknuté klávese. To je dobré například pro ňákou hru(?).

12 ncurses – vstup Funkce pro zachycení vstupu: int wgetch(WINDOW *win)
int mvwgetch(WINDOW *win, int y, int x); #define getch() wgetch(stdscr) #define mvgetch(y, x) mvwgetch(stdscr, y, x) všechny tyto funkce a makra zachytí jeden znak ze vstupu. V případě, že jsme nastavili funkcí nodelay() na TRUE, funkce vrátí hodnotu ERR, v případě, že nebyla stisknuta žádná klávesa. Funkce getch čeká pouze, když je nastaveno: nodelay(win, FALSE); int scanw(const char *fmt, ...); int wscanw(WINDOW *win, const char *fmt, ...); int mvscanw(int y, int x, const char *fmt, ...); int mvwscanw(WINDOW *win, int y, int x, const char *fmt, ...); Zachycení formátovaného vstupu (jako scanf)

13 ncurses – vstup Funkce pro zachycení vstupu (pokr.): int wgetstr(WINDOW *win, char *str); int wgetnstr(WINDOW *win, char *str, int len); int mvwgetnstr(WINDOW *win, int y, int x, char *str, int len); int mvwgetstr(WINDOW *win, int y, int x, char *str); #define getstr(str) wgetstr(stdscr, str) #define mvwgetnstr(win,y,x,str,n)(wmove(win,y,x) == ERR ? ERR : wgetnstr(win,str,n)) #define mvwgetstr(win,y,x,str) (wmove(win,y,x) == ERR ? ERR : wgetstr(win,str)) Funkce a makra, které čtou řetězec ukončený '\n' Tady je seznam některých kódů kláves (Kompletní seznam je v man stránkách funkce getch()): key code popis KEY_DOWN The four arrow keys ... KEY_UP KEY_LEFT KEY_RIGHT KEY_HOME Home key KEY_BACKSPACE Backspace KEY_F(n) Function keys, for 0 <= n >= 63 KEY_DC Delete character KEY_IC Insert char or enter insert mode KEY_ENTER Enter or send

14 ncurses – výstup výstup je vždy tam, kde se nachází kurzor.
pro výstup máme i funkce s prefixem mv a mvw. pro aktualizaci (obnovení) je třeba volat funkci refresh() nebo wrefresh(). Výstup po jendom znaku: int addch(const chtype ch); int waddch(WINDOW *win, const chtype ch); int mvaddch(int y, int x, const chtype ch); int mvwaddch(WINDOW *win, int y, int x, const chtype ch) int echochar(const chtype ch); int wechochar(WINDOW *win, const chtype ch); Máme tu šestici funkcí, které vypíší jeden znak do okna win (nebo do stdscr), rozdíl je v tom, že funkce echochar() a wechochar() zavolají wrefresh() pro aktualizaci výstupu. Výstup řetězce: int addstr(const char *str) int waddstr(WINDOW *win, const char *str) int mvaddstr(int y, int x, const char *str); int mvwaddstr(WINDOW *win, int y, int x, const char *str); int addnstr(const char *str, int len); int waddnstr(WINDOW *win, const char *str, int len); int mvaddnstr(int y, int x, const char *str, int len); int mvwaddnstr(WINDOW *win, int y, int x, const char *str, int len);

15 ncurses – výstup Výstup formátovaného textu:
int printw(const char *fmt ...); int wprintw(WINDOW *win, const char *fmt, ...); int mvprintw(int y, int x, const char *fmt, ...); int mvwprintw(WINDOW *win, int y, int x, const char *fmt, ...); Poznámka: Pokud chceme aktualizovat výstup, je nutné zavolat funkci wrefresh() nebo refresh(). Pokud chcete opravdu pokročilou aktualizaci, mrkněte na funkce: int wnoutrefresh(WINDOW *win); int doupdate(void); int redrawwin(WINDOW *win); int wredrawln(WINDOW *win, int beg_line, int num_lines); Smysl těchto funkcí spočívá v tom, že okna si uchovávají dvojí obsah (takový textový double-buffer), jeden obsah je roven tomu, co je na obrazovce, a druhý tomu, co by tam mělo být. Funkcí doupdate() se překreslí jen to, co se opravdu změnilo.

16 ncurses – grafický výstup
NCurses nabízí víc než jen výstup znaků a řetězců. Umožňuje do okna přímo kreslit. V následující části si popíšeme jak vykreslit horizontální nebo vertikální čáru, okraj nebo rámeček a kopírování obsahu z jednoho okna do druhého. Kreslení horizontální čáry: int hline(chtype ch, int length); int whline(WINDOW *win, chtype ch, int length); int mvhline(int y, int x, chtype ch, int length); int mvwhline(WINDOW *win, int y, int x, chtype ch, int length); Tyto funkce nakreslí horizontální čáru typu ch o velikosti length. Kreslení vertikální čáry: int vline(chtype ch, int length); int wvline(WINDOW *win, chtype ch, int length); int mvvline(int y, int x, chtype ch, int length); int mvwvline(WINDOW *win, int y, int x, chtype ch, int length); Tyto funkce nakreslí vertikální čáru typu ch o velikosti length.

17 ncurses – grafický výstup
Kreslení okraje (border): int border(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br); int wborder(WINDOW *win, chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br); Tyto funkce nakreslí okraj (border) okolo okna win. Dalo by se říct že okraj je nakreslen v okně. Kreslení rámečku (box): int box(WINDOW *win, chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, chtype tr, chtype bl, chtype br); Funkce nakreslí rámeček (box) v okně win na pozici x, y. Umístění atribut pro funkce border(), vborder() a box(): ls – levá strana, rs – pravá strana, ts – vrchní strana, bs – spodní strana, tl – roh vlevo-nahoře, tr – roh vpravo nahoře, bl – roh vlevo-dole a br – roh vpravo-dole.

18 ncurses – grafický výstup
Kopírování obsahu z jednoho okna do druhého: int overlay(const WINDOW *srcwin, WINDOW *dstwin); int overwrite(const WINDOW *srcwin, WINDOW *dstwin); Obě 2 funkce zkopírují obsah srcwin do dstwin. Okna nemusí mít stejné rozměry. Rozdíl je v tom, že funkce overlay() nepřepisuje prázdné znaky (blank characters) a funkce overwrite() ano. int copywin(const WINDOW *srcwin, WINDOW *dstwin, int sminrow, int smincol, int dminrow, int dmincol, int dmaxrow, int dmaxcol, int overlay); Tato funkce zkopíruje jen určitou část okna srcwin na určitou pozici okna dstwin. Parametr overlay určuje, zda kopírovat i prázdné znaky (blank characters). U NCurses si musíme opět zvyknout, že první parametr u kopírování je zdroj (source) a druhý je cíl (destination)!!!

19 ncurses – atributy (attributes)
Když se znaky vykreslí na obrazovku, můžeme vidět některé z efektů jako barva písma, barva pozadí, styl písma, blikání, atd..., souhrn těchto efektů nazýváme právě atributy.Každý bit atributy koresponduje jako jeden grafický efekt. Máme dva způsoby použití atribut, jeden způsob je volání funkcí jako např waddch(win, ch), kde znak ch je včetně atribut, druhý způsor umožňuje nastavit předvolené globální atributy do okna. Než se pustíme k popisu funkcí, popíšeme si předdefinované atributy: A_NORMAL Normání display (bez zvíraznění). A_STANDOUT Nejlepší zvýrazňvací mód terminálu. A_UNDERLINE Podtržení. A_REVERSE Převrátit A_BLINK Blikání. A_DIM Poloviční světlost. A_BOLD Extra světlost nebo tučné. A_PROTECT Protected mode. A_INVIS Neviditelný nebo blikací mód. A_ALTCHARSET Alternativní character set. A_CHARTEXT Bitová maska k extrakci znaku. COLOR_PAIR(n) Color-pair číslo n.

20 ncurses – atributy (attributes)
Funkce pro změnu atribut: int attroff(int attrs); int wattroff(WINDOW *win, int attrs); Funkce které odeberou globální atributy attrs z okna win (nebo stdscr). int attron(int attrs); int wattron(WINDOW *win, int attrs); Funkce které přidají globální atributy attrs do okna win (nebo stdscr). int attrset(int attrs); int wattrset(WINDOW *win, int attrs); Funkce které nastaví globální atributy attrs okna win (nebo stdscr).

21 ncurses – atributy (attributes)
Používání barev: Do atributy můžeme také přidat kombinaci barvy textu a pozadí (jestli chceme používat barvy, musíme to dát najevo, hned na začátku je popis k funkcím has_colors() a start_color() ). Poté, co jsme zavolali funkci start_color(), je vytvořena množina barev a barevných párů (color pairs), kterou můžem použít a změnit. Počet barev a párů barev k dispozici je uložen v globálních proměnných COLORS a COLOR_PAIRS. K využití předdefinovaných párů můžeme využít makro COLOR_PAIR(n), kde n musí být menší než COLOR_PAIRS. Po vykonání funkce start_color() je nastavených 8 barev: COLOR_BLACK černá COLOR_RED červená COLOR_GREEN zelená COLOR_YELLOW žlutá COLOR_BLUE modrá COLOR_MAGENTA purpurová COLOR_CYAN tyrkysová COLOR_WHITE bílá

22 ncurses – atributy (attributes)
Barevné funkce: bool has_colors(void); Zeptá se terminálu, jestli je barevný...? Funkce vrací nenulovou hodnotu, jestli ano. int start_color(void); Oznámí používání barev. Tato funkce sama o sobě inicializuje barvy COLOR_xxx. bool can_change_color(void); Zeptá se terminálu, zda můžem změnit základní barvy? Vrací nenulovou hodnotu, jestli ano. int init_pair(short pair, short f, short b); Nastavý barevný pár pair na barvu popředí f a pozadí b. int init_color(short color, short r, short g, short b); Nastaví barevné složky r,g,b barvy color. int color_content(short color, short *r, short *g, short *b); Vrátí barevné složky barvy color. int pair_content(short pair, short *f, short *b); Vrátí popředí (f) a pozadí (b) barevného páru pair.

23 ncurses – atributy (attributes)
Jak na to...? Ukázali jsme si funkce a typy pro změnu barev a atribut, ale jak docílit, že se znak zobrazí tak jak chceme...? Jednoduše, při zadávání textu nebo znaku můžeme ORovat styly a barvy, malý příklad: addch(win, 'X' | A_UNDERLINE | COLOR_PAIR(3)); NCurses nabízí funkce, které umožňují psát text (řetězec) v atributách: int addchstr(const chtype *chstr); int waddchstr(WINDOW *win, const chtype *chstr); int mvaddchstr(int y, int x, const chtype *chstr); int mvwaddchstr(WINDOW *win, int y, int x, const chtype *chstr); Funkce, které vypíší řetězec chstr typu chtype* ukončený (chtype)0 do okna win (nebo stdscr). int addchnstr(const chtype *chstr, int n); int waddchnstr(WINDOW *win, const chtype *chstr, int n); int mvaddchnstr(int y, int x, const chtype *chstr, int n); int mvwaddchnstr(WINDOW *win, int y, int x, const chtype *chstr, int n); Funkce, které vypíší n znaků řetězce chstr typu chtype* do okna win (nebo stdscr).

24 ncurses – tabulka grafických znaků
Knihovna NCurses definuje některé grafické znaky: Už jsme se setkali s funkcí box(), border() nebo hline(), když chceme nakreslit například rámeček nebo čáru. Abychom to měli co nejsnadnější, tak nám knihovna NCurses nabízí předdefinované konstanty různých grafických symbolů (čáry a různé ASCII znaky) ACS_BLOCK solid square block ACS_BOARD board of squares ACS_BTEE bottom tee ACS_BULLET bullet ACS_CKBOARD checker board (stipple) ACS_DARROW arrow pointing down ACS_DEGREE degree symbol ACS_DIAMOND diamond ACS_GEQUAL greater-than-or-equal-to ACS_HLINE horizontal line ACS_LANTERN lantern symbol ACS_LARROW arrow pointing left ACS_LEQUAL less-than-or-equal-to ACS_LLCORNER lower left-hand corner ACS_LRCORNER lower right-hand corner ACS_LTEE left tee

25 ncurses – tabulka grafických znaků
Knihovna NCurses definuje některé grafické znaky: Už jsme se setkali s funkcí box(), border() nebo hline(), když chceme nakreslit například rámeček nebo čáru. Abychom to měli co nejsnadnější, tak nám knihovna NCurses nabízí předdefinované konstanty různých grafických symbolů (čáry a různé ASCII znaky) ACS_NEQUAL not-equal ACS_PI greek pi ACS_PLMINUS plus/minus ACS_PLUS plus ACS_RARROW arrow pointing right ACS_RTEE right tee ACS_S scan line 1 ACS_S scan line 3 ACS_S scan line 7 ACS_S scan line 9 ACS_STERLING pound-sterling symbol ACS_TTEE top tee ACS_UARROW arrow pointing up ACS_ULCORNER upper left-hand corner ACS_URCORNER upper right-hand corner ACS_VLINE vertical line

26 ncurses – příklad 1 Pojďme si shrnout vše co jsme se naučili do krátkých příkladů, zavádějící a ukončovací kód programu vynechávám, zůstávají akorát vnitřekí: /* nakresli rámeček v hlavním okně / wattrset(stdscr, COLOR_PAIR(2)); wborder(stdscr, ACS_VLINE, ACS_VLINE, ACS_HLINE, ACS_HLINE, ACS_ULCORNER, ACS_URCORNER, ACS_LLCORNER, ACS_LRCORNER); /* vytvoř podokno okna stdwin (pozice 1, 1) */ WINDOW *win = subwin(stdscr, getmaxy(stdscr)-2, getmaxx(stdscr)-2, , 1); /* nastav atributu nově vytvořeného okna na barevný pár 0 */ wattrset(win, COLOR_PAIR(0)); wprintw(win, "maxx=%d\n", getmaxx(stdscr)); /* něco */ wprintw(win, "maxy=%d\n", getmaxy(stdscr)); /* vypiš */ wprintw(win, "COLORS=%d\n", COLORS); wprintw(win, "COLOR_PAIRS=%d\n", COLOR_PAIRS); /* všimněme si že se kurzor neposune při volání whline() */ whline(win, ACS_HLINE | COLOR_PAIR(3), getmaxx(win)); wrefresh(stdscr); /* aktualizuj hlavní okno */ wrefresh(win); /* aktualizuj podokno win */

27 ncurses – příklad 1 (výsledek)

28 ncurses – příklad 2 chtype chstr[] = { 'J' | A_NORMAL | COLOR_PAIR(1), 'E' | A_STANDOUT, 'D' | A_UNDERLINE, 'N' | A_REVERSE, 'O' | A_BLINK, 'D' | A_DIM, 'U' | A_BOLD, 'C' | A_PROTECT, 'H' | A_INVIS, 'Y', ' ', 'T', 'e', 'x', 't', ' ', ACS_PI, 0 }; /* vykresli řetězec typu chtype* */ addchstr(chstr); /* aktualizuj screen */ refresh();

29 ncurses – příklad 2 (výsledek)

30 ncurses – vychytávka pro X Window System
Protože terminál může běžet v okně a uživatel ho může kdykoliv roztáhnout nebo smrštit, je nutné aplikaci umožnit zachytávat událostí o změně velikosti terminálu. Jde o signál SIGWINCH. Jediné co je třeba je nastavit handler a to je vše. Příklad: #include <signal.h> void* resizeHandler(int sig); int main(int argc, char *argv[]) { signal(SIGWINCH, resizeHandler); } void* resizeHandler(int sig) { int nh, nw; getmaxyx(stdscr, nh, nw); /* get the new screen size */ }

31 ncurses – ukázky aplikací běžící pod ncurses (alsamixer)

32 ncurses – ukázky aplikací běžící pod ncurses (mc)

33 ncurses – hořící terminál (aafire, využití knihovny aalib)

34 ncurses – závěr ncurses toho umí daleko víc, ale to by se sem asi všechno nevešlo. Krátký souhrn toho, co zde chybí: Tvorba gui (menu, panels, forms, ...) #include <panel.h> #include <menu.h> #include <form.h> Obsluha myši (je řešena pomocí zvláštní pseudoklávesy, která se získá funkcí getch(); ) Nejsou zde popsány úplně všechny funkce, které umožňuje knihovna ncurses. Vypracoval: Petr Kobalíček Zlín