Управление терминалами (curses/terminfo)

ПРЕДИСЛОВИЕ

Многие коммерческие программные системы имеют в своем составе программы, управляющие вводом и выводом на терминал. Такая программа может перемещать курсор, показывать меню, делить экран терминала на окна или форматировать экран для облегчения ввода и извлечения информации из базы данных.

В этой главе объясняется, как разрабатывать программы, работающие с терминалом в системе UNIX, используя пакет подпрограмм, называемый cursescurses/terminfo . Этот пакет включает библиотеку подпрограмм на языке C, базу данных и набор вспомогательных средств системы UNIX. Назначение данной главы - не описание всех компонент пакета, а предоставление пользователю возможности немедленно приступить к написанию программ, работающих с терминалом. Здесь рассматриваются только наиболее часто используемые подпрограммы, в отношении же остальных делается ссылка на curses(3X) и terminfo(4) в Справочнике программиста. Держите эту книгу под рукой на случай, если Вам нужно будет узнать подробности о какой-либо из описанных (или не описанных) здесь подпрограмм.

Для использования cursescurses/terminfo нужно быть знакомым с языком программирования C, так как подпрограммы пакета написаны именно на нем. Кроме того, необходимо знать стандартный пакет средств ввода/вывода системы UNIX для языка C [см. stdio(3S)]. Вы сможете создавать разнообразные программы для работы с терминалом, пользуясь этими знаниями и пониманием принятого в системе UNIX принципа опоры на работу, уже сделанную другими.

Данная глава делится на пять разделов:

1. Введение
   В этом разделе кратко описываются curses, terminfo и другие компоненты пакета подпрограмм для работы с терминалом.
2. Использование подпрограмм пакета curses
   В этом разделе описываются основные подпрограммы, составляющие библиотеку curses(3X). Рассказывается о подпрограммах вывода на экран, чтения с экрана, построения окон. Описываются также подпрограммы, реализующие более сложные функции - линейную графику, использование терминальных программируемых меток, работу с несколькими терминалами одновременно. Приводится множество примеров, демонстрирующих эффективность использования этих подпрограмм.
3. Использование подпрограмм пакета terminfo
   В этом разделе описываются те подпрограммы пакета curses, которые непосредственно взаимодействуют с базой данных terminfo для реализации таких возможностей, как программируемые функциональные клавиши.
4. Использование базы данных terminfo
   В этом разделе описывается база данных terminfo, соответствующие средства поддержки и их взаимодействие с библиотекой curses.
5. Примеры программ, работающих с curses
   В этом разделе приведены тексты шести программ, иллюстрирующие использование подпрограмм пакета curses.

1. ВВЕДЕНИЕ

1.1. Что такое curses?

Curses(3X) - это библиотека подпрограмм, которые используются для разработки программ, осуществляющих ввод/вывод на экран терминала в системе UNIX. Эти подпрограммы являются функциями C или макросами. Многие из них напоминают подпрограммы из стандартной библиотеки языка C. Например, имеется подпрограмма printw(), весьма похожая на printf(3S) и подпрограмма getch(), подобная getc(3S). В Вашем банке программа - автоматический кассир может использовать printw() для вывода меню и getch() для приема Ваших запросов на изъятие сумм (или, что даже лучше, на их вклад). Экранный текстовый редактор - такой, например, как редактор vi(1) системы UNIX, также может использовать эти и другие подпрограммы пакета curses.

Название curses принято из-за того, что данная библиотека подпрограмм оптимизирует движение курсора, то есть минимизирует это движение в процессе обновления экрана. Например, если (используя подпрограммы пакета curses) Вы разработали текстовый редактор и редактируете фразу

       curses/terminfo - отличный пакет для работы с экраном

так, чтобы она читалась:

       curses/terminfo -   лучший пакет для работы с экраном

то программа выведет только 'лучший' вместо 'отличный', остальные символы останутся без изменений. Оптимизация управления курсором называется еще оптимизацией вывода, поскольку минимизируется объем передаваемых данных, то есть вывод.

При оптимизации управления курсором запись на экран производится таким способом, который соответствует терминалу, с которым работает программа, использующая пакет curses. Таким образом, библиотека curses позволяет делать все необходимое на терминалах различных типов. Подпрограммы пакета просматривают базу данных terminfo (подробно описывается ниже), чтобы найти подходящее описание терминала.

Чем будет полезна оптимизация управления курсором Вам и тем, кто будет пользоваться Вашими программами? Во-первых, она сэкономит Ваше время, затрачиваемое на описание того, как именно Вы хотите изменять содержимое экрана. Во-вторых, она сохранит время пользователя за счет уменьшения времени, необходимого для переписывания экрана. В-третьих, она уменьшит загрузку линий связи системы UNIX в период обновления экрана. В-четвертых, Вам не придется задумываться об огромном количестве терминалов, на которых Ваша программа, быть может, будет работать.

Далее приводится текст простой программы, работающей с curses. Она обращается к нескольким подпрограммам curses для того, чтобы передвинуть курсор на середину экрана и вывести цепочку символов BullsEye. Все эти подпрограммы описываются в следующем разделе, который называется Использование подпрограмм пакета curses. Чтобы понять, что делают эти подпрограммы, Вам достаточно взглянуть на их имена.

       #include <curses.h>
       
       main ()
       {
         initscr ();
         move (LINES/2 - 1, COLS/2 - 4);
         addstr ("Bulls");
         refresh ();
         addstr ("Eye");
         refresh ();
         endwin ();
       }

1.2. Что такое terminfo?

• Группу подпрограмм из библиотеки curses, которые управляют некоторыми терминальными функциями. Например, Вы можете использовать их для написания фильтров, или для программирования функциональной клавиатуры, если она на Вашем терминале программируемая. Подпрограммами terminfo могут пользоваться как те программисты, которые пишут на C, так и те, которые работают в shell'е.
  
• Базу данных, содержащую описания многих типов терминалов, с которыми могут работать программы, если они используют curses. Эти описания содержат характеристики терминала и то, как терминал выполняет различные операции, - например, сколько строк и столбцов отображается на экране, как интерпретируются управляющие символы и т.п. Описание каждого терминала компилируется в отдельный файл. Вам следует использовать язык, описываемый в terminfo(4), для создания таких файлов, и команду tic(1M) для их компиляции. Скомпилированные файлы обычно находятся в каталогах /usr/lib/terminfo/?. Эти каталоги имеют имена, состоящие из одного символа - первой буквы названия терминала. Например, описание терминала AT&T Teletype 5425 обычно находится в файле /usr/lib/terminfo/a/att5425.

Далее приводится простая командная процедура, использующая базу данных terminfo.

       # Очистить экран и показать позицию 0,0
       #
       tput clear
       tput cup 0 0     # или tput home
       echo "<- это позиция 0 0"
       #
       # Показать позицию 5,10
       #
       tput cup 5 10
       echo "<- это позиция 5 10"

1.3. Взаимодействие curses и terminfo

Подпрограммы пакета curses извлекают из базы данных terminfo информацию о том типе терминала, на котором программа выполняется. В дальнейшем этот терминал мы будем называть текущим терминалом.

Предположим, что программа, текст которой приведен в конце раздела Что такое curses?, выполняется на терминале AT&T Teletype 5425. Чтобы отработать должным образом, то есть вывести BullsEye в центр экрана, программа должна иметь информацию о количестве строк и столбцов на экране. Эти данные хранятся в описании терминала AT&T Teletype 5425 в базе данных terminfo. Чтобы получить их, программе, работающей с curses, достаточно знать только название терминала, на котором она выполняется. Можно передать ей это название, поместив его в переменную окружения $TERM при подключении к системе UNIX, или путем присвоения значения и помещения в окружение переменной $TERM в Вашем файле .profile [см. profile(4)]. Располагая значением $TERM, программа, использующая curses, может извлечь описание текущего терминала из базы данных terminfo.

Пусть, например, в .profile включены следующие строки:

       TERM=5425
       export TERM
       tput init

Как было сказано выше, пакет управления терминалом обычно называют curses/terminfo. Однако, в нем есть и другие компоненты, из которых мы уже упомянули, в частности, tic(1M). Далее приводится полный список компонент, рассматриваемых в этом руководстве:

См. также profile(4), scr_dump(4), term(4) и term(5). Более подробную информацию об этих компонентах см. в Справочнике программиста и Справочнике пользователя.

2. ИСПОЛЬЗОВАНИЕ ПОДПРОГРАММ ПАКЕТА CURSES

В этом разделе рассматриваются основные подпрограммы пакета curses, которые используются при создании интерактивных терминальных программ. В начале раздела описаны подпрограммы (и другие компоненты), которые нужны для нормальной работы любой программе, работающей с пакетом (в дальнейшем мы для краткости будем иногда называть такие программы curses-программами). В оставшейся части раздела рассказывается о том, как компилировать и выполнять такую программу. Наконец, описываются наиболее часто применяемые подпрограммы, которые делают следующее:

• Осуществляют ввод и вывод данных на экран терминала.
• Управляют вводом и выводом данных - например, подсвечивают выводимые данные или подавляют отображение вводимых символов на экране ("эхо").
• Работают с несколькими образами экрана (окнами).
• Выполняют простые графические функции.
• Управляют программируемыми метками на экране терминала.
• Осуществляют ввод/вывод, работая одновременно с несколькими терминалами.

В файле <curses.h> определяются несколько глобальных переменных и структур данных, а также те из подпрограмм пакета, которые в действительности являются макросами.

Начнем с рассмотрения определяемых в файле переменных и структур данных. В файле <curses.h> определены параметры всех подпрограмм, входящих в пакет curses. Кроме того, определяются целочисленные переменные LINES и COLS, которым при выполнении программы назначаются значения соответственно вертикального и горизонтального размера экрана. Это делается при вызове описываемой ниже подпрограммы initscr(). В файле определяются также константы OK и ERR. Большинство подпрограмм curses возвращают OK при нормальном завершении и ERR при возникновении ошибки.

Примечание

Рассмотрим теперь макроопределения. Многие подпрограммы curses определены в <curses.h> как макросы, которые обращаются к другим подпрограммам и макросам из curses. Например, refresh() является макросом. Определение

       #define refresh() wrefresh(stdscr)

показывает, что вызов refresh расширяется в обращение к также входящей в curses подпрограмме wrefresh(). Эта последняя, в свою очередь, вызывает две другие подпрограммы curses: wnoutrefresh() и doupdate(). Многие подпрограммы обеспечивают нужный результат, группируя два-три обращения к другим.

Предостережение

Подпрограммы initscr(), refresh() и endwin() приводят терминал в состояние "работа с curses", обновляют содержимое экрана и восстанавливают терминал в состоянии "вне curses" соответственно. Для уяснения действия каждой из этих подпрограмм воспользуемся еще раз нашим простым примером.

       #include <curses.h>
       
       main ()
       {
         initscr ();     /* Инициализируем терминал и
                            переменные и структуры данных
                            из <curses.h> */
         move (LINES/2 - 1, COLS/2 - 4);
         addstr ("Bulls");
         refresh ();     /* Выводим данные на экран
                            терминала */
         addstr ("Eye");
         refresh ();     /* Выводим еще на экран
                            терминала */
         endwin ();      /* Восстанавливаем состояние
                            терминала */
       }

Curses-программа начинается обычно с вызова initscr(); это достаточно сделать один раз. Подпрограмма initscr() определяет тип терминала, на котором выполняется программа, по значению переменной окружения $TERM, как это описано в разделе Взаимодействие curses и terminfo. Затем подпрограмма инициализирует все переменные и структуры данных, описанные в файле <curses.h>. initscr() присваивает переменным LINES и COLS значения, соответствующие терминалу, на котором выполняется программа. Например, если используется Teletype 5425, она присвоит значение 24 переменной LINES, а значение COLS станет равным 80. Если возникает ошибка, подпрограмма записывает сообщение об этом в stderr и завершает работу.

Ввод/вывод при выполнении программы производится подпрограммами, подобными использующимся в примере move() и addstr(). Например,

       move (LINES/2 - 1, COLS/2 - 4);

требует перемещения курсора в точку, находящуюся несколько левее центра экрана. Затем

       addstr ("Bulls");

Внимание!

При вызове подпрограмм типа move() и addstr() содержимое физического экрана терминала не меняется. Экран обновляется только при вызове refresh(). До такого вызова изменяется только внутреннее представление экрана, которое называется окном. Эту весьма важную концепцию мы обсудим далее в разделе Еще об окнах и подпрограмме refresh().

Компилируйте такую программу, как обычную программу на языке C, командой cc(1) (см. Справочник программиста), которая вызывает компилятор языка C.

Подпрограммы обычно хранятся в библиотеке /usr/lib/libcurses.a. Чтобы редактор внешних связей просматривал эту библиотеку, в команде cc необходимо указать опцию -l.

Общий формат командной строки для компиляции программы, работающей с curses, таков:

       cc файл.c -lcurses -o файл

В процессе своей работы подпрограммы curses опираются на информацию из окружения пользователя. В частности, пользователю такой программы обычно нужно включить в свой файл .profile следующие три строки:

       TERM=тип_текущего_терминала
       export TERM
       tput init

Смысл этих строк объясняется в разделе Взаимодействие curses и terminfo. Пользователи curses-программы могут, кроме того, установить в файле .profile значения переменных окружения $LINES, $COLUMNS и $TERMINFO, однако, в отличие от случая с $TERM, делать это не обязательно.

Если Ваша curses-программа не работает должным образом, Вы, возможно, попытаетесь ее отладить с помощью sdb(1), как это описывается в Справочнике программиста. Пользуясь sdb, нужно учитывать ряд обстоятельств. Во-первых, curses-программа интерактивна и контролирует положение курсора. Однако, интерактивный отладчик, подобный sdb, может произвести на экране изменения, о которых не будет знать отлаживаемая программа.

Во-вторых, программа, работающая с curses, выводит в окно до тех пор, пока не будет вызвана refresh() или подобная ей подпрограмма. В связи с такой задержкой вывода на экран, отладка его правильности может быть затруднена.

2.5. Еще об окнах и подпрограмме refresh( )

Как указывалось ранее, подпрограммы curses не обновляют экран, пока не будет вызвана refresh(). Когда refresh() вызывается, все данные, накопленные для вывода, пересылаются на экран текущего терминала.

Эффект использования окна во многом подобен эффекту использования буфера при работе с редактором системы UNIX. Например, когда Вы редактируете файл при помощи vi(1), все изменения содержимого файла отражаются в буфере, а сам файл изменяется только после выдачи команд w или zz. Аналогично, когда Вы вызываете программу, работающую с экраном через пакет curses, изменяется содержимое окна, а сам экран терминала перерисовывается только при вызове refresh(). В <curses.h> содержится описание принятого по умолчанию окна stdscr (стандартное окно), размеры которого совпадают с размерами экрана терминала. В <curses.h> stdscr имеет тип WINDOW*, указатель на структуру языка C, которую пользователь может представлять себе в виде двумерного массива символов, соответствующего экрану терминала. Программа всегда отслеживает как состояние stdscr, так и состояние физического экрана. refresh(), когда вызывается, сравнивает их и посылает на терминал последовательность символов, приводящий его экран в соответствующий содержимому stdscr вид. При этом выбирается один из многих способов сделать это, с учетом характеристик терминала и возможного сходства того, что есть на экране и того, что содержится в окне. Выходной поток оптимизируется таким образом, чтобы он содержал как можно меньше символов. На рисунке ниже показано, что происходит при работе программы, выводящей BullsEye в центре экрана (см. раздел Что такое curses?). Обратите внимание, что, какой бы мусор ни был на экране, он там и останется, пока не будет вызвана refresh(). При этом вызове экран очищается и заполняется текущим содержимым stdscr.

Вместо stdscr Вы можете создавать и использовать другие окна. Окна полезны для одновременного ведения нескольких образов экрана. Например, во многих приложениях для ввода и вывода данных используются два окна: одно для ввода/вывода собственно данных, а другое - для вывода сообщений об ошибках, чтобы эти сообщения не портили содержимое основного окна.

Можно разделить экран на большое количество окон, обновляя по желанию то или иное из них. Если окна перекрываются, на экран выводится содержимое того окна, которое обновлялось позже. Можно также создать одно окно внутри другого (первое мы будем иногда называть подокном). Допустим, разрабатываемое Вами приложение использует в качестве интерфейса с пользователем экранные формы, например, для изображения на экране расписки. Тогда можно использовать меньшие, находящиеся внутри основного, окна для управления доступом к отдельным полям такой формы.

Некоторые подпрограммы пакета curses предназначены для работы с окнами особого типа, которые мы будем называть спецокнами. Спецокно - это такое окно, размер которого не ограничивается размером экрана и которое не связано с каким-либо определенным местом на экране. Их можно применять, если Вам нужны очень большие окна, или же такие, которые нужно отображать на экран частями. Спецокна могут, например, понадобиться при работе с электронными таблицами.

Ниже показаны взаимосвязи между несколькими окнами, подокнами и спецокнами и экраном терминала.

2.6.1. Вывод

curses содержит подпрограммы для записи в stdscr, похожие на подпрограммы из stdio(3S) для записи в файл. Они позволяют:

• Выводить одиночный символ - addch().
• Выводить цепочку символов - addstr().
• Форматировать строку из нескольких входных аргументов - printw().
• Перемещать курсор, возможно, с одновременным выводом символа (символов) - move(), mvaddch(), mvaddstr(), mvprintw().
• Очистить весь экран или его часть - clear(), erase(), crltoeol(), clrtobot().

Далее следуют описания и примеры применения этих подпрограмм.

Предостережение

addch( )

#include <curses.h>
       
int addch (ch)
chtype ch;

    #include <curses.h>
       
    main ()
    {
      initscr ();
      addch ('a');
      refresh ();
      endwin ();
    }

addstr( )

#include <curses.h>
       
int addstr (str)
char *str;

printw( )

#include <curses.h>
       
int printw(fmt [,arg...])
char *fmt;

       #include <curses.h>
       
       main ()
       {
         char *title = "Не указано";
         int no = 0;
               . . .
         initscr ();
               . . .
         printw ("%s отсутствует на складе.", title);
         printw ("Попросите кассира заказать %d для Вас.\n", no);
         refresh ();
         endwin ();
       }

move( )

#include <curses.h>
       
int move (y, x);
int y, x;

       #include <curses.h>
       
       main()
       {
         initscr ();
         addstr ("Курсор должен быть здесь -->");
         addstr (" если move () работает.");
         printw ("\n\n\nНажмите <CR> для завершения теста.");
         move (0, 28);
         refresh ();
         getch ();       /* Вводит <CR>, см. ниже */
         endwin ();
       }

clear( ), erase( )

#include <curses.h>
       
int clear ( )
       
int erase ( )

clrtoeol( ), clrtobot( )

#include <curses.h>
       
int clrtoeol ( )
       
int clrtobot ( )

       #include <curses.h>
       
       main ()
       {
         initscr ();
         addstr ("Нажмите <CR> для удаления отсюда ");
         addstr ("до конца строки и далее.");
         addstr ("\nУдалите это тоже.\nИ это.");
         move (0, 32);
         refresh ();
         getch ();
         clrtobot ();
         refresh ();
         endwin ();
       }

2.6.2. Ввод

Подпрограммы curses, предназначенные для чтения с текущего терминала, подобны тем, которые содержатся в stdio(3S) и читают из файла. Они позволяют:

• Читать символы по одному: getch().
• Читать строку, заканчивающуюся символом перевода строки: getstr().
• Сканировать вводимые символы, извлекая значения и присваивая их переменным из списка аргументов: scanw().

Первичной подпрограммой является getch(), которая обрабатывает и возвращает значение одного введенного символа. Она подобна подпрограмме getchar(3S) из библиотеки языка C, за исключением того, что она может производить некоторые зависящие от системы или терминала действия, которые не выполняет getchar(). Например, getch() можно использовать совместно с подпрограммой keypad() из библиотеки curses. Это позволяет программе распознавать и обрабатывать, как один символ, последовательности, начинающиеся с ESC, которые передаются, например, при нажатии клавиш управления курсором или функциональных клавиш. Дополнительную информацию о keypad() см. в описаниях getch() и keypad() в curses(3X).

Ниже описываются основные подпрограммы для ввода с терминала и даются примеры их использования.

getch( )

#include <curses.h>
       
int getch ( )

       #include <curses.h>
       
       main ()
       {
         int ch;
         initscr ();
         cbreak ();    /* Пояснения см. в
                           разделе "Опции ввода" */
         addstr ("Введите любой символ:  ");
         refresh ();
         ch=getch ();
         printw ("\n\n\nВы ввели '%c'.\n", ch);
         refresh ();
         endwin ();
       }

getstr( )

#include <curses.h>
       
int getstr (str)
char *str;

       #include <curses.h>
       
       main ()
       {
         char str [256];
         initscr ();
         cbreak ();   /* Пояснения см. в
                         разделе "Опции ввода" */
         addstr ("Введите строку символов,");
         addstr (" оканчивающуюся <CR>:\n\n");
         refresh ();
         getstr (str);
         printw ("\n\n\nВы ввели \n'%s'\n", str);
         refresh ();
         endwin ();
       }

scanw( )

#include <curses.h>
       
int scanw (fmt [,arg...])
char *fmt;

       include <curses.h>
       
       main ()
       {
         char string [100];
         float number;
         initscr ();
         cbreak ();  /* Пояснения см.
                        в разделе "Опции ввода" */
         echo ();
         addstr ("Введите число и текст,");
         addstr (" разделенные запятой:");
         refresh ();
         scanw ("%f,%s", &number, string);
         clear ();
         printw ("Вы ввели текст \"%s\" и число %f.",
                  string, number);
         refresh ();
         endwin ();
       }

2.7. Управление вводом/выводом

2.7.1. Атрибуты вывода

Рассказывая об addch(), мы упомянули, что эта подпрограмма выводит в stdscr один знак типа chtype. chtype состоит из двух частей: информации о самом символе и информации о наборе атрибутов, связанных с этим символом. Эти атрибуты позволяют отображать символ с повышенной яркостью, подчеркнутым, инвертированным и т.д.

С stdscr всегда связан набор атрибутов, которые автоматически присваиваются каждому выводимому символу. Вы можете изменить текущие значения атрибутов, используя attrset() или другие подпрограммы пакета curses, которые описаны ниже. Приведем здесь список атрибутов и их описания:

• A_BLINK - мерцание.
• A_BOLD - повышенная яркость или жирный шрифт.
• A_DIM - пониженная яркость.
• A_REVERSE - инвертированное отображение.
• A_STANDOUT - как можно заметнее, насколько это возможно на данном терминале.
• A_UNDERLINE - подчеркивание.
• A_ALTCHARSET - альтернативная кодировка (см. раздел Линии на экране и прочая графика).

Эти атрибуты можно передавать в качестве аргумента подпрограмме attrset() или ей подобным. Им можно передавать комбинации атрибутов, объединенные операцией дизъюнкции (|).

Примечание

Рассмотрим использование одного из этих атрибутов. Следующий фрагмент программы обеспечивает отображение слова с повышенной яркостью:

          . . .
         printw ("Яркое ");
         attrset (A_BOLD);
         printw ("слово");
         attrset (0);
         printw (" бросается в глаза.\n");
          . . .
         refresh ();

Атрибуты можно включать по одному, как в примере: attrset (A_BOLD), или в комбинации. Например, чтобы вывести яркий мерцающий текст, Вы можете использовать attrset (A_BOLD | A_BLINK). Те или иные атрибуты включаются и выключаются подпрограммами attron() и attroff() без какого-либо влияния на остальные атрибуты отображения. attrset (0) отключает все атрибуты.

Заметьте, что в набор атрибутов входит A_STANDOUT, который можно применять для привлечения внимания пользователя. Для физической реализации этого атрибута используется наиболее визуально выразительный способ отображения, возможный на данном терминале. Обычно это повышенная яркость или инверсия. Если нужно просто выделить часть текста, все равно, подсветкой, инверсией или как-либо еще, лучше использовать A_STANDOUT. Для его включения и выключения удобны функции standout() и standend() соответственно. Фактически, standend() отключает все атрибуты. Кроме перечисленных атрибутов, имеется еще две битовые маски, а именно A_CHARTEXT и A_ATTRIBUTES. Их можно использовать для извлечения только символа или только атрибутов из значения, возвращаемого входящей в curses функцией inch(), путем их конъюнкции (операция & языка C) с этим значением. См. описание inch() в curses(3X).

Приведем описание attrset() и других подпрограмм curses, которые используются для управления атрибутами вывода.

attron( ), attroff( ), attrset( )

#include <curses.h>
       
int attron (attrs)
chtype attrs;
       
int attrset (attrs)
chtype attrs;
       
int attroff (attrs)
chtype attrs;

standout( ), standend( )

#include <curses.h>
       
int standout ( )
       
int standend ( )

2.7.2. Звонки, свист, вспышки

Иногда бывает нужно привлечь внимание пользователя. Для этого в пакет curses включены две подпрограммы, которые могут заставить терминал звенеть, а его экран - вспыхивать.

flash() заставляет экран терминала вспыхнуть, если это возможно, если же нет - включает звуковой сигнал. Вспышка является альтернативой звуковому сигналу и особенно полезна, когда звук мешает кому-либо, сидящему неподалеку от терминала. Подпрограмма beep() вызывается, когда нужно подать звуковой сигнал (если это почему-либо невозможно на данном терминале, beep() пытается произвести вспышку).

beep( ), flash( )

#include <curses.h>
       
int flash ( )
       
int beep ( )

2.7.3. Опции ввода

Система UNIX производит множество действий с символами, вводимыми пользователем. Среди прочего, система выполняет следующее:

• Отображает вводимые символы на экране терминала (такое отображение мы будем называть эхом).
• Обрабатывает символы забоя (ERASE, обычно #) и уничтожения (KILL, обычно @).
• Интерпретирует CTRL+D как конец файла (EOF).
• Обрабатывает символы прерывания (INTR) и выхода (QUIT).
• Сбрасывает бит четности символа.
• Преобразует возврат каретки в перевод строки.

Curses полностью берет на себя управление экраном терминала, поэтому его подпрограммы отключают эхо, производимое системой UNIX, и делают его самостоятельно. Временами бывает необходимо программно отключать стандартную для системы UNIX обработку символов. Для этого предназначены некоторые подпрограммы curses, например, noecho() и cbreak(). Используя такие подпрограммы, можно управлять интерпретацией вводимых символов. В приведенной ниже таблице перечислены основные подпрограммы, предназначенные для управления режимом ввода.

Если программа использует curses и вводит с терминала, она должна установить некоторые опции ввода. Это связано с тем, что при старте программы терминал может оказаться в любом из режимов cbreak(), raw(), nocbreak(), или noraw(). Как показано в таблице, при запуске программы гарантируется только наличие режима echo().

Как правило, в интерактивной терминальной программе используются комбинация режимов noecho() и cbreak(). Пусть, например, нужно отображать вводимые символы не там, где находится курсор, а в нижней строке экрана. Для этого предназначена подпрограмма noecho(). Однако, хотя noecho() и подавляет отображение вводимых символов, символы забоя и уничтожения обрабатываются обычным образом. Для отключения этого режима используется подпрограмма cbreak().

Предостережение

Помимо подпрограмм, перечисленных в таблице, для управления вводом используются следующие подпрограммы curses: noraw(), halfdelay(), nodelay(). Они обсуждаются в curses(3X).

Далее подробнее описываются подпрограммы noecho(), cbreak() и связанные с ними echo() и nocbreak().

echo( ), noecho( )

#include <curses.h>
       
int echo ( )
       
int noecho ( )

cbreak( ), nocbreak( )

#include <curses.h>
       
int cbreak ( )
       
int nocbreak ( )

2.8. Работа с окнами

Для ввода и вывода данных в окна и спецокна используются подпрограммы, похожие на те, которые работают с stdscr. Единственная разница состоит в том, что необходимо указать окно, к которому относится операция. Как правило, имена этих подпрограмм получаются путем добавления буквы w в начало названия соответствующей подпрограммы для stdscr, а также имени окна в качестве первого параметра. Например, если нужно вывести символ c в окно mywin, addch ('c') превращается в waddch (mywin,'c'). Далее приводится список работающих с окнами подпрограмм, соответствующих тем, которые были описаны в разделе Несложный ввод/вывод.

       waddch (win, ch)

       mvwaddch (win, y, x, ch)

       waddstr (win, str)

       mvwaddstr (win, y, x, str)

       wprintw (win, fmt[,arg...])

       mvwprintw (win, y, x, fmt[,arg...])

       wmove (win, y, x)

       wclear (win)
       
       werase (win)

       wclrtoeol (win)
       
       wclrtobot (win)

       wrefresh (win)

Как видно из описаний, эти подпрограммы отличаются от тех, которые работают с stdscr, только своими именами и добавлением аргумента win. Заметьте, что у подпрограмм, чьи имена начинаются на mvw, аргумент win предшествует координатам y, x, хотя, судя по их именам, следовало бы ожидать обратного. См. в curses(3X) дополнительные данные об этих подпрограммах, вариантах подпрограмм getch(), getstr() и другую информацию, касающуюся работы с окнами.

Как было сказано ранее, подпрограмма refresh() пересылает данные с stdscr на экран терминала. refresh() является макросом, который расширяется в wrefresh (stdscr), о чем также упоминалось в разделах Что нужно программе для работы с curses и Еще об окнах и подпрограмме refresh().

Подпрограмма wrefresh() предназначена для пересылки данных из окна (будь то stdscr или созданное пользователем) на экран терминала; она вызывает подпрограммы wnoutrefresh() и doupdate(). Аналогичным образом, prefresh() пересылает данные из спецокна на экран, обращаясь к pnoutrefresh() и doupdate().

Пользуясь wnoutrefresh() или pnoutrefresh() (здесь мы для простоты рассмотрим только первую из них) и doupdate(), Вы можете обновлять экран с большей эффективностью, чем обращаясь к wrefresh(). wrefresh() сначала вызывает wnoutrefresh(), которая копирует указанное окно в структуру данных, называемую виртуальным экраном. Виртуальный экран содержит то, что программа собирается вывести на терминал. Вызвав wnoutrefresh(), wrefresh() затем обращается к doupdate(), которая сравнивает виртуальный экран с физическим и производит обновление последнего. Если Вы хотите отобразить содержимое сразу нескольких окон, вызовы wrefresh() приведут к нескольким обращениям к wnoutrefresh() и doupdate(), то есть к нескольким актам вывода данных на экран. Однако, вызвав wnoutrefresh() для каждого окна, а затем один раз doupdate(), можно уменьшить общее количество передаваемых символов и необходимого для передачи времени процессора. Нижеследующая программа использует doupdate() лишь однажды.

       #include <curses.h>
       
       main ()
       {
         WINDOW *w1, *w2;
         initscr ();
         w1 = newwin (2, 6, 0, 3);
         w2 = newwin (1, 4, 5, 4);
         waddstr (w1, "Bulls");
         wnoutrefresh (w1);
         waddstr (w2, "Eye");
         wnoutrefresh (w2);
         doupdate ();
         endwin ();
       }

         w1 = newwin (2, 6, 0, 3);
         w2 = newwin (1, 4, 5, 4);

объявляют два окна, которые называются w1 и w2, передавая некоторые описания подпрограмме newwin(), которая подробнее описана ниже. Ниже показано действие wnoutrefresh() и doupdate() на эти два окна и на виртуальный и физический экраны.

2.8.3. Новые окна

newwin( )

#include <curses.h>
       
WINDOW *newwin (nlines, ncols, begin_y, begin_x)
int nlines, ncols, begin_y, begin_x;

#include <curses.h>
       
WINDOW *subwin (orig, nlines, ncols, begin_y, begin_x)
WINDOW *orig;
int nlines, ncols, begin_y, begin_x;

       #include <curses.h>
       
       main()
       {
         WINDOW *sub;
       
         initscr ();
         box (stdscr, 'w', 'w');  /* О box() см. curses(3X) */
         mvaddstr (stdscr, 7, 10, "------- это 10,10");
         mvaddch (stdscr, 8, 10, '');
         mvaddch (stdscr, 9, 10, 'v');
         sub = subwin (stdscr, 10, 20, 10, 10);
         box (sub, 's', 's');
         wnoutrefresh (stdscr);
         wrefresh (sub);
         endwin ();
       }

Умея пользоваться основными подпрограммами curses для ввода/вывода на экран и управления окнами, можно создавать терминальные программы, удовлетворяющие потребности большинства пользователей. Вместе с тем, в curses имеются подпрограммы, которые позволяют делать больше, чем просто вводить и выводить символы и работать с окнами. На следующих нескольких страницах кратко описываются некоторые из этих подпрограмм, которые помогут Вам выводить простые графические изображения, использовать программируемые метки терминала и обращаться из одной программы к нескольким терминалам.

Прежде, чем использовать эти возможности, следует освоить подпрограммы ввода/вывода и управления окнами, которые были рассмотрены выше в этой главе, а также в руководстве curses(3X).

Предостережение

2.9.1. Линии на экране и прочая графика

Многие терминалы поддерживают альтернативную кодировку для простых графических изображений (графические символы, или глифы). Этим набором символов можно пользоваться и в программах, работающих с curses. В curses используются те же названия глифов, что и в графическом наборе символов VT100.

Для работы с альтернативной кодировкой в curses-программе, необходимо передать подпрограмме waddch() (или подобной) последовательность символов, чьи имена начинаются с ACS_. Например, ACS_ULCORNER - это переменная для символа, изображающего левый верхний угол. Если терминал поддерживает этот символ, то в ACS_ULCORNER будет результат операции ИЛИ (|) соответствующего значения и битной маски A_ALTCHARSET. Если такого графического символа нет, используется символ из стандартного набора ASCII, аппроксимирующий требуемое изображение. Например, для аппроксимации ACS_HLINE, горизонтальной черты, используется - (знак минус). Если близкая аппроксимация невозможна, используется +, знак плюс. Все стандартные имена ACS_ и аппроксимирующие их символы перечислены в curses(3X).

Мы приведем часть текста программы, которая использует графические символы. В примере вызывается подпрограмма box(), входящая в пакет curses, для того, чтобы окружить меню на экране рамкой. По умолчанию box() использует графические символы, но по выбору пользователя может рисовать знаками и - [см. curses(3X)]. Если меню, изображенное в рамке, имеет продолжение вверх или вниз за пределы рамки, то для указания этого выводятся стрелки соответственно вверх или вниз (ACS_UARROW и ACS_DARROW).

         box (menuwin, ACS_VLINE, ACS_HLINE);
                    ...
         /* Вывод стрелок вверх/вниз */
         wmove (menuwin, maxy, maxx - 5);
       
         /* вывод стрелки вверх или горизонтальной черты */
         if (moreabove)
           waddch(menuwin, ASC_UARROW);
         else
           waddch (menuwin, ACS_HLINE);
       
         /* вывод стрелки вниз или горизонтальной черты  */
         if (morebelow)
           waddch (menuwin, ASC_DARROW);
         else
           waddch (menuwin, ACS_HLINE);

Приведем еще один пример. Поскольку символ для стрелки вниз (например, строчная v) не очень выделяется на экране, если на нем много строчных букв, этот символ можно заменить на прописную V.

         if ( ! (ACS_DARROW & A_ALTCHARSET))
           ACS_DARROW = 'V';

Большинство терминалов поддерживает программируемые метки в нижней части своего экрана. На клавиатуре этим меткам обычно соответствует функциональные клавиши. Меток обычно восемь, каждая длиной в восемь знаков и высотой в одну-две строки.

Библиотека curses содержит подпрограммы, поддерживающие единую модель из восьми программируемых меток. Если терминал их не имеет, нижняя строка его экрана превращается в область программируемых меток. Для использования в curses-программах таких меток, нет необходимости иметь на клавиатуре соответствующие им функциональные клавиши.

Далее кратко описываются большинство подпрограмм curses, применяющихся при работе с программируемыми метками: slk_init(), slk_set(), slk_refresh(), slk_noutrefresh(), slk_clear() и slk_restore().

Если Вы пользуетесь программируемыми метками в curses-программе, Вам необходимо перед initscr() вызвать подпрограмму slk_init(). При этом устанавливается внутренний флаг, указывающий initscr(), что программируемые метки используются. Если initscr() обнаружит, что программируемые метки отсутствуют на терминале, либо их меньше восьми, либо их длина менее восьми символов, она удаляет нижнюю строку stdscr, чтобы использовать ее для размещения программируемых меток. При этом размер stdscr и значение переменной LINES уменьшается на единицу. Разумно написанная программа, использующая переменные LINES и COLS, будет выполняться правильно, как если бы этой строки вообще не было бы на экране.

slk_init() имеет один аргумент, определяющий способ размещения меток на экране в случае использования для этого строки из stdscr. Выбор возможен между размещением группами 3-2-3, как это принято на терминалах AT&T, либо 4-4, как на терминалах Хьюлетт-Паккард. Подпрограммы curses определяют положение и размер меток в соответствии с указанным способом, причем максимально возможная длина метки - восемь символов.

Подпрограмма slk_set() имеет три аргумента: номер метки (1-8), текст, помещаемый в метку (не более восьми символов), выравнивание этого текста в поле метки (0 - выравнивание влево, 1 - центрирование, 2 - выравнивание вправо).

Подпрограмма slk_noutrefresh() подобна wnoutrefresh() тем, что она обновляет содержимое внутреннего образа экрана, но не выводит данные на реальный экран. Поскольку после ее вызова обычно вызывают wrefresh(), именно slk_noutrefresh(), как правило, используется для вывода меток на экран терминала.

Подобно тому, как wrefresh() эквивалентна последовательным вызовам wnoutrefresh() и doupdate(), подпрограмма slk_refresh() эквивалентна последовательным вызовам slk_noutrefresh() и doupdate().

Curses-программа может выводить данные сразу на несколько терминалов. Это может оказаться полезным при разработке программ, которые представляют собой один процесс и обращаются к одной базе данных, например, игр для нескольких участников.

Писать программы, работающие с несколькими терминалами, - дело нелегкое, и подпрограммы curses не решают всех возникающих при этом проблем. Например, сами программы, а не подпрограммы библиотеки, должны определять имена файлов для терминалов и типы этих терминалов. Стандартный способ с использованием переменной окружения $TERM не срабатывает, поскольку каждый процесс может знать только о своем собственном окружении.

Другая проблема возникает, когда несколько программ пытаются читать данные с одного и того же терминала. Следует избегать ситуации, когда программы перехватывают данные друг у друга. В то же время, программа, которая пытается занять дополнительный терминал, не должна просто прерывать программу, которая уже работает на нем. (Обычно это также неприемлемо из соображений безопасности, но бывают случаи, когда это может оказаться полезным, например, если терминал не используется, либо для разработки программ связи между терминалами). Типичным решением проблемы является запуск каждым пользователем программы, уведомляющей главную программу о желании с ней работать и передающей главной программе идентификатор процесса уведомляющей программы, имя линии и тип используемого терминала. Затем уведомляющая программа переходит в неактивное состояние до окончания работы главной. Перед своим завершением, главная программа активизирует все уведомляющие программы, после чего все они завершаются.

Концепция работы curses со многими терминалами заключается в поддержании текущего терминала. Все обращения к подпрограммам относятся к этому текущему терминалу. Главная программа должна описать каждый терминал и сохранить ссылку на него в своих переменных. Когда программе нужно работать с некоторым терминалом, ей следует установить его в качестве текущего и вызывать обычные подпрограммы curses.

Ссылки на терминал в curses-программе имеют тип *SCREEN. Новый терминал инициализируется путем обращения к newterm (type, outfd, infd). newterm возвращает указатель на новый терминал, type - это цепочка символов, содержащая тип используемого терминала. outfd является указателем на файл [*FILE, stdio(3S)], который используется для вывода на терминал, а infd указывает на файл для ввода с терминала. Вызов newterm() заменяет обычное обращение к initscr(), которое расширяется в newterm (getenv ("TERM"), stdout, stdin).

Для изменения текущего терминала необходимо вызвать set_term (sp), где sp указывает на терминал, который должен стать текущим. set_term() возвращает указатель на терминал, который был текущим на момент ее вызова.

Важно понять, что каждый терминал будет иметь свои собственные режимы работы и окна. Каждый терминал должен быть проинициализирован соответствующим вызовом newterm(). Для каждого терминала отдельно должны быть установлены режимы работы, например, cbreak() или noecho(). Равным образом для каждого терминала отдельно должны вызываться endwin() и refresh(). Ниже изображен типичный сценарий рассылки сообщения на несколько терминалов.

         for (i=0; i<nterm; i++) {
           set_term (terms[i]);
           mvaddstr (0, 0, "Важное сообщение");
           refresh ();
         }

Более подробный пример см. в программе two раздела Примеры программ, работающих с curses.

3. ИСПОЛЬЗОВАНИЕ ПОДПРОГРАММ ПАКЕТА TERMINFO

Иногда могут понадобиться подпрограммы более низкого уровня, чем те, которые предлагает пакет curses. Такие подпрограммы содержатся в пакете terminfo. Они не работают непосредственно с экраном терминала, а дают пользователю возможность узнать значения характеристик терминала и последовательности символов, которые терминалом управляют.

Подпрограммы terminfo полезно использовать в трех случаях. Вопервых, если Вам нужны только некоторые возможности терминала, например, выделение текста на экране. Во-вторых, если нужно написать фильтр. Типичный фильтр только преобразует входной поток, без очистки экрана или перемещения курсора. Если вид преобразования зависит от терминала, и экран не должен очищаться, то стоит воспользоваться подпрограммами terminfo. В-третьих, если Вы пишете специальную программу для посылки специальной строки на терминал, например, для программирования функциональной клавиатуры, установки позиций табуляции, передачи данных на принтер, или для работы со строкой состояния. За исключением этих трех случаев, Вам лучше не пользоваться подпрограммами terminfo: curses содержит подпрограммы более высокого уровня, использование которых повысит степень переносимости Ваших программ на другие системы UNIX и другие терминалы.

Примечание

3.1. Что нужно программе для работы с terminfo

Как правило, программа, работающая с terminfo, включает файлы и подпрограммы, которые перечислены ниже:

       #include <curses.h>
       #include <term.h>
        . . .
         setupterm ((char*) 0, 1, (int*) 0);
          . . .
         putp (clear_screen);
          . . .
         reset_shell_mode ();
         exit (0);

Файлы <curses.h> и <term.h> нужны, поскольку они содержат определения текстовых объектов, чисел и флагов, которые используются подпрограммами terminfo. setupterm() занимается инициализацией. Передача ей значений (char*) 0, 1 и (int*) 0 обеспечивает установку разумных режимов. Если setupterm() не может распознать тип используемого терминала, она выводит сообщение об ошибке и завершается. reset_shell_mode() делает примерно то же, что и endwin(), и должна вызываться перед завершением terminfo-программы. При вызове setupterm() определяются значения глобальных переменных, например clear_screen. Их значения могут быть выведены на экран входящими в terminfo подпрограммами putp() или tputs(), что обеспечивает пользователю дополнительные возможности по контролю терминала. Такую строку не следует выводить подпрограммой printf(3S) из библиотеки языка C, поскольку в ней содержится информация об использовании символов-заполнителей. Программа, пытающаяся вывести ее таким образом, может завершиться аварийно, если терминал требует использования заполнителей, или если он использует протокол xon/xoff.

       /* Версия программы highlight уровня terminfo */
       
       #include <curses.h>
       #include <term.h>
       
       int ulmode = 0;        /* Режим подчеркивания */
       
       main (argc, argv)
       int argc;
       char **argv;
       {
         FILE *fd;
         int c, c2;
         int outch();
       
         if (argc > 2) {
           fprintf (stderr, "Откуда: termhl [file]\n");
           exit(1);
         }

         if (argc == 2) {
           fd = fopen (argv [1], "r");
           if (fd == NULL) {
             perror (argv [1]);
             exit(2);
           }
         }
         else {
           fd = stdin;
         }
         setupterm ((char*) 0, 1, (int*) 0);

         for (;;) {
           c = getc (fd);
           if (c == EOF) break ();
           if (c == '\') {
             c2 = getc (fd);
             switch (c2) {
               case 'B':
                 tputs (enter_bold_mode, 1, outch);
                 continue;
               case 'U':
                 tputs (enter_underline_mode, 1, outch);
                 ulmode = 1;
                 continue;
               case 'N':
                 tputs (exit_attribute_mode, 1, outch);
                 ulmode = 0;
                 continue;
             }
             putch (c);
             putch (c2);
           }
           else putch (c);
         }

         fclose (fd);
         fflush (stdout);
         resetterm ();
         exit (0);
       }

       /* Функция putch подобна putchar,           */
       /* но проверяет необходимость подчеркивания */
       
       putch (c)
       int c;
       {
         outch (c);
         if (ulmode && underline_char) {
           outch ('\b');
           tputs (underlihe_char, 1, outch);
         }
       }

       /* outchar передается tputs в качестве параметра      */
       /* как функция, которую нужно вызывать вместо putchar */
       
       outch (c)
       int c;
       {
         putchar (c);
       }

Познакомимся поближе с подпрограммами terminfo на примере использования функции tputs (cap, affcnt, outc) в этой программе. tputs() добавляет символы-заполнители. Некоторые терминалы имеют возможность задерживать вывод. Их описания в базе данных terminfo, быть может, содержат цепочки, подобные $<20>, что означает задержку на 20 миллисекунд (см. ниже раздел Указание характеристик терминала). tputs генерирует достаточное для задержки на это время количество символов-заполнителей.

tputs() имеет три параметра. Первый является цепочкой символов, определяющей характеристику (атрибут вывода), которую необходимо реализовать. Второй - количество затрагиваемых этим строк. (Некоторые запросы требуют добавления символов-заполнителей в количестве, зависящем от этого параметра. Например, запрос на вставку строки, insert_line, может привести к копированию всех строк ниже текущей, для чего нужно время, пропорциональное количеству копируемых строк. Если ни одна строка не затрагивается, в качестве affcnt используется 1. Единица вместо нуля берется для надежности, так как affcnt умножается на некоторый интервал времени, а умножение чего-либо на 0 дает 0). Третий параметр - это подпрограмма, вызываемая для вывода каждого символа.

Для понимания желательности использования подпрограмм уровня curses вместо подпрограмм уровня terminfo (там, где это возможно), полезно обратить внимание на проверку значения underline_char в примере. Некоторые терминалы имеют управляющий символ, указывающий начало подчеркивания, и еще один символ, указывающий конец подчеркивания. Другим необходимо указание кода подчеркивания при выводе каждого символа. Программа termhl хранит значение этого режима, и, если необходимо, выводит underline_char для подчеркивания очередного символа. Из-за наличия такого рода мелких деталей, с которыми программы уровня terminfo должны разбираться самостоятельно, и предпочтительнее работать на уровне curses.

Программа termhl была написана для иллюстрации применения подпрограмм terminfo, поэтому она получилась сложнее, чем могла бы быть. Вместо непосредственного вывода enter_bold_mode, enter_underline_mode и exit_attribute_mode можно было бы использовать подпрограмму vidattr [см. curses(3X)]. Фактически, в последнем случае программа была бы более надежна, поскольку существует несколько способов изменения атрибутов вывода.

4. ИСПОЛЬЗОВАНИЕ БАЗЫ ДАННЫХ TERMINFO

База данных terminfo содержит описания многих наиболее часто применяющихся терминалов. Может, однако, оказаться, что Вы пожелаете написать curses-программу, предназначенную для выполнения на терминале, который еще не описан. В этом случае Вам придется создать его описание.

В общем случае для генерации описания терминала необходимо: