Текст книги "Основы программирования в Linux"

Автор книги: Нейл Мэтью

Соавторы: Ричард Стоунс
сообщить о нарушении

Текущая страница: 22 (всего у книги 67 страниц)

Оптимизация обновлений экрана

Как вы видели в примере из упражнения 6.4, обновление множественных окон требует некоторой ловкости, но не слишком обременительно. Но может возникнуть более серьезная проблема, если нуждающийся в обновлении терминал подключен через медленное сетевое соединение. К счастью, в наши дни с ней сталкиваются очень редко, но ее обработка настолько легка, что мы рассмотрим ее просто для полноты картины.

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

#include

int wnoutrefresh(WINDOW *window_ptr);

int doupdate(void);

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

Вложенные окна

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

#include

WINDOW *subwin(WINDOW *parent, int num_of_lines, int num_of_cols,

 int start_y, int start_x);

int delwin(WINDOW *window_to_delete);

У функции subwin почти такой же список параметров, как у функции newwin, и удаляются вложенные окна так же, как другие окна с помощью вызова delwin. Для записи во вложенные окна, как и в новые окна, вы можете применять ряд функций mvw. На самом деле большую часть времени вложенные окна ведут себя почти так же, как новые окна, но есть одно важное отличие: подокна самостоятельно не хранят отдельный набор экранных символов; они используют ту же область хранения символов, что и родительское окно, заданное при создании вложенного окна. Это означает, что любые изменения, сделанные во вложенном окне, вносятся и в лежащее в основании родительское окно, поэтому, когда подокно удаляется, экран не меняется.

На первый взгляд вложенные окна кажутся бесполезным экспериментом. Почему не изменять просто родительское окно? Основная сфера их применения – предоставление простого способа прокрутки другого окна. Потребность в прокрутке небольшой области экрана удивительно часто возникает при написании программ с использованием curses. Создав вложенное окно и прокручивая его, вы добьетесь желаемого результата.

Примечание

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

Выполните упражнение 6.5.

Упражнение 6.5. Вложенные окна

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

1. Начальная секция кода программы subscl.c инициализирует отображение базового окна с некоторым текстом:

#include

#include

#include

int main() {

 WINDOW *sub_window_ptr;

 int x_loop;

 int y_loop;

 int counter;

 char a_letter = '1';

 initscr();

 for (y_loop = 0; y_loop < LINES – 1; y_loop++) {

  for (x_loop = 0; x_loop < COLS – 1; x_loop++) {

   mvwaddch(stdscr, y_loop, x_loop, a_letter);

   a_letter++;

   if (a_letter > '9') a_letter = '1';

  }

 }

2. Теперь создайте новое подокно с прокруткой. Как рекомендовалось, вам следует перед обновлением экрана "коснуться" родительского окна:

 ub_window_ptr = subwin(stdscr, 10, 20, 10, 10);

 scrollok(sub_window_ptr, 1);

 touchwin(stdscr);

 refresh();

 sleep(1);

3. Сотрите содержимое вложенного окна, выведите в нем текст и обновите его. Прокрутка текста обеспечивается циклом:

 werase(sub_window_ptr);

 mvwprintw(sub_window_ptr, 2, 0, «%s», «This window will now scroll»);

 wrefresh(sub_window_ptr);

 sleep(1);

 for (counter = 1; counter < 10; counter++) {

  wprintw(sub_window_ptr, «%s», "This text is both wrapping and

   scrolling.");

  wrefresh(sub_window_ptr);

  sleep(1);

 }

4. Завершив цикл, удалите вложенное окно и обновите основной экран:

 delwin(sub_window_ptr);

 touchwin(stdscr);

 refresh();

 sleep(1);

 endwin();

 exit(EXIT_SUCCESS);

}

К концу программы вы увидите вывод, показанный на рис. 6.6.

Рис. 6.6

Как это работает

После присвоения указателю sub_window_ptr результата вызова subwin вы включаете прокрутку вложенного окна. Даже после удаления вложенного окна и обновления базового окна (strdcr) текст на экране не меняется, поскольку вложенное окно на самом деле откорректировало символьные данные экрана strdcr.

Дополнительная клавиатура

Вы уже познакомились с некоторыми средствами библиотеки curses для обработки клавиатурного ввода. У многих клавиатур, как минимум, есть клавиши управления курсором и функциональные клавиши. Кроме того, у многих клавиатур есть дополнительная клавиатура и другие клавиши, например, и .

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

К счастью, библиотека curses предоставляет элегантное решение для управления функциональными клавишами. Обычно в структуре terminfo для каждого терминала хранится последовательность, отправляемая каждой функциональной клавишей, и во включенном в программу файле curses.h для логических клавиш есть набор определений, начинающихся с префикса KEY_.

Когда curses стартует, преобразование последовательностей в логические клавиши отключено, и его следует включить вызовом функции keypad. Если вызов успешен, функция вернет OK, в противном случае ERR.

#include

int keypad(WINDOW *window_ptr, bool keypad_on);

Когда режим дополнительной клавиатуры включен с помощью вызова функции keypad с параметром keypad_on, равным true, библиотека curses принимает на себя обработку клавиатурных последовательностей, так что чтение с клавиатуры может вернуть не только нажатую клавишу, но и одно из определений вида KEY_ для логических клавиш.

Отметьте три незначительных ограничения, налагаемых при использовании режима дополнительной клавиатуры.

□ Распознавание escape-последовательностей требует разного времени, и многие сетевые протоколы сгруппируют символы в пакеты (что приведет к неверному распознаванию escape-последовательностей) или разделят их (что приведет к распознаванию последовательностей функциональных клавиш, как клавиши и отдельных символов). Такое поведение чаще всего наблюдается в региональных сетях (Wide-Area Network, WAN) и других медленных линиях связи. Единственный выход – попытаться запрограммировать терминалы так, чтобы они отправляли единичные уникальные символы в ответ на нажатие каждой функциональной клавиши, используемой вами, хотя это ограничит количество управляющих символов.

□ Для того чтобы библиотека curses могла отличить нажатие клавиши от клавиатурной последовательности, начинающейся с символа Esc, ей требуется ожидание в течение короткого промежутка времени. Иногда при включенном режиме дополнительной клавиатуры можно заметить легкую задержку при обработке клавиши .

□ Библиотека curses не может обрабатывать неуникальные escape-последовательности. Если у вашего терминала есть две разные клавиши, отправляющие одну и ту же последовательность, библиотека просто не будет ее обрабатывать, поскольку не может решить, какую логическую клавишу следует вернуть.

Выполните упражнение 6.6.

Упражнение 6.6. Применение дополнительной клавиатуры

Далее приведена короткая программа keypad.c, демонстрирующая применение режима дополнительной клавиатуры. После запуска программы нажмите клавишу и отметьте незначительную задержку, в течение которой программа пытается понять: Esc – это начало управляющей последовательности или просто нажатие одной клавиши,

1. Инициализировав программу и библиотеку curses, включите режим дополнительной клавиатуры:

#include

#include

#include

#define LOCAL_ESCAPE_KEY 27

int main() {

 int key;

 initscr();

 crmode();

 keypad(stdscr, TRUE);

2. Отключите отображение символов, чтобы помешать перемещению курсора при нажатии клавиш управления курсором. Экран очищается, и выводится некоторый текст. Программа ждет нажатия клавиши и до тех пор, пока не нажата клавиша или не возникла ошибка. Символ нажатой клавиши выводится на экран. Если нажатые клавиши соответствуют одной из последовательностей для дополнительной клавиатуры терминала, вместо символа выводится эта последовательность.

 noecho();

 clear();

 mvprintw(5, 5, «Key pad demonstration. Press 'q' to quit»);

 move(7, 5);

 refresh();

 key = getch();

 while (key != ERR && key i= 'q') {

  move(7, 5);

  clrtoeol();

  if ((key >= 'A' && key <= 'Z') || (key >= 'a' && key <= 'z')) {

   printw(«Key was%c», (char)key);

  } else {

   switch(key) {

   case LOCAL_ESCAPE_KEY:

    printw(«%s», «Escape key»);

    break;

   case KEY_END:

    printw(«%s», «END key»);

    break;

   case KEY_BEG:

    printw(«%s», «BEGINNING key»);

    break;

   case KEY_RIGHT:

    printw(«%s», «RIGHT key»);

    break;

   case KEY_LEFT:

    printw(«%s», «LEFT key»);

    break;

   case KEY_UP:

    printw(«%s», «UP key»);

    break;

   case KEY_DOWN:

    printw(«%s», «DOWN key»);

    break;

   default:

    printw(«Unmatched – %d», key);

    break;

   } /* switch */

  } /* else */

  refresh();

  key = getch();

 } /* while */

 endwin();

 exit(EXIT_SUCCESS);

}

Как это работает

Включив режим дополнительной клавиатуры, вы увидите, как можно распознать различные функциональные клавиши на дополнительной клавиатуре, генерирующие escape-последовательности. Вы, возможно, сумеете заметить, что распознавание клавиши немного медленнее, чем других клавиш.

Применение цвета

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

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

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

Прежде чем применять цвета в curses, нужно убедиться в том, что текущий терминал поддерживает цвета, и инициализировать подпрограммы управления цветом библиотеки curses. Для этого примените две функции: has_colors и start_color.

#include

bool has_colors(void);

int start_color(void);

Функция has_colors возвращает true, если терминал поддерживает цвета. Далее следует вызвать функцию start_color, которая вернет OK, если цветовая поддержка успешно инициализирована. После вызова start_color и инициализации цветов переменная COLOR_PAIRS принимает значение, равное максимальному количеству цветовых пар, которые может поддерживать терминал. Переменная COLORS определяет максимальное число доступных цветов, которых, как правило, восемь. Внутри компьютера числа от 0 до 63 действуют как уникальные ID для каждого из доступных цветов.

Прежде чем применять цвета как атрибуты, вы должны инициализировать цветовые пары, которые хотите использовать. Делается это с помощью функции init_pair. Обратиться к атрибутам, задающим цвет, можно с помощью функции COLOR_PAIR.

#include

int init_pair(short pair_number, short foreground, short background);

int COLOR_PAIR(int pair_number);

int pair_content(short pair_number, short *foreground, short *background);

В файле curses.h обычно определены некоторые базовые цвета, начинающиеся с префикса COLOR_. Дополнительная функция pair_content позволяет извлечь сведения о ранее определенной цветовой паре.

Для определения цветовой пары номер 1, как красный на зеленом, примените следующую строку:

init_pair(1, COLOR_RED, COLOR_GREEN);

Затем вы сможете получить доступ к этой цветовой паре, применив функцию COLOR_PAIR следующим образом:

wattron(window_ptr, COLOR_PAIR(1));

Она установит вывод в будущем на экран красных символов на зеленом фоне.

Поскольку COLOR_PAIR – это атрибут, вы можете комбинировать его с другими атрибутами. На ПК часто можно добиться на экране цветов повышенной яркости, объединив с помощью поразрядной операции OR атрибут COLOR_PAIR с дополнительным атрибутом A_BOLD:

wattron(window_ptr, COLOR_PAIR(1) | A_BOLD);

Давайте проверим эти функции в примере color.c (упражнение 6.7).

Упражнение 6.7. Цвета

1. Сначала проверьте, поддерживает ли цвета терминал, используемый программой. Если да, то инициализируйте отображение цветов:

#include

#include

#include

#include

int main() {

 int i;

 initscr();

 if (!has_colors()) {

  endwin();

  fprintf(stderr, «Error – no color support on this terminaln»);

  exit(1);

 }

 if (start_color() != OK) {

  endwin();

  fprintf(stderr, «Error – could not initialize colorsn»);

  exit(2);

 }

2. Теперь можно вывести допустимое количество цветов и цветовые пары. Создайте семь цветовых пар и выведите их по очереди на экран:

 clear();

 mvprintw(5, 5, «There are %d COLORS, and %d COLOR_PAIRS available», COLORS, COLOR_PAIRS);

 refresh();

 init_pair(1, COLOR_RED, COLOR_BLACK);

 init_pair(2, COLOR_RED, COLOR_GREEN);

 init_pair(3, COLOR_GREEN, COLOR_RED);

 init_pair(4, COLOR_YELLOW, COLOR_BLUE);

 init_pair(5, COLOR_BLACK, COLOR_WHITE);

 init_pair(6, COLOR_MAGENTA, COLOR_BLUE);

 init_pair(7, COLOR_CYAN, COLOR_WHITE);

 for (i = 1; i <= 7; i++) {

  attroff(A_BOLD);

  attrset(COLOR_PAIR(i));

  mvprintw(5 + i, 5, «Color pair %d», i);

  attrset(COLOR_PAIR(i) | A_BOLD);

  mwprintw(5 + i, 25, «Bold color pair %d», i);

  refresh();

  sleep(1);

 }

 endwin();

 exit(EXIT_SUCCESS);

}

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

Рис. 6.7

Как это работает

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

Переопределение цветов

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

#include

int init_color(short color_number, short red, short green, short blue);

Она позволяет переопределить существующий цвет (в диапазоне от 0 до COLORS) новыми значениями яркости цвета из диапазона от 0 до 1000. Такой подход немного напоминает определение цветовых характеристик в графических файлах формата GIF.

Панели

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

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

Структура панели похожа на структуру WINDOW, и все функции библиотеки curses, написанные для работы с окнами, можно применять и к панелям. Но у панелей есть и собственные функции для создания и обновления.

Панели создаются во многом так же, как и обычные окна.

#include

WINDOW *newpad(int number_of_lines, int number_of_columns);

Обратите внимание на то, что возвращаемое значение – указатель на структуру типа WINDOW, такое же, как у функции newwin. Удаляются панели, как и окна, функцией delwin.

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

#include <сurses.h>

int prefresh(WINDOW *pad_ptr, int pad_row, int pad_column, int screen_row_min, int screen_col_min, int screen_row_max, int screen_соl_max);

Функция выполняет запись области панели, начинающейся в точке (pad_row, pad_column), в область экрана, определенную от (screen_row_min, screen_col_min) до (screen_row_max, screen_col_max).

Есть и дополнительная подпрограмма pnoutrefresh. Она действует так же, как функция wnoutrefresh, обеспечивая более производительное обновление экрана.

Давайте проверим это на практике с помощью программы pad.с (упражнение 6.8).

Упражнение 6.8. Применение панели

1. В начале этой программы вы инициализируете структуру панели и затем формируете панель с помощью функции, которая возвращает указатель на нее. Вставьте символы, заполняющие структуру панели (панель на 50 символов шире и выше экрана терминала):

#include

#include

#include

int main() {

 WINDOW *pad_ptr;

 int x, y;

 int pad_lines;

 int pad_cols;

 char disp_char;

 initscr();

 pad_lines = LINES + 50;

 pad_cols = COLS + 50;

 pad_ptr = newpad(pad_lines, padcols);

 disp_char = 'a';

 for (x = 0; x < pad_lines; x++) {

  for (у = 0; у < pad_cols; y++) {

   mvwaddch(pad_ptr, x, y, disp_char);

   if (disp_char == 'z') disp_char = 'a';

   else disp_char++;

  }

 }

2. Теперь перед завершением программы нарисуйте разные области панели в разных местах экрана:

 prefresh(pad_ptr, 5, 7, 2, 2, 9, 9);

 sleep(1);

 prefresh(pad_ptr, LINES + 5, COLS + 7, -5, 5, 21, 19);

 sleep(1);

 delwin(pad_ptr);

 endwin();

 exit(EXIT_SUCCESS);

}

Выполнив эту программу, вы увидите нечто подобное показанному на рис. 6.8.

Рис. 6.8

Приложение, управляющее коллекцией компакт-дисков

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

Все приложение занимает восемь страниц, поэтому мы разделили его на секции и отдельные функции внутри секций. Исходный код программы curses_app.c можно получить на Web-сайте издательства Wrox (http://www.wrox.com/WileyCDA/). Как и все программы из этой книги, оно подчиняется требованиям Общедоступной лицензии проекта GNU.

Примечание

Мы написали эту версию приложения для работы с базой данных компакт-дисков, используя информацию из предыдущих глав. Данное приложение – потомок оригинального сценария командной оболочки, приведенного в главе 2. Оно не перепроектировалось для написания на языке С, поэтому вы увидите в этой версии многие подходы, заимствованные из сценария. Учтите, что в этой реализации есть существенные ограничения, которые мы устраним в последующих модификациях.

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