Лекция 10. Проект "Текстовый редактор"

Проект "Tекстовый редактор" как иллюстрация работы со структурами данных (динамический массив и Л2-список) и концепции "Document--View" (данные, составляющие документ, и их отображение в графическом окне).

Содержание лекции

• Назначение текстового редактора
• Класс "Text"
• Класс "TextLine"
• Класс "TextEdit"
• Обработка клавиатурных событий
• Действия, выполняемые перед любой командой и после нее
• Реализация команд редактора
• Как добавить новую команду редактора
• Работа с графическими контекстами
• Концепция Document -- View
• Задачи по проекту "Текстовый Редактор"

Проект "Текстовый редактор" (TextEdit.zip) иллюстрирует разработку программы, имеющей практическое значение. Рассматриваемый простой текстовый редактор вполне можно использовать в работе, если дополнить его небольшим набором дополнительных команд (типа запоминания-вспоминания фрагментов текста), которые сознательно не были реализованы. Реализация этих дополнительных команд вынесена в качестве задач для экзамена.

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

Текстовый редактор предназначен для просмотра и изменения обычных текстовых файлов. Мы рассматриваем текст как последовательность строк. Это отличается от модели текста, принятой в редакторах типа Microsoft Word, в которых основной единицей является абзац. Такая модель больше подходит для литературных текстов, в которых разбиение текста на строки не имеет значения. Но при редактировании компьютерных программ разбиение на строки крайне важно. К тому же большинство людей привыкло к восприятию текста как последовательности строк еще со времен пишущих машинок (да и книжный текст так выглядит).

Итак, текст -- это последовательность строк. Для хранения текста используется структура данных Л2-список, поскольку нормальной операцией является добавление и удаление строк в середине текста, а в списке такие операции реализованы максимально эффективно. Текст хранится в объекте класса "Text", который выводится из класса "L2List".

    class Text: public L2List { ... };

Класс "Text" хранит элементы типа "Текстовая строка":

    class TextLine: public L2ListHeader { ... };

Класс "TextLine" представляет собой динамический массив символов:

    class TextLine: public L2ListHeader {
        int     capacity;
        int     len;
        char*   str;
        . . .

Класс "TextLine" реализует множество методов, типичных для работы с текстовыми строками (конкатенация, вставка и удаление символов и т.п.). Отметим следующие 2 важнейших метода:

• Конструктор, инициализирующий объект типа "TextLine" по указателю на константную строку символов, терминированную нулем, т.е. по строке в стиле языка C:

      TextLine(const char* line);
  

• Оператор приведения типа "TextLine" к const char *line, т.е. к строке в стиле языка C:

      operator const char*() const;
  

    TextLine t;
    . . .
    if (strcmp(t, "abcd") == 0) { ... }

Класс "TextEdit" реализует текстовый редактор в оконной системе X-Windows. Реализация не использует никаких серьезных библиотек типа Motif или QT. Вместо этого используется класс "GWindow", являющийся несложным C++ интерфейсом к функциям X11. Класс TextEdit наследуется из класса GWindow:

    class TextEdit: public GWindow { ...

    Text text;

    int windowX;        // Window position in the text
    int windowY;
    int windowWidth;    // Window size in characters
    int windowHeight;

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

Координаты курсора вычисляются относительно начала текста (не окна!) и измеряются в колонках и строках:

    int cursorX;        // Cursor position in the text
    int cursorY;

Используемый шрифт хранится в переменной textFont; также хранится его имя в стиле X11 и структура, описывающая свойства шрифта:

    Font textFont;          // Font used
    XFontStruct fontStruct; // Font properties
    TextLine fontName;      // Font name (in X11 form)

static const char* const DEFAULT_TEXT_FONT =
    "-adobe-courier-medium-r-normal-*-14-*-*-*-*-*-koi8-r";

    void loadTextFont();

Метрические параметры шрифта извлекаются из структуры

    XFontStruct fontStruct; // Font properties

    int dx;             // Maximal character advance (width)
    int ascent;         // Character ascent
    int descent;        // Character descent
    int leading;        // Interline skip
    int dy;             // ascent + descent + leading

    dx         = fontStruct.max_bounds.width;
    ascent     = fontStruct.max_bounds.ascent;
    descent    = fontStruct.max_bounds.descent;
    int height = ascent + descent;
    leading    = height / 8;
    if (leading <= 2) leading = 2;
    dy         = ascent + descent + leading;

Размеры отступов от краев окна, т.е. поля хранятся в переменных leftMargin, topMargin, rightMargin, bottomMargin, statusLineMargin. Верхнее поле topMargin включает в себя высоту статусной строки. Статусная строка изображается в верхней части окна редактора и содержит разную полезную информацию, например, текущие координаты курсора.

В нашем редакторе работа с меню не реализована (это дополнительно усложнило бы проект). Поэтому все команды выполняются нажатиями клавиш, можно использовать аккорды (например, Ctrl+PageUp). Все методы, реализующие команды редактора, вызываются из виртуального метода

    virtual void onKeyPress(XEvent& event);

    unsigned int modState = event.xkey.state;
    unsigned int keycode = event.xkey.keycode;

Число "event.xkey.keycode" представляет собой так называемый скан-код клавиши, он зависит только от клавиши и не зависит от состояния модификаторов, включения или выключения русификатора клавиатуры и т.п. Вместе с тем полагаться на значения скан-кодов опасно, поскольку они могут зависеть от конкретных X-терминалов, версии операционной системы и т.п. Вместо скан-кодов следует использовать клавиатурные символы (тип "KeySym"), которые определены независимо от версий терминалов и операционных систем. Определения клавиатурных символов содержатся в файле "/usr/include/X11/keysymdef.h". Например, символ клавиши "Стрелка вниз" равен константе "XK_Down", символ стрелки вниз на дополнительной правой клавиатуре равен константе "XK_KP_Down" ("XK" расшифровывается как "X11 Keyboard", "KP" -- как "Key Pad"). Клавиатурный символ, соответствующий скан-коду и модификаторам, вычисляется с помощью стандартной функции "XLookupString":

    KeySym keySymbol;
    char keyName[256];
    int keyNameLen;

    keyNameLen = XLookupString(
        &(event.xkey), keyName, 255, &keySymbol, 0
    );

    #define XK_Down 0xFF54

    #define XK_Cyrillic_a 0x6c1

Если клавиша -- это обычный латинский символ или русская буква, то ее код помещается в переменную

    int lastChar;       // The character typed

    void onCharTyped(); // Insert a character typed

    static const struct CommandDsc editorCommands[];

    struct CommandDsc {
        KeySym keysym;          // X11 Key symbol
        unsigned int state;     // State of Shift, Control, Alt, etc.
        unsigned int stateMask; // Which bits in "state" are important
        bool change;            // The command changes a text
        void (TextEdit::*method)(); // Pointer to editor method
    };

    {XK_Home, 0, ControlMask, false, &TextEdit::onHome},
    {XK_Home, ControlMask, ControlMask, false, &TextEdit::onTextBeg},

Последнее поле "method" структуры CommandDsc -- это указатель на метод класса TextEdit, который выполняет соответствующую команду. В нашем примере перемещение курсора в начало строки выполняется с помощью метода onHome(), перемещение курсора в начало текста -- с помощью метода onTextBeg().

Итак, суммируем все вышесказанное. При обработке клавиатурного события в методе onKeyPress

• сначала определяется клавиатурный символ клавиши с помощью системного вызова XLookupString;
• затем осуществляется поиск клавиатурной команды в массиве описателей команд редактора editorCommands;
• если команда найдена в массиве, то вызывается соответствующий метод редактора, выполняющий ее. Указатель на этот метод содержится в описателе команды;
• если команда не найдена и если нажатая клавиша -- это обычный ASCII-символ или русская буква, то символ помещается в переменную lastChar и вызывается метод onCharTyped().

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

Перед выполнением любой команды вызывается метод

    void preProcessCommand();

    void postProcessCommand();

Метод "preProcessCommand()"

Этот метод

• запрещает всякий ввод с клавиатуры в процессе выполнения команд. Для этого логическая переменная "inputDisabled" устанавливается в true;
• стирается изображение курсора, которое может помешать корректной перерисовке экрана при выполнении команды (вообще, всегда, когда ввод запрещен, курсор должен быть стерт).

void TextEdit::preProcessCommand() {
    inputDisabled = true;                      // Disable any input
    drawCursor(cursorX, cursorY, false, true); // Remove cursor
}

Метод "postProcessCommand()"

В этом методе выполняются следующие действия:

• если команда изменяет текст, то факт изменения текста запоминается в логической переменной "textChanged", которой присваивается значение "true";
• если в результате выполнения команды курсор вышел за пределы окна (речь идет о координатах курсора, сам курсор в процессе выполнения команды не изображается!), то нужно изменить положение окна в тексте так, чтобы курсор снова вошел в окно. Для этого вызывается метод

      void scrollToCursor();
  

  Окно как бы гонится за курсором, пытаясь вновь поймать его в свою рамку. При перемещении окна по тексту изображение в окне "роллируется", т.е. как бы прокручивается по вертикали или горизонтали. Можно было бы просто изменить положение окна в тексте и перерисовать окно, однако это привело бы к неприятному мерцанию при полной перерисовке. Поэтому вместо полной перерисовки используются возможности графической системы X-Windows, позволяющей копировать прямоугольные области окна из одной позиции в другую (или даже между различными окнами!). При этом неприятного для глаз мерцания не происходит. Перерисовывается только та часть текста в окне, которая заново появляется, как бы "выезжает" на экран из-за пределов окна. Метод "scrollToCursor" реализован с помощью методов

      void scrollLeft(int n);
      void scrollRight(int n);
      void scrollUp(int n);
      void scrollDown(int n);
  

  которые роллируют окно в соответствующем направлении на n позиций;
• указатель в тексте устанавливается в соответствии с координатой Y курсора (напомним, что текст представляет собой Л2-список строк, указатель списка располагается между элементами, позицией указателя называется общее число элементов до указателя);
• снимается запрет на ввод символов с клавиатуры; для этого логическая переменная inputDisabled устанавливается в false;
• рисуется курсор, который до этого был стерт в методе "preProcessCommand()";
• наконец, перерисовывается статусная строка в верхней части окна редактора. Статусная строка содержит разную полезную информацию типа координат курсора, сообщения о том, что текст модифицирован, подсказку, как выйти из редактора и т.п.

void TextEdit::postProcessCommand() {
    if (m_Window == 0) // Window is destroyed => return
        return;

    if (textChanged)
        textSaved = false;

    // Scroll the window to the cursor, if necessary
    if (
        cursorX < windowX || cursorX > windowX + windowWidth - 1 ||
        cursorY < windowY || cursorY > windowY + windowHeight - 1
    ) {
        // Cursor is removed at the moment!
        scrollToCursor();
    }

    // Set pointer in the text
    text.setPointer(cursorY);

    inputDisabled = false;

    drawCursor(cursorX, cursorY, true, true);
    drawStatusLine(true);
}

Каждой команде редактора соответствует метод класса "TextEdit", выполняющий эту команду. Так как мы вынесли все общие действия, выполняемые до и после любой команды, в отдельные методы "preProcessCоmmand" и "postProcessCommand", то реализация некоторых команд редактора становится до смешного простой. Например, метод, реализующий нажатие правой стрелки, выглядит следующим образом:

void TextEdit::onRight() {
    ++cursorX;
}

void TextEdit::onLeft() {
    if (cursorX > 0)
        --cursorX;
}

void TextEdit::onEnd() {
    if (cursorY >= text.size()) {
        cursorX = 0;
    } else {
        cursorX = text.getLine(cursorY).length();
    }
}

[* End of text *]

В противном случае мы получаем ссылку на текущую строку текста

    text.getLine(cursorY)

    cursorX = text.getLine(cursorY).length();

Наконец, рассмотрим команду, изменяющую текст, например, команду "удалить текущую строку", выполняемую по нажатию Shift+Delete или Ctrl+K:

void TextEdit::onDeleteLine() {
    if (cursorY >= text.size())
        return;
    text.setPointer(cursorY);
    text.removeAfter();
    redrawTextRectangle(0, cursorY, INT_MAX, INT_MAX);
}

    void redrawTextRectangle(int x, int y, int w, int h);

    redrawTextRectangle(0, cursorY, INT_MAX, INT_MAX);

Аналогично реализуются и другие команды редактора.

Для добавления новой команды нужно:

• придумать, с помощью какой клавиши будет выполняться команда. Можно реализовать несколько разных способов выполнить одну и ту же команду (например, в нашем редакторе можно удалить строку по Shift+Delete или по Ctrl+K). Пусть, к примеру, мы хотим добавить команду "На экран вниз". Естественно было бы положить эту команду на клавишу PageDown, соответствующий клавиатурный символ определен в системе X11 как XK_Page_Down (см. заголовочный файл "/usr/include/X11/keysymdef.h");
• придумать название метода, реализующего эту команду, и добавить описание прототипа этого метода в описание интерфейса класса TextEdit, т.е. в файл "TextEdit.h". В нашем примере естественно было бы назвать метод "onPageDown", следовательно, в описание класса "TextEdit" добавляется строка

      void onPageDown();
  

• добавить описатель новой команды в таблицу описателей команд редактора, т.е. в массив "editorCommands". Этот массив инициализируется в файле "TextEdit.cpp", содержащем реализацию класса "TextEdit".

  const struct TextEdit::CommandDsc TextEdit::editorCommands[] = { ...
  

  В нашем примере в список инициализации этого массива добавляется строка

      {XK_Page_Down, 0, 0, false, &TextEdit::onPageDown}
  

  Нули в полях state и stateMask структуры CommandDsc означают, что команда будет выполняться независимо от состояния модификаторов клавиатуры (Shift, Ctrl, Alt и т.д.). Если мы хотим зарезервировать нажатие Shift+PageDown для какой-либо другой команды, то мы должны вместо этого написать строку

      {XK_Page_Down, 0, ShiftMask, false, &TextEdit::onPageDown}
  

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

  Константа "false" в четвертом поле структуры означает, что данная команда не изменяет текст;

• наконец, надо реализовать метод, выполняющий добавленную команду. Реализация метода записывается в файле "TextEdit.cpp". В нашем случае она будет выглядеть приблизительно так:

  void TextEdit::onPageDown() {
      if (windowY < text.size() - windowHeight) { // If not the last page
          windowY += windowHeight; // then move the window down,
          cursorY += windowHeight; // move the cursor down,
          redraw();                // redraw all window
      } else {
          cursorY = text.size();   // else move cursor to the end of text
      }
  }
  

Графический контекст создается для рисования в окне. Все системные функции рисования имеют графический контекст в качестве одного из аргументов. Например, системная функция рисования линии имеет прототип

int XDrawLine(
    Display* display, Drawable window, GC graphicContex,
    int x1, int y1, int x2, int y2
);

Зачем нужен графический контекст? Он хранит текущие установки, влияющие на рисование, например, текущий цвет, фон, текущий шрифт и т.п. Для нас наиболее важно, что графический контекст устанавливает область клипирования (clip region), т.е. ту область, которой ограничивается рисование. На окно как бы накладывается пленка, в которой прорезаны отверстия, соответствующие области клипирования. Мы можем пытаться рисовать во всем окне, но следы краски останутся только там, где нет пленки.

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

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

    void drawLine(int x1, int y1, int x2, int y2);

Если, однако, мы хотим нарисовать часть окна, не перерисовывая все окно (чтобы не было неприятного мерцания), то иногда нельзя использовать графический контекст, связанный с окном, поскольку в нем текущая область клипирования может быть ограничена. Поэтому можно временно создать новый графический контекст, установить его в качестве используемого графического контекста окна (сохранив при этом предыдущий контекст), выполнить необходимое рисование, восстановить предыдущий графический контекст окна и затем удалить временный графический контекст. Именно такие действия выполняются при рисовании курсора или статусной строки редактора в случае, когда последний аргумент соответствующего метода рисования равен "true" (по умолчанию этот параметр равен "false"):

    void drawCursor(
        int cx, int cy, bool on, bool createGC = false
    );
    void drawStatusLine(bool createGC = false);

void TextEdit::drawStatusLine(bool createGC /*= false*/) {
    GC savedGC;
    if (createGC) {
        // Save the previous graphic contex, create a temporary GC
        savedGC = m_GC;
        m_GC = XCreateGC(m_Display, m_Window, 0, 0);
        setFont(textFont);
    }

    // ... рисование статусной строки ...

    if (createGC) {
        // Release the temporary GC, restore the previous GC
        XFreeGC(m_Display, m_GC);
        m_GC = savedGC;
    }
}

Подобный прием применяется при программировании в большинстве графических систем (Unix X-Windows, MS Windows и т.п.). Нормальное рисование сосредоточено в методе, обрабатывающем сообщение типа Expose (или WM_PAINT в системе MS Windows). Но если мы хотим что-то быстро нарисовать, не посылая сообщение Expose окну, то мы должны создать временный графический контекст, нарисовать что-то с его помощью, а затем удалить его.

• программа -- это инструмент, с помощью которого пользователь работает с документом;
• документ -- это файл или набор файлов на диске. В процессе работы он загружается в память, по окончании записывается обратно на диск;
• программа хранит документ в объекте типа "Document". (Базовый класс, представляющий документ, может иметь разные названия, например, "class CDocument" в MFC.) При написании конкретной программы класс, представляющий документ, должен быть выведен из базового класса;
• документ -- это только набор данных в памяти, но не их отображение в каком-либо окне. Для представления документа используется класс типа "View" (графическое изображение документа), ему соответствует окно в оконной системе. Один документ может иметь несколько отображений, которые даже могут иметь разные типы -- как бы несколько разных точек зрения на один и тот же объект. Все конкретные классы типа "View" должны выводиться из базового класса ("class CView" в случае MFC);
• при изменении документа, т.е. модификации данных в памяти, нужно изменить отображение модифицированной части документа во всех окнах, соответствующих различным объектам типа View для данного документа. Для этого проще всего послать им сообщения о перерисовке, полной или частичной (в последнем случае программа должна вычислить, какой прямоугольник внутри каждого View должен быть перерисован при изменении документа). Для посылки сообщения окну используется стандартный механизм передачи сообщений, который является основой любой оконной системы.

В случае нашего текстового редактора мы не выделяем отдельно класс "Документ" и класс "Отображение документа", поскольку мы не предусматриваем возможности открытия двух разнах окон для одного и того же текстового файла. Роль документа выполняет у нас объект "text" типа "Text" (Л2-список строк), который в нашем случае является членом класса "TextEdit". Объект "View" -- это сам класс "TextEdit", который наследует все свойства графического окна ("class GWindow") и который предназначен для изображения и изменения текста.

Хотя в нашем случае документ и его отображение не разделены в явном виде, следует хотя бы мысленно различать эти две аспекта реализации приложения: работа с данными в памяти и их отображение в графическом окне. Графическое окно -- это всегда отображение данных, содержащихся в документе. Поэтому, например, бессмысленно что-то рисовать в окне, не меняя параллельно данных в памяти. Аналогично, при изменении данных в памяти следует перерисовать ту часть окна (или окон), которая изображает эти данные.

Задачи по проекту "Текстовый Редактор"

Конец лекции